Changeset 587 for GPL/trunk/drv32


Ignore:
Timestamp:
Jun 9, 2016, 10:38:13 PM (9 years ago)
Author:
David Azarewicz
Message:

Rearrange directory structure
rework makefiles
cleanup files

Location:
GPL/trunk/drv32
Files:
5 added
5 deleted
6 edited

Legend:

Unmodified
Added
Removed

  • GPL/trunk/drv32/dispatch.c

    r542 r587  
    3030#include <devhelp.h>
    3131#include <devtype.h>
    32 #include <devrp.h>
     32#include <strategy.h>
    3333#include "devown.h"
    3434#include <ossidc.h>
    … …  
    3636#include <version.h>
    3737
    38 extern "C" int cdecl printk(const char * fmt, ...);
     38extern int cdecl printk(const char * fmt, ...);
    3939//******************************************************************************
    4040// Dispatch IOCtl requests received from the Strategy routine
    4141//******************************************************************************
    42 extern "C" int GetUniaudCardInfo(ULONG deviceid, void *info);
    43 extern "C" int GetUniaudControlNum(ULONG deviceid);
    44 extern "C" int GetUniaudControls(ULONG deviceid, void *pids);
    45 extern "C" int GetUniaudControlInfo(ULONG deviceid, ULONG id, void *info);
    46 extern "C" int GetUniaudControlValueGet(ULONG deviceid, ULONG id, void *value);
    47 extern "C" int GetUniaudControlValuePut(ULONG deviceid, ULONG id, void *value);
    48 extern "C" int GetNumberOfPcm(int card_id);
    49 extern "C" int GetUniaudPcmCaps(ULONG deviceid, void *caps);
    50 extern "C" int SetPCMInstance(int card_id, int pcm);
    51 extern "C" int WaitForControlChange(int card_id, int timeout);
    52 extern "C" int GetNumberOfCards(void);
    53 extern "C" OSSRET OSS32_WaveOpen(ULONG deviceid, ULONG streamtype, OSSSTREAMID *pStreamId, int pcm, USHORT fileid);
    54 extern "C" OSSRET OSS32_WaveClose(OSSSTREAMID streamid);
    55 extern "C" int UniaudIoctlHWRefine(OSSSTREAMID streamid, void *pHwParams);
    56 extern "C" int UniaudIoctlHWParamSet(OSSSTREAMID streamid, void *pHwParams);
    57 extern "C" int UniaudIoctlSWParamSet(OSSSTREAMID streamid, void *pSwParams);
    58 extern "C" int UniaudIoctlPCMStatus(OSSSTREAMID streamid, void *pstatus);
    59 extern "C" int UniaudIoctlPCMWrite(OSSSTREAMID streamid, char *buf, int size);
    60 extern "C" int UniaudIoctlPCMRead(OSSSTREAMID streamid, char *buf, int size);
    61 extern "C" int UniaudIoctlPCMPrepare(OSSSTREAMID streamid);
    62 extern "C" int UniaudIoctlPCMStart(OSSSTREAMID streamid);
    63 extern "C" int UniaudIoctlPCMDrop(OSSSTREAMID streamid);
    64 extern "C" int UniaudIoctlPCMResume(OSSSTREAMID streamid, int pause);
    65 extern "C" void UniaudCloseAll(USHORT fileid);
    66 extern "C" int WaitForPCMInterrupt(void *file, int timeout);
    67 extern "C" int unlock_all;
    68 extern "C" int OSS32_CloseUNI16(void);
    69 extern "C" int UniaudCtlGetPowerState(ULONG deviceid, void *state);
    70 extern "C" int UniaudCtlSetPowerState(ULONG deviceid, void *state);
     42extern int GetUniaudCardInfo(ULONG deviceid, void *info);
     43extern int GetUniaudControlNum(ULONG deviceid);
     44extern int GetUniaudControls(ULONG deviceid, void *pids);
     45extern int GetUniaudControlInfo(ULONG deviceid, ULONG id, void *info);
     46extern int GetUniaudControlValueGet(ULONG deviceid, ULONG id, void *value);
     47extern int GetUniaudControlValuePut(ULONG deviceid, ULONG id, void *value);
     48extern int GetNumberOfPcm(int card_id);
     49extern int GetUniaudPcmCaps(ULONG deviceid, void *caps);
     50extern int SetPCMInstance(int card_id, int pcm);
     51extern int WaitForControlChange(int card_id, int timeout);
     52extern int GetNumberOfCards(void);
     53extern OSSRET OSS32_WaveOpen(ULONG deviceid, ULONG streamtype, OSSSTREAMID *pStreamId, int pcm, USHORT fileid);
     54extern OSSRET OSS32_WaveClose(OSSSTREAMID streamid);
     55extern int UniaudIoctlHWRefine(OSSSTREAMID streamid, void *pHwParams);
     56extern int UniaudIoctlHWParamSet(OSSSTREAMID streamid, void *pHwParams);
     57extern int UniaudIoctlSWParamSet(OSSSTREAMID streamid, void *pSwParams);
     58extern int UniaudIoctlPCMStatus(OSSSTREAMID streamid, void *pstatus);
     59extern int UniaudIoctlPCMWrite(OSSSTREAMID streamid, char *buf, int size);
     60extern int UniaudIoctlPCMRead(OSSSTREAMID streamid, char *buf, int size);
     61extern int UniaudIoctlPCMPrepare(OSSSTREAMID streamid);
     62extern int UniaudIoctlPCMStart(OSSSTREAMID streamid);
     63extern int UniaudIoctlPCMDrop(OSSSTREAMID streamid);
     64extern int UniaudIoctlPCMResume(OSSSTREAMID streamid, int pause);
     65extern void UniaudCloseAll(USHORT fileid);
     66extern int WaitForPCMInterrupt(void *file, int timeout);
     67extern int unlock_all;
     68extern int OSS32_CloseUNI16(void);
     69extern int UniaudCtlGetPowerState(ULONG deviceid, void *state);
     70extern int UniaudCtlSetPowerState(ULONG deviceid, void *state);
    7171
    7272typedef UCHAR LOCKHANDLE[12];
    … …  
    8585#pragma pack()
    8686
    87 ULONG StratIOCtl(RP __far* _rp)
     87ULONG StratIOCtl(REQPACKET __far* rp)
    8888{
    89     RPIOCtl __far* rp = (RPIOCtl __far*)_rp;
    9089    USHORT rc = 0;;
    9190    LOCKHANDLE lhParm, lhData;
    … …  
    9695    ULONG ctl_id;
    9796
    98     if (rp->Category != CAT_IOCTL_OSS32)
    99     {
    100 //        printk("not our cat %x. func %x\n", rp->Category, rp->Function);
     97    if (rp->ioctl.bCategory != CAT_IOCTL_OSS32)
     98    {
     99        //printk("not our cat %x. func %x\n", rp->Category, rp->Function);
    101100        // not our category, exit with error
    102         return (RPERR_COMMAND | RPDONE);
     101        return (RPERR_BADCOMMAND | RPDONE);
    103102    }
    104103
    105 #ifdef DEBUG
     104    #ifdef DEBUG
    106105    //printk("StratIOCtl 0x%x\n", rp->Function);
    107 #endif
    108 //    printk("cmd: %x, len: %i, pack: %x\n",rp->Function, rp->ParmLength, rp->ParmPacket);
     106    #endif
     107    //    printk("cmd: %x, len: %i, pack: %x\n",rp->Function, rp->ioctl.usParmLen, rp->ParmPacket);
    109108    // work with Parm Packet
    110     if ((rp->ParmLength != 0 ||
    111          rp->Function == IOCTL_OSS32_ATTACH /*16 bit ioctl*/) &&
    112         ((rp->ParmPacket & 0xfffcffff) != 0))
     109    if ((rp->ioctl.usParmLen != 0 ||
     110         rp->ioctl.bFunction == IOCTL_OSS32_ATTACH /*16 bit ioctl*/) &&
     111        ((rp->ioctl.pvParm & 0xfffcffff) != 0))
    113112    {
    114113        // got Parm Packet
    115         rc = DevVirtToLin((USHORT)((ULONG)(rp->ParmPacket) >> 16),
    116                           (ULONG)((USHORT)(rp->ParmPacket)),
     114        rc = DevVirtToLin((USHORT)((ULONG)(rp->ioctl.pvParm) >> 16),
     115                          (ULONG)((USHORT)(rp->ioctl.pvParm)),
    117116                          (UCHAR * __far *)&linParm);
    118117
    119118        if (rc == 0)
    120119        {
    121             if (rp->Function == IOCTL_OSS32_ATTACH)
    122             {
    123                 rc = DevVMLock(VMDHL_LONG,
    124                            (ULONG)linParm,
    125                            4,
    126                            (LINEAR)-1L,
    127                            lhParm,
    128                                (UCHAR*)&pages);
    129             }else
    130             {
    131                 rc = DevVMLock(VMDHL_LONG,
    132                            (ULONG)linParm,
    133                            rp->ParmLength,
    134                            (LINEAR)-1L,
    135                                lhParm,
    136                                (UCHAR*)&pages);
     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);
    137127            }
    138128
    … …  
    154144
    155145    // work with Data Packet
    156     if ((rp->DataLength != 0) &&
    157         ((rp->DataPacket & 0xfffcffff) != 0))
     146    if ((rp->ioctl.usDataLen != 0) &&
     147        ((rp->ioctl.pvData & 0xfffcffff) != 0))
    158148    {
    159149        // got Data Packet
    160         rc = DevVirtToLin((USHORT)((ULONG)(rp->DataPacket) >> 16),
    161                           (ULONG)((USHORT)(rp->DataPacket)),
     150        rc = DevVirtToLin((USHORT)((ULONG)(rp->ioctl.pvData) >> 16),
     151                          (ULONG)((USHORT)(rp->ioctl.pvData)),
    162152                          (UCHAR * __far *)&linData);
    163153        if (rc == 0)
    164154        {
    165             rc = DevVMLock(VMDHL_LONG,
    166                            (ULONG)linData,
    167                            rp->DataLength,
    168                            (LINEAR)-1L,
    169                            lhData,
     155            rc = DevVMLock(VMDHL_LONG, (ULONG)linData, rp->ioctl.usDataLen, (LINEAR)-1L, lhData,
    170156                           (UCHAR*)&pages);
    171157        } else
    … …  
    193179    rc = RPDONE; // ok by default
    194180
    195     switch(rp->Function)
     181    switch(rp->ioctl.bFunction)
    196182    {
    197183    case IOCTL_OSS32_ATTACH:
    … …  
    199185            card_id = (ULONG) *linParm;
    200186            // Check if audio init was successful
    201             if (OSS32_QueryNames(card_id, NULL, 0,
    202                                  NULL, 0, FALSE) != OSSERR_SUCCESS)
     187            if (OSS32_QueryNames(card_id, NULL, 0, NULL, 0, FALSE) != OSSERR_SUCCESS)
    203188            {
    204189                rc = RPERR_GENERAL | RPDONE;
    … …  
    208193    case IOCTL_OSS32_VERSION:
    209194        {
    210             if (rp->DataLength < sizeof(ULONG))
     195            if (rp->ioctl.usDataLen < sizeof(ULONG))
    211196            {
    212197                // invalid Data Pkt
    … …  
    221206    case IOCTL_OSS32_GET_PCM_NUM:
    222207        {
    223             if (rp->DataLength < sizeof(ULONG))
     208            if (rp->ioctl.usDataLen < sizeof(ULONG))
    224209            {
    225210                // invalid Data Pkt
    … …  
    234219
    235220    case IOCTL_OSS32_CARDS_NUM:
    236         if (rp->DataLength < sizeof(ULONG))
     221        if (rp->ioctl.usDataLen < sizeof(ULONG))
    237222        {
    238223            // invalid Data Pkt
    … …  
    246231    case IOCTL_OSS32_PCM_CAPS:
    247232        {
    248             if (rp->DataLength < sizeof(ULONG))
     233            if (rp->ioctl.usDataLen < sizeof(ULONG))
    249234            {
    250235                // invalid Data Pkt
    … …  
    259244    case IOCTL_OSS32_CARD_INFO:
    260245        {
    261             if (rp->DataLength < sizeof(ULONG))
     246            if (rp->ioctl.usDataLen < sizeof(ULONG))
    262247            {
    263248                // invalid Data Pkt
    … …  
    272257    case IOCTL_OSS32_GET_POWER_STATE:
    273258        {
    274             if (rp->DataLength < sizeof(ULONG))
     259            if (rp->ioctl.usDataLen < sizeof(ULONG))
    275260            {
    276261                // invalid Data Pkt
    … …  
    285270    case IOCTL_OSS32_SET_POWER_STATE:
    286271        {
    287             if (rp->DataLength < sizeof(ULONG))
     272            if (rp->ioctl.usDataLen < sizeof(ULONG))
    288273            {
    289274                // invalid Data Pkt
    … …  
    298283    case IOCTL_OSS32_GET_CNTRLS_NUM:
    299284        {
    300             if (rp->DataLength < sizeof(ULONG))
     285            if (rp->ioctl.usDataLen < sizeof(ULONG))
    301286            {
    302287                // invalid Data Pkt
    … …  
    313298    case IOCTL_OSS32_GET_CNTRLS:
    314299        {
    315             if (rp->DataLength < sizeof(ULONG))
     300            if (rp->ioctl.usDataLen < sizeof(ULONG))
    316301            {
    317302                // invalid Data Pkt
    … …  
    327312        {
    328313
    329             if (rp->DataLength < sizeof(ULONG))
    330             {
    331                 // invalid Data Pkt
    332                 rc = RPERR_PARAMETER | RPDONE;
    333                 break;
    334             }
    335 
    336             if (rp->ParmLength < sizeof(ULONG))
     314            if (rp->ioctl.usDataLen < sizeof(ULONG))
     315            {
     316                // invalid Data Pkt
     317                rc = RPERR_PARAMETER | RPDONE;
     318                break;
     319            }
     320
     321            if (rp->ioctl.usParmLen < sizeof(ULONG))
    337322            {
    338323                // invalid Data Pkt
    … …  
    351336    case IOCTL_OSS32_CNTRL_GET:
    352337        {
    353             if (rp->DataLength < sizeof(ULONG))
    354             {
    355                 // invalid Data Pkt
    356                 rc = RPERR_PARAMETER | RPDONE;
    357                 break;
    358             }
    359 
    360             if (rp->ParmLength < sizeof(ULONG))
     338            if (rp->ioctl.usDataLen < sizeof(ULONG))
     339            {
     340                // invalid Data Pkt
     341                rc = RPERR_PARAMETER | RPDONE;
     342                break;
     343            }
     344
     345            if (rp->ioctl.usParmLen < sizeof(ULONG))
    361346            {
    362347                // invalid Data Pkt
    … …  
    376361        {
    377362
    378             if (rp->DataLength < sizeof(ULONG)) {
    379                 // invalid Data Pkt
    380                 rc = RPERR_PARAMETER | RPDONE;
    381                 break;
    382             }
    383 
    384             if (rp->ParmLength < sizeof(ULONG)) {
     363            if (rp->ioctl.usDataLen < sizeof(ULONG)) {
     364                // invalid Data Pkt
     365                rc = RPERR_PARAMETER | RPDONE;
     366                break;
     367            }
     368
     369            if (rp->ioctl.usParmLen < sizeof(ULONG)) {
    385370                // invalid Data Pkt
    386371                rc = RPERR_PARAMETER | RPDONE;
    … …  
    399384        {
    400385
    401             if (rp->ParmLength < sizeof(ULONG))
     386            if (rp->ioctl.usParmLen < sizeof(ULONG))
    402387            {
    403388                // invalid Data Pkt
    … …  
    414399    case IOCTL_OSS32_CNTRL_WAIT:
    415400        {
    416             if (rp->DataLength < sizeof(ULONG))
     401            if (rp->ioctl.usDataLen < sizeof(ULONG))
    417402            {
    418403                // invalid Data Pkt
    … …  
    430415            ioctl_pcm *pcm = (ioctl_pcm *)linParm;
    431416            // close all pcms from uniaud16 first
    432             pcm->ret = OSS32_WaveOpen(pcm->deviceid, pcm->streamtype, pData,  pcm->pcm, rp->FileID);
     417            pcm->ret = OSS32_WaveOpen(pcm->deviceid, pcm->streamtype, pData,  pcm->pcm, rp->ioctl.usSysFileNum);
    433418        }
    434419        break;
    … …  
    536521    default:
    537522        {
    538             printk("invalid function code %i\n",rp->Function);
     523            printk("invalid function code %i\n",rp->ioctl.bFunction);
    539524            // invalid function code
    540525            rc = RPERR_PARAMETER | RPDONE;
    … …  
    561546// Dispatch Close requests received from the strategy routine
    562547//******************************************************************************
    563 ULONG StratClose(RP __far* _rp)
     548ULONG StratClose(REQPACKET __far* rp)
    564549{
    565   RPOpenClose __far* rp = (RPOpenClose __far*)_rp;
    566 
    567550  // only called if device successfully opened
    568 //  printk("strat close\n");
     551  //  printk("strat close\n");
    569552  numOS2Opens--;
    570553
    571   UniaudCloseAll(rp->FileID);
     554  UniaudCloseAll(rp->open_close.usSysFileNum);
    572555
    573556  if (numOS2Opens == 0) {
    574         deviceOwner = DEV_NO_OWNER;
     557          deviceOwner = DEV_NO_OWNER;
    575558  }
    576559  return(RPDONE);
    577560}
    578 //******************************************************************************
    579 //******************************************************************************
     561

  • GPL/trunk/drv32/idc.c

    r549 r587  
    2323 */
    2424
    25 extern "C" {               // 16-bit header files are not C++ aware
     25//DAZ extern "C" {               // 16-bit header files are not C++ aware
    2626#define INCL_NOPMAPI
    2727#define INCL_DOSINFOSEG
    2828#include <os2.h>
    29 }
     29//DAZ }
    3030#include <devtype.h>
    3131#include <devhelp.h>
    32 #include <strategy.h>
     32//#include <strategy.h>
    3333#include <ossidc32.h>
    3434#include <irqos2.h>
    … …  
    3838//16:32 address of 16 bits pdd idc handler
    3939IDC16_HANDLER idc16_PddHandler = 0;
    40 extern "C" int pcm_device;
     40extern int pcm_device;
    4141WORD32 OSS32IDC(ULONG cmd, PIDC32_PACKET pPacket);
    42 extern "C" BOOL fRewired; //pci.c
     42extern BOOL fRewired; //pci.c
    4343
    4444//packet pointer must reference a structure on the stack
    4545
    46 OSSRET AlsaIDC(ULONG cmd, ULONG packet);
    4746#pragma aux AlsaIDC "ALSA_IDC" parm reverse [ecx edx]
    4847OSSRET AlsaIDC(ULONG cmd, ULONG packet)

  • GPL/trunk/drv32/init.c

    r535 r587  
    3131#include <devhelp.h>
    3232#include <devtype.h>
    33 #include <devrp.h>
     33//DAZ #include <devrp.h>
     34#include <strategy.h>
    3435#include "devown.h"
    3536#include <version.h>
    … …  
    6768} MSG_TABLE;
    6869
    69 extern "C" FARPTR16 MSG_TABLE32;
    70 extern "C" char szLastALSAError1[];
    71 extern "C" char szLastALSAError2[];
    72 extern "C" int sprintf (char *buffer, const char *format, ...);
    73 
    74 extern "C" APIRET APIENTRY DOS16OPEN(PSZ pszFileName, PHFILE phf, PULONG pulAction, ULONG cbFile, ULONG ulAttribute, ULONG fsOpenFlags, ULONG fsOpenMode, PEAOP2 peaop2 );
    75 extern "C" APIRET APIENTRY DOS16CLOSE(HFILE hFile);
    76 extern "C" APIRET APIENTRY DOS16WRITE(HFILE hFile, PVOID pBuffer, ULONG cbWrite, PULONG pcbActual);
    77 extern "C" void SaveBuffer(void);
     70extern FARPTR16 MSG_TABLE32;
     71extern char szLastALSAError1[];
     72extern char szLastALSAError2[];
     73extern int sprintf (char *buffer, const char *format, ...);
     74
     75extern APIRET APIENTRY DOS16OPEN(PSZ pszFileName, PHFILE phf, PULONG pulAction, ULONG cbFile, ULONG ulAttribute, ULONG fsOpenFlags, ULONG fsOpenMode, PEAOP2 peaop2 );
     76extern APIRET APIENTRY DOS16CLOSE(HFILE hFile);
     77extern APIRET APIENTRY DOS16WRITE(HFILE hFile, PVOID pBuffer, ULONG cbWrite, PULONG pcbActual);
     78extern void SaveBuffer(void);
    7879
    7980#define VMDHA_FIXED             0x0002
    8081
    81 extern "C" APIRET VMAlloc(ULONG size, ULONG flags, char NEAR* *pAddr);
     82extern APIRET VMAlloc(ULONG size, ULONG flags, char NEAR* *pAddr);
    8283
    8384//Print messages with DosWrite when init is done or has failed (see startup.asm)
    … …  
    8990
    9091  for(i=0;i<length;i++) {
    91         str16[msg->MsgLength + i] = str[i];
     92  str16[msg->MsgLength + i] = str[i];
    9293  }
    9394  str16[msg->MsgLength + length] = 0;
    … …  
    116117    segsize = OffsetFinalDS32 - ((OffsetBeginDS32) & ~0xFFF);
    117118    if(segsize & 0xFFF) {
    118             segsize += PAGE_SIZE;
     119      segsize += PAGE_SIZE;
    119120    }
    120121    segsize &= ~0xFFF;
    … …  
    134135                   (LINEAR)&PgCount)) {
    135136#endif
    136             return(1);
     137      return(1);
    137138    }
    138139    /*
    … …  
    141142    segsize = OffsetFinalCS32 - ((OffsetBeginCS32) & ~0xFFF);
    142143    if(segsize & 0xFFF) {
    143             segsize += PAGE_SIZE;
     144      segsize += PAGE_SIZE;
    144145    }
    145146    segsize &= ~0xFFF;
    … …  
    159160                 (LINEAR)&PgCount)) {
    160161#endif
    161             return(1);
     162      return(1);
    162163    }
    163164    return 0;
    … …  
    195196#endif
    196197// Initialize device driver
    197 WORD32 DiscardableInit(RPInit __far* rp)
    198 {
    199     char        debugmsg[64];
    200     char FAR48 *args;
    201 
    202 #ifdef KEE
    203     GetTKSSBase();
    204 #endif
    205 
    206     if(LockSegments()) {
    207         WriteString(ERR_ERROR, sizeof(ERR_ERROR)-1);
    208         WriteString(ERR_LOCK, sizeof(ERR_LOCK)-1);
    209         return RPDONE | RPERR_COMMAND;
    210     }
    211 
    212         DebugLevel = 1;
    213     rp->Out.FinalCS = 0;
    214     rp->Out.FinalDS = 0;
    215 
    216         if ( szprintBuf == 0 ) {
    217                 VMAlloc( DBG_MAX_BUF_SIZE, VMDHA_FIXED, &szprintBuf );
    218                 if (szprintBuf) {
    219                         memset( szprintBuf, 0, DBG_MAX_BUF_SIZE );
    220                         wrOffset= 0;
    221                 }
    222         }
    223         if (!HeapInit(HEAP_SIZE)) {
    224                 rprintf(("HeapInit failed!"));
    225         }
    226 
    227     args = MAKE_FARPTR32(rp->In.Args);
    228     GetParms(args);
    229 
    230 #ifdef DEBUG
    231         rprintf(("Uniaud32 version %s-DEBUG",UNIAUD_VERSION));
    232 #else
    233         rprintf(("Uniaud32 version %s",UNIAUD_VERSION));
    234 #endif
    235 
    236     if(fVerbose) {
    237         WriteString(szALSA, sizeof(szALSA)-1);
    238         WriteString(szCopyRight3, sizeof(szCopyRight3)-1);
    239         WriteString(szCopyRight2, sizeof(szCopyRight2)-1);
    240     }
    241 
    242 
    243     if(fDebug) {
    244         sprintf(debugmsg, szCodeStartEnd, OffsetBeginCS32, OffsetFinalCS32);
    245         WriteString(debugmsg, strlen(debugmsg));
    246     }
    247 
    248     //get the current time (to force retrieval of GIS pointer)
    249     os2gettimemsec();
    250 
    251     char szMixerName[64];
    252     char szDeviceName[128];
    253 
    254     if(OSS32_Initialize() != OSSERR_SUCCESS)
    255     {
    256         WriteString(ERR_ERROR, sizeof(ERR_ERROR)-1);
    257         WriteString(ERR_INIT, sizeof(ERR_INIT)-1);
    258         if(szLastALSAError1[0]) {
    259             WriteString(szLastALSAError1, strlen(szLastALSAError1));
    260         }
    261         if(szLastALSAError2[0]) {
    262             WriteString(szLastALSAError2, strlen(szLastALSAError2));
    263         }
    264         // !! dont exit when error !! return RPDONE | RPERR_COMMAND;
    265     } else if (OSS32_QueryNames(OSS32_DEFAULT_DEVICE, szDeviceName,
    266                                 sizeof(szDeviceName),szMixerName,
    267                                 sizeof(szMixerName), TRUE) != OSSERR_SUCCESS)
    268     {
    269         WriteString(ERR_ERROR, sizeof(ERR_ERROR)-1);
    270         WriteString(ERR_NAMES, sizeof(ERR_INIT)-1);
    271         if(szLastALSAError1[0]) {
    272             WriteString(szLastALSAError1, strlen(szLastALSAError1));
    273         }
    274         if(szLastALSAError2[0]) {
    275             WriteString(szLastALSAError2, strlen(szLastALSAError2));
    276         }
    277 
    278         // !! dont exit when error !! return RPDONE | RPERR_COMMAND;
    279     }
    280     else
    281     if(fVerbose) {
     198WORD32 DiscardableInit(REQPACKET __far* rp)
     199{
     200  char debugmsg[64];
     201  char FAR48 *args;
     202
     203#ifdef KEE
     204  GetTKSSBase();
     205#endif
     206
     207  if(LockSegments())
     208  {
     209    WriteString(ERR_ERROR, sizeof(ERR_ERROR)-1);
     210    WriteString(ERR_LOCK, sizeof(ERR_LOCK)-1);
     211    return RPDONE | RPERR_BADCOMMAND;
     212  }
     213
     214  DebugLevel = 1;
     215  rp->init_out.usCodeEnd = 0;
     216  rp->init_out.usDataEnd = 0;
     217
     218  if ( szprintBuf == 0 )
     219  {
     220    VMAlloc( DBG_MAX_BUF_SIZE, VMDHA_FIXED, &szprintBuf );
     221    if (szprintBuf)
     222    {
     223      memset( szprintBuf, 0, DBG_MAX_BUF_SIZE );
     224      wrOffset= 0;
     225    }
     226  }
     227  if (!HeapInit(HEAP_SIZE))
     228  {
     229    rprintf(("HeapInit failed!"));
     230  }
     231
     232  args = MAKE_FARPTR32(rp->init_in.szArgs);
     233  GetParms(args);
     234
     235  #ifdef DEBUG
     236  rprintf(("Uniaud32 version %s-DEBUG",UNIAUD_VERSION));
     237  #else
     238  rprintf(("Uniaud32 version %s",UNIAUD_VERSION));
     239  #endif
     240
     241  if(fVerbose)
     242  {
     243    WriteString(szALSA, sizeof(szALSA)-1);
     244    WriteString(szCopyRight3, sizeof(szCopyRight3)-1);
     245    WriteString(szCopyRight2, sizeof(szCopyRight2)-1);
     246  }
     247
     248  if(fDebug)
     249  {
     250    sprintf(debugmsg, szCodeStartEnd, OffsetBeginCS32, OffsetFinalCS32);
     251    WriteString(debugmsg, strlen(debugmsg));
     252  }
     253
     254  //get the current time (to force retrieval of GIS pointer)
     255  os2gettimemsec();
     256
     257  char szMixerName[64];
     258  char szDeviceName[128];
     259
     260  if(OSS32_Initialize() != OSSERR_SUCCESS)
     261  {
     262    WriteString(ERR_ERROR, sizeof(ERR_ERROR)-1);
     263    WriteString(ERR_INIT, sizeof(ERR_INIT)-1);
     264      if(szLastALSAError1[0])
     265      {
     266        WriteString(szLastALSAError1, strlen(szLastALSAError1));
     267      }
     268      if(szLastALSAError2[0])
     269      {
     270        WriteString(szLastALSAError2, strlen(szLastALSAError2));
     271      }
     272    // !! dont exit when error !! return RPDONE | RPERR_COMMAND;
     273  }
     274  else if (OSS32_QueryNames(OSS32_DEFAULT_DEVICE, szDeviceName,
     275                              sizeof(szDeviceName),szMixerName,
     276                              sizeof(szMixerName), TRUE) != OSSERR_SUCCESS)
     277  {
     278    WriteString(ERR_ERROR, sizeof(ERR_ERROR)-1);
     279    WriteString(ERR_NAMES, sizeof(ERR_INIT)-1);
     280    if(szLastALSAError1[0])
     281    {
     282      WriteString(szLastALSAError1, strlen(szLastALSAError1));
     283    }
     284    if(szLastALSAError2[0])
     285    {
     286      WriteString(szLastALSAError2, strlen(szLastALSAError2));
     287    }
     288
     289    // !! dont exit when error !! return RPDONE | RPERR_COMMAND;
     290  }
     291  else
     292  if(fVerbose)
     293  {
     294    WriteString(szDeviceName, strlen(szDeviceName));
     295    WriteString(szEOL, sizeof(szEOL)-1);
     296    WriteString(szMixerFound, sizeof(szMixerFound)-1);
     297    WriteString(szMixerName, strlen(szMixerName));
     298    WriteString(szEOL, sizeof(szEOL)-1);
     299
     300    #if 0
     301    for(int i=1;i<OSS32_MAX_AUDIOCARDS;i++)
     302    {
     303      if(OSS32_QueryNames(i, szDeviceName, sizeof(szDeviceName), szMixerName, sizeof(szMixerName)) == OSSERR_SUCCESS)
     304      {
    282305        WriteString(szDeviceName, strlen(szDeviceName));
    283306        WriteString(szEOL, sizeof(szEOL)-1);
    … …  
    285308        WriteString(szMixerName, strlen(szMixerName));
    286309        WriteString(szEOL, sizeof(szEOL)-1);
    287 
    288 #if 0
    289         for(int i=1;i<OSS32_MAX_AUDIOCARDS;i++) {
    290             if(OSS32_QueryNames(i, szDeviceName, sizeof(szDeviceName), szMixerName, sizeof(szMixerName)) == OSSERR_SUCCESS)
    291             {
    292                 WriteString(szDeviceName, strlen(szDeviceName));
    293                 WriteString(szEOL, sizeof(szEOL)-1);
    294                 WriteString(szMixerFound, sizeof(szMixerFound)-1);
    295                 WriteString(szMixerName, strlen(szMixerName));
    296                 WriteString(szEOL, sizeof(szEOL)-1);
    297             }
    298             else break;
    299         }
    300 #endif
    301         WriteString(szEOL, sizeof(szEOL)-1);
    302     }
    303     // Complete the installation
    304     rp->Out.FinalCS = _OffsetFinalCS16;
    305     rp->Out.FinalDS = _OffsetFinalDS16;
    306 
    307         //SaveBuffer();
    308 
    309     // Confirm a successful installation
    310     return RPDONE;
    311 }
    312 
     310      }
     311      else break;
     312    }
     313    #endif
     314    WriteString(szEOL, sizeof(szEOL)-1);
     315  }
     316  // Complete the installation
     317  rp->init_out.usCodeEnd = _OffsetFinalCS16;
     318  rp->init_out.usDataEnd = _OffsetFinalDS16;
     319
     320  //SaveBuffer();
     321
     322  // Confirm a successful installation
     323  return RPDONE;
     324}
     325

  • GPL/trunk/drv32/irq.h

    r63 r587  
    2525#define __IRQ_H__
    2626
    27 extern "C" FARPTR16 ISR00;
    28 extern "C" FARPTR16 ISR01;
    29 extern "C" FARPTR16 ISR02;
    30 extern "C" FARPTR16 ISR03;
    31 extern "C" FARPTR16 ISR04;
    32 extern "C" FARPTR16 ISR05;
    33 extern "C" FARPTR16 ISR06;
    34 extern "C" FARPTR16 ISR07;
     27extern FARPTR16 ISR00;
     28extern FARPTR16 ISR01;
     29extern FARPTR16 ISR02;
     30extern FARPTR16 ISR03;
     31extern FARPTR16 ISR04;
     32extern FARPTR16 ISR05;
     33extern FARPTR16 ISR06;
     34extern FARPTR16 ISR07;
    3535
    3636#endif //__IRQ_H__

  • GPL/trunk/drv32/parse.c

    r501 r587  
    3434#include <devhelp.h>
    3535#include <devtype.h>
    36 #include <devrp.h>
    3736#include <unicard.h>
    3837#include "parse.h"         // NUM_DEVICES
    … …  
    4645int ForceCard = CARD_NONE;
    4746
    48 extern "C" short int midi_port;
     47extern short int midi_port;
    4948
    5049#ifdef COMM_DEBUG
    51 extern "C" short int MAGIC_COMM_PORT;
     50extern short int MAGIC_COMM_PORT;
    5251#endif
    5352

  • GPL/trunk/drv32/strategy.c

    r549 r587  
    55 * (C) 2000-2002 InnoTek Systemberatung GmbH
    66 * (C) 2000-2001 Sander van Leeuwen (sandervl@xs4all.nl)
     7 * Copyright (c) 2013-2015 David Azarewicz david@88watts.net
    78 *
    89 * This program is free software; you can redistribute it and/or
    … …  
    2425
    2526#define INCL_NOPMAPI
    26 #define INCL_DOSINFOSEG         // Need Global info seg in rm.cpp algorithms
     27#define INCL_DOSINFOSEG   // Need Global info seg in rm.cpp algorithms
    2728#include <os2.h>
    2829
    2930#include <devhelp.h>
    30 #include <devrp.h>
     31//DAZ #include <devrp.h>
    3132#include <devown.h>
    3233#include "strategy.h"
    … …  
    3536#include <string.h>
    3637
    37 ULONG StratRead(RP __far *_rp);
    38 ULONG StratIOCtl(RP __far *_rp);
    39 ULONG StratClose(RP __far *_rp);
     38ULONG StratRead(REQPACKET __far *_rp);
     39ULONG StratIOCtl(REQPACKET __far *_rp);
     40ULONG StratClose(REQPACKET __far *_rp);
    4041
    41 ULONG DiscardableInit(RPInit __far*);
     42ULONG DiscardableInit(REQPACKET __far*);
    4243ULONG deviceOwner = DEV_NO_OWNER;
    4344ULONG numOS2Opens = 0;
    44 extern "C" BOOL fRewired; //pci.c
     45extern BOOL fRewired; //pci.c
    4546
    46 extern "C" DBGINT DbgInt;
     47extern DBGINT DbgInt;
    4748
    4849//******************************************************************************
     50ULONG StratOpen(REQPACKET __far* rp)
     51{
     52  if (numOS2Opens == 0)
     53  {
     54    deviceOwner = DEV_PDD_OWNER;
     55  }
     56  numOS2Opens++;
     57  return RPDONE;
     58}
     59
    4960//******************************************************************************
    50 ULONG StratOpen(RP __far*)
    51 {
    52         if (numOS2Opens == 0) {
    53                 deviceOwner = DEV_PDD_OWNER;
    54         }
    55         numOS2Opens++;
    56                 return RPDONE;
    57 }
    58 //******************************************************************************
    59 //******************************************************************************
    60 #pragma off (unreferenced)
    61 static ULONG StratWrite(RP __far* _rp)
    62 #pragma on (unreferenced)
     61//DAZ #pragma off (unreferenced)
     62static ULONG StratWrite(REQPACKET __far* rp)
     63//DAZ #pragma on (unreferenced)
    6364{
    6465  return RPDONE | RPERR;
    6566}
     67
    6668//******************************************************************************
    6769// External initialization entry-point
    6870//******************************************************************************
    69 ULONG StratInit(RP __far* _rp)
     71ULONG StratInit(REQPACKET __far* rp)
    7072{
    71         ULONG rc;
     73  ULONG rc;
    7274
    73         memset(&DbgInt, 0, sizeof(DbgInt));
    74         DbgPrintIrq();
     75  memset(&DbgInt, 0, sizeof(DbgInt));
     76  DbgPrintIrq();
    7577
    76         RPInit __far* rp = (RPInit __far*)_rp;
    77         rc = DiscardableInit(rp);
    78         //dprintf(("StratInit End rc=%d", rc));
    79         DbgPrintIrq();
    80         DbgInt.ulState = 1;
    81         return rc;
     78  //DAZ RPInit __far* rp = (RPInit __far*)_rp;
     79  rc = DiscardableInit(rp);
     80  //dprintf(("StratInit End rc=%d", rc));
     81  DbgPrintIrq();
     82  DbgInt.ulState = 1;
     83  return rc;
    8284}
     85
    8386//******************************************************************************
    8487// External initialization complete entry-point
    85 #ifdef ACPI
    86 #include "irqos2.h"
    87 #endif //ACPI
    8888//******************************************************************************
    89 #pragma off (unreferenced)
    90 ULONG StratInitComplete(RP __far* _rp)
    91 #pragma on (unreferenced)
     89//DAZ #pragma off (unreferenced)
     90ULONG StratInitComplete(REQPACKET __far* rp)
     91//DAZ #pragma on (unreferenced)
    9292{
    93         DbgInt.ulState = 2;
    94 #ifdef ACPI
    95         PciAdjustInterrupts();
    96 #endif
    97         DbgPrintIrq();
    98         //dprintf(("StratInitComplete"));
    99         return(RPDONE);
     93  DbgInt.ulState = 2;
     94  DbgPrintIrq();
     95  //dprintf(("StratInitComplete"));
     96  return(RPDONE);
    10097}
     98
    10199//******************************************************************************
    102 //******************************************************************************
    103 #pragma off (unreferenced)
    104 ULONG StratShutdown(RP __far *_rp)
    105 #pragma on (unreferenced)
     100//DAZ #pragma off (unreferenced)
     101ULONG StratShutdown(REQPACKET __far *rp)
     102//DAZ #pragma on (unreferenced)
    106103{
    107         RPShutdown __far *rp = (RPShutdown __far *)_rp;
     104  //DAZ RPShutdown __far *rp = (RPShutdown __far *)_rp;
    108105
    109         //dprintf(("StratShutdown %d", rp->Function));
    110         if(rp->Function == 1) {//end of shutdown
    111                 OSS32_Shutdown();
    112         }
    113         return(RPDONE);
     106  //dprintf(("StratShutdown %d", rp->Function));
     107  if(rp->shutdown.Function == 1) //end of shutdown
     108  {
     109    OSS32_Shutdown();
     110  }
     111  return(RPDONE);
    114112}
    115 //******************************************************************************
     113
    116114//******************************************************************************
    117115// Handle unsupported requests
    118 static ULONG StratError(RP __far*)
     116static ULONG StratError(REQPACKET __far* rp)
    119117{
    120   return RPERR_COMMAND | RPDONE;
     118  return RPERR_BADCOMMAND | RPDONE;
    121119}
     120
    122121//******************************************************************************
    123122// Strategy dispatch table
    … …  
    125124// This table is used by the strategy routine to dispatch strategy requests
    126125//******************************************************************************
    127 typedef ULONG (*RPHandler)(RP __far* rp);
     126typedef ULONG (*RPHandler)(REQPACKET __far* rp);
    128127RPHandler StratDispatch[] =
    129128{
    130   StratInit,                              // 00 (BC): Initialization
    131   StratError,                             // 01 (B ): Media check
    132   StratError,                             // 02 (B ): Build BIOS parameter block
    133   StratError,                             // 03 (  ): Unused
    134   StratRead,                              // 04 (BC): Read
    135   StratError,                             // 05 ( C): Nondestructive read with no wait
    136   StratError,                             // 06 ( C): Input status
    137   StratError,                             // 07 ( C): Input flush
    138   StratWrite,                             // 08 (BC): Write
    139   StratError,                             // 09 (BC): Write verify
    140   StratError,                             // 0A ( C): Output status
    141   StratError,                             // 0B ( C): Output flush
    142   StratError,                             // 0C (  ): Unused
    143   StratOpen,                              // 0D (BC): Open
    144   StratClose,                             // 0E (BC): Close
    145   StratError,                             // 0F (B ): Removable media check
    146   StratIOCtl,                             // 10 (BC): IO Control
    147   StratError,                             // 11 (B ): Reset media
    148   StratError,                             // 12 (B ): Get logical unit
    149   StratError,                             // 13 (B ): Set logical unit
    150   StratError,                             // 14 ( C): Deinstall character device driver
    151   StratError,                             // 15 (  ): Unused
    152   StratError,                             // 16 (B ): Count partitionable fixed disks
    153   StratError,                             // 17 (B ): Get logical unit mapping of fixed disk
    154   StratError,                             // 18 (  ): Unused
    155   StratError,                             // 19 (  ): Unused
    156   StratError,                             // 1A (  ): Unused
    157   StratError,                             // 1B (  ): Unused
    158   StratShutdown,                          // 1C (BC): Notify start or end of system shutdown
    159   StratError,                             // 1D (B ): Get driver capabilities
    160   StratError,                             // 1E (  ): Unused
    161   StratInitComplete               // 1F (BC): Notify end of initialization
     129  StratInit,          // 00 (BC): Initialization
     130  StratError,         // 01 (B ): Media check
     131  StratError,         // 02 (B ): Build BIOS parameter block
     132  StratError,         // 03 (  ): Unused
     133  StratRead,          // 04 (BC): Read
     134  StratError,         // 05 ( C): Nondestructive read with no wait
     135  StratError,         // 06 ( C): Input status
     136  StratError,         // 07 ( C): Input flush
     137  StratWrite,         // 08 (BC): Write
     138  StratError,         // 09 (BC): Write verify
     139  StratError,         // 0A ( C): Output status
     140  StratError,         // 0B ( C): Output flush
     141  StratError,         // 0C (  ): Unused
     142  StratOpen,          // 0D (BC): Open
     143  StratClose,         // 0E (BC): Close
     144  StratError,         // 0F (B ): Removable media check
     145  StratIOCtl,         // 10 (BC): IO Control
     146  StratError,         // 11 (B ): Reset media
     147  StratError,         // 12 (B ): Get logical unit
     148  StratError,         // 13 (B ): Set logical unit
     149  StratError,         // 14 ( C): Deinstall character device driver
     150  StratError,         // 15 (  ): Unused
     151  StratError,         // 16 (B ): Count partitionable fixed disks
     152  StratError,         // 17 (B ): Get logical unit mapping of fixed disk
     153  StratError,         // 18 (  ): Unused
     154  StratError,         // 19 (  ): Unused
     155  StratError,         // 1A (  ): Unused
     156  StratError,         // 1B (  ): Unused
     157  StratShutdown,        // 1C (BC): Notify start or end of system shutdown
     158  StratError,         // 1D (B ): Get driver capabilities
     159  StratError,         // 1E (  ): Unused
     160  StratInitComplete       // 1F (BC): Notify end of initialization
    162161};
     162
    163163//******************************************************************************
    164164// Strategy entry point
    … …  
    167167// calling convention, which fetches arguments from the correct registers.
    168168//******************************************************************************
    169 ULONG Strategy(RP __far* rp);
    170169#pragma aux (STRATEGY) Strategy "ALSA_STRATEGY";
    171 ULONG Strategy(RP __far* rp)
     170ULONG Strategy(REQPACKET __far* rp)
    172171{
    173         if (fRewired) {
    174                 fRewired = FALSE;
    175                 rprintf(("Strategy: Resuming"));
    176                 OSS32_APMResume();
    177                 DbgPrintIrq();
    178         }
     172  if (fRewired)
     173  {
     174    fRewired = FALSE;
     175    rprintf(("Strategy: Resuming"));
     176    OSS32_APMResume();
     177    DbgPrintIrq();
     178  }
    179179
    180         if (rp->Command < sizeof(StratDispatch)/sizeof(StratDispatch[0]))
    181                 return(StratDispatch[rp->Command](rp));
    182         else return(RPERR_COMMAND | RPDONE);
     180  if (rp->bCommand < sizeof(StratDispatch)/sizeof(StratDispatch[0])) return(StratDispatch[rp->bCommand](rp));
     181  else return(RPERR_BADCOMMAND | RPDONE);
    183182}
    184 //******************************************************************************
    185 //******************************************************************************
     183
Note: See TracChangeset for help on using the changeset viewer.