Ejemplo n.º 1
0
bool Baud( int index )
{
    USHORT      temp;
    BYTE        lc[3];
    APIRET      rc;
    BYTE        command;
    ULONG       ulParmLen;

    if( index == MIN_BAUD )
        return( TRUE );
    if( index == CurrentBaud )
        return( TRUE );
    temp = Rate[index];

    command   = 0;
    ulParmLen = sizeof( temp );
    rc = DosDevIOCtl( ComPort, IOCTL_ASYNC, ASYNC_SETBAUDRATE,
        &temp,  sizeof( temp ), &ulParmLen,
        NULL,  0, NULL );
    if( rc != 0 ) {
        return( FALSE );
    }
    lc[ 0 ] = DATA_BITS_8;
    lc[ 1 ] = PARITY_NONE;
    lc[ 2 ] = STOP_BITS_1;
    ulParmLen = sizeof( lc );
    rc = DosDevIOCtl( ComPort, IOCTL_ASYNC, ASYNC_SETLINECTRL,
        &lc,  sizeof( lc ), &ulParmLen,
        NULL,  0, NULL );
    if( rc != 0 ) {
        return( FALSE );
    }
    CurrentBaud = index;
    return( TRUE );
}
bool CD_drive::readTrackInfo(char track, CDTRACKINFO *trackInfo2)
{
   ULONG ulParamLen;
   ULONG ulDataLen;
   ULONG rc;
   BOOL returnBool = FALSE;

   CDAUDIOTRACKINFOPARAM trackParam;
   CDAUDIOTRACKINFODATA  trackInfo[2];

   memcpy(trackParam.signature,TAG,4);

   trackParam.trackNum = track;
   rc = DosDevIOCtl(hCDDrive, IOCTL_CDROMAUDIO, CDROMAUDIO_GETAUDIOTRACK,
                    &trackParam, sizeof(trackParam),
                    &ulParamLen, &trackInfo[0],
                    sizeof(trackInfo[0]), &ulDataLen);
   if(rc)
      updateError("DosDevIOCtl failed with return code 0x%x reading track %d info",rc,track);
   else
   {
      trackParam.trackNum = track+1;
      rc = 0;
      if(trackParam.trackNum <= cdInfo.lastTrack)
      {
         rc = DosDevIOCtl(hCDDrive, IOCTL_CDROMAUDIO, CDROMAUDIO_GETAUDIOTRACK,
                          &trackParam, sizeof(trackParam),
                          &ulParamLen, &trackInfo[1],
                          sizeof(trackInfo[1]), &ulDataLen);

         if(rc)
            updateError("DosDevIOCtl failed with return code 0x%x",rc);
      }
      else
          trackInfo[1].address = cdInfo.leadOutAddress;

      if(!rc)
      {
         ULONG LBA[2];
         MSF length;

         LBA[0] = getLBA(trackInfo[0].address);
         LBA[1] = getLBA(trackInfo[1].address);

         /* -150 because we want length, not an address */
         length = getMSF(LBA[1]-LBA[0]-150);

         trackInfo2->start = trackInfo[0].address;
         trackInfo2->end = trackInfo[1].address;
         trackInfo2->length = length;
         trackInfo2->size = (LBA[1]-LBA[0])*2352;
         trackInfo2->data = (trackInfo[0].info & 0x40) ? TRUE : FALSE;
         trackInfo2->channels = (trackInfo[0].info & 0x80) ? 4 : 2;
         trackInfo2->number = track;

         returnBool = TRUE;
      }
   }
   return returnBool;
}
Ejemplo n.º 3
0
int SERIAL_getextchar(COMPORT port) {
	ULONG dwRead = 0;	// Number of chars read
	char chRead;

	int retval = 0;
	// receive a byte; TODO communicate failure
	if (DosRead(port->porthandle, &chRead, 1, &dwRead) == NO_ERROR) {
		if (dwRead) {
			// check for errors; will OS/2 clear the error on reading its data?
			// if yes then this is in wrong order
			USHORT errors = 0, event = 0;
			ULONG ulParmLen = sizeof(errors);
			DosDevIOCtl(port->porthandle, IOCTL_ASYNC, ASYNC_GETCOMMEVENT,
				0, 0, 0, &event, ulParmLen, &ulParmLen);
			if (event & (64 + 128) ) { // Break (Bit 6) or Frame or Parity (Bit 7) error
				Bit8u errreg = 0;
				if (event & 64) retval |= SERIAL_BREAK_ERR;
				if (event & 128) {
					DosDevIOCtl(port->porthandle, IOCTL_ASYNC, ASYNC_GETCOMMERROR,
						0, 0, 0, &errors, ulParmLen, &ulParmLen);
					if (errors & 8) retval |= SERIAL_FRAMING_ERR;
					if (errors & 4) retval |= SERIAL_PARITY_ERR;
				}
			}
			retval |= (chRead & 0xff);
			retval |= 0x10000; 
		}
	}
	return retval;
}
Ejemplo n.º 4
0
int mpioctl(HFILE fd, int func,struct map_ioctl* data)
{
	struct xf86_pmap_param par;
	struct xf86_pmap_data dta;
	ULONG len;
	APIRET rc;

	switch (func) {
	case IOCTL_MAP:
		par.u.physaddr = data->a.phys;
		par.size = data->size;
		rc = DosDevIOCtl(fd, XFREE86_PMAP, PMAP_MAP,
			(ULONG*)&par, sizeof(par), &len,
			(ULONG*)&dta, sizeof(dta), &len);
		if (!rc) data->a.user = (void*)dta.addr;
		return rc ? -1 : 0;
	case IOCTL_UMAP:
		par.u.physaddr = (ULONG)data->a.user;
		par.size = 0;
		rc = DosDevIOCtl(fd, XFREE86_PMAP, PMAP_UNMAP,
			(ULONG*)&par, sizeof(par), &len,
			NULL, 0, NULL);
		return rc ? -1 : 0;
	default:
		return -1;
	}
}
void CDirectSerial::updateModemControlLines ( /*Bit8u mcr */ ) {
	bool change = false;
	DCBINFO dcb;
	ULONG ulParmLen = sizeof(dcb);

	DosDevIOCtl(hCom, IOCTL_ASYNC, ASYNC_GETDCBINFO, 0, 0, 0, &dcb, ulParmLen, &ulParmLen);

		/*** DTR ***/
	if (CSerial::getDTR ()) {			// DTR on
		if (dcb.fbCtlHndShake && 3 == 0) { // DTR disabled
			dcb.fbCtlHndShake |= 1;
			change = true;
		}
	} else {
		if (dcb.fbCtlHndShake && 3 == 1) { // DTR enabled
			dcb.fbCtlHndShake &= ~3;
			change = true;
		}
	}
		/*** RTS ***/
	if (CSerial::getRTS ()) {			// RTS on
		if (dcb.fbFlowReplace && 192 == 0) { //RTS disabled
			dcb.fbFlowReplace |= 64;
			change = true;
		}
	} else {
		if (dcb.fbFlowReplace && 192 == 1) { // RTS enabled
			dcb.fbFlowReplace &= ~192;
			change = true;
		}
	}
	if (change)
		DosDevIOCtl(hCom, IOCTL_ASYNC, ASYNC_SETDCBINFO, &dcb, ulParmLen, &ulParmLen, 0, 0, 0);
}
Ejemplo n.º 6
0
void Set_IOCTL_Bit_Rate(USHORT BitRate,HWND hwnd)
{
   APIRET rc;
   ULONG ParmPacketLen;
   ParmPacketLen = 2;  //size of Parmpacket

   rc = DosDevIOCtl (HandleComm,
                     IOCTL_ASYNC,
                     ASYNC_SETBAUDRATE,
                     (PULONG) &BitRate, 
                     sizeof(BitRate),    //size input parm packet
                     &ParmPacketLen,         // length of parm packet
                     NULL,
                     0,
                     NULL);

   rc = DosDevIOCtl (HandleComm,
                     IOCTL_ASYNC,
                     ASYNC_SETBAUDRATE,
                     (PULONG) &BitRate, 
                     sizeof(BitRate),    //size input parm packet
                     &ParmPacketLen,         // length of parm packet
                     NULL,
                     0,
                     NULL);


   if (rc)
      {
      sprintf(PrintBuf,"RC=%u Line=%u\nFile: %s",rc,__LINE__,__FILE__);
      WinDebugMsg(PrintBuf,hwnd);
      }

}
Ejemplo n.º 7
0
APIRET InitLineBits(HWND hwnd)
{

   APIRET rc;
   ULONG DataPacketLen;



   rc = DosDevIOCtl (HandleComm,
                     IOCTL_ASYNC,
                     ASYNC_GETLINECTRL,
                     NULL,                  //no parameter packet
                     0,                  // = 0
                     NULL,                  // length of parm packet
                     (PULONG) &DataPacket,
                     sizeof(DataPacket),
                     &DataPacketLen);

   rc = DosDevIOCtl (HandleComm,
                     IOCTL_ASYNC,
                     ASYNC_GETLINECTRL,
                     NULL,                  //no parameter packet
                     0,                  // = 0
                     NULL,                  // length of parm packet
                     (PULONG) &DataPacket,
                     sizeof(DataPacket),
                     &DataPacketLen);

   if (rc)
      {
      sprintf(PrintBuf,"RC=%u Line=%u\nFile: %s",rc,__LINE__,__FILE__);
      WinDebugMsg(PrintBuf,hwnd);
      }


   WinSendDlgItemMsg(hwnd,
                     (ULONG) IDC_DATA_BIT5 + (DataPacket.bDataBits - 5),
                     (ULONG) BM_SETCHECK,
                     MPFROM2SHORT(TRUE,0),
                     NULL);

   WinSendDlgItemMsg(hwnd,IDC_PARITY_NO + DataPacket.bParity,
                        BM_SETCHECK,
                        MPFROM2SHORT(TRUE,0),
                        NULL);

   WinSendDlgItemMsg(hwnd,IDC_STOP_BIT1 + DataPacket.bStopBits,
                        BM_SETCHECK,
                        MPFROM2SHORT(TRUE,0),
                        NULL);




   WinSetFocus (HWND_DESKTOP, WinWindowFromID(hwnd,DID_OK));


   return 0;
}
Ejemplo n.º 8
0
bool SERIAL_setCommParameters(COMPORT port,
			int baudrate, char parity, int stopbits, int length) {
	// baud
	struct {
		ULONG baud;
		BYTE fraction;
	} setbaud;

	setbaud.baud = baudrate;
	setbaud.fraction = 0;
	ULONG ulParmLen = sizeof(setbaud);
	APIRET rc = DosDevIOCtl(port->porthandle, IOCTL_ASYNC, ASYNC_EXTSETBAUDRATE,
		&setbaud, ulParmLen, &ulParmLen, 0, 0, 0);
	if (rc != NO_ERROR) {
		return false;
	}

	struct {
		UCHAR data;
		UCHAR parity;
		UCHAR stop;
	} paramline;

	// byte length
	if(length > 8 || length < 5) {
		// TODO SetLastError(ERROR_INVALID_PARAMETER);
		return false;
	}
	paramline.data = length;

	// parity
	switch (parity) {
	case 'n': paramline.parity = 0; break;
	case 'o': paramline.parity = 1; break;
	case 'e': paramline.parity = 2; break;
	case 'm': paramline.parity = 3; break;
	case 's': paramline.parity = 4; break;
	default:
		// TODO SetLastError(ERROR_INVALID_PARAMETER);
		return false;
	}
	// stopbits
	switch(stopbits) {
	case SERIAL_1STOP: paramline.stop = 0; break;
	case SERIAL_2STOP: paramline.stop = 2; break;
	case SERIAL_15STOP: paramline.stop = 1; break;
	default:
		// TODO SetLastError(ERROR_INVALID_PARAMETER);
		return false;
	}
	// set it
	ulParmLen = sizeof(paramline);
	rc = DosDevIOCtl(port->porthandle, IOCTL_ASYNC, ASYNC_SETLINECTRL,
		&paramline, ulParmLen, &ulParmLen, 0, 0, 0);
	if ( rc != NO_ERROR)
		return false;
	return true;
}
Ejemplo n.º 9
0
void ClearCom( void )
{
    BYTE        command;

    command = 0;
    DosDevIOCtl( 0L, &command, INPUT, FLUSH, ComPort );
    command = 0;
    DosDevIOCtl( 0L, &command, OUTPUT, FLUSH, ComPort );
}
CDirectSerial::CDirectSerial (IO_ReadHandler * rh, IO_WriteHandler * wh,
                              TIMER_TickHandler th, Bit16u baseAddr, Bit8u initIrq,
                              Bit32u initBps, Bit8u bytesize, const char *parity,
                              Bit8u stopbits,const char *realPort)
                              :CSerial (rh, wh, th,baseAddr,initIrq, initBps,
                              bytesize, parity,stopbits) {
	InstallationSuccessful = false;
	InstallTimerHandler(th);
	lastChance = 0;
	LOG_MSG ("OS/2 Serial port at %x: Opening %s", base, realPort);
        LOG_MSG("Opening OS2 serial port");

	ULONG ulAction = 0;
	APIRET rc = DosOpen((unsigned char*)realPort, &hCom, &ulAction, 0L, FILE_NORMAL, FILE_OPEN,
			OPEN_ACCESS_READWRITE | OPEN_SHARE_DENYNONE | OPEN_FLAGS_SEQUENTIAL, 0L);
	if (rc != NO_ERROR)
	{
		LOG_MSG ("Serial port \"%s\" could not be opened.", realPort);
		if (rc == 2) {
			LOG_MSG ("The specified port does not exist.");
		} else if (rc == 99) {
			LOG_MSG ("The specified port is already in use.");
		} else {
			LOG_MSG ("OS/2 error %d occurred.", rc);
		}

		hCom = 0;
		return;
	}

	DCBINFO dcb;
	ULONG ulParmLen = sizeof(DCBINFO);
	rc = DosDevIOCtl(hCom, IOCTL_ASYNC, ASYNC_GETDCBINFO, 0, 0, 0, &dcb, ulParmLen, &ulParmLen);
	if ( rc != NO_ERROR)
	{
		DosClose(hCom);
		hCom = 0;
		return;
	}
	dcb.usWriteTimeout = 0;
	dcb.usReadTimeout = 0; //65535;
	dcb.fbTimeout |= 6;
	rc = DosDevIOCtl(hCom, IOCTL_ASYNC, ASYNC_SETDCBINFO, &dcb, ulParmLen, &ulParmLen, 0, 0, 0);
	if ( rc != NO_ERROR)
	{
		DosClose(hCom);
		hCom = 0;
		return;
	}

	CSerial::Init_Registers (initBps, bytesize, parity, stopbits);
	InstallationSuccessful = true;
	//LOG_MSG("InstSuccess");
}
void CDirectSerial::setBreak (bool value) {
	//#ifdef SERIALPORT_DEBUGMSG
	//LOG_MSG("UART 0x%x: Break toggeled: %d", base, value);
	//#endif
	USHORT error;
	ULONG ulParmLen = sizeof(error);
	if (value)
		DosDevIOCtl (hCom, IOCTL_ASYNC, ASYNC_SETBREAKON, 0,0,0, &error, ulParmLen, &ulParmLen);
	else
		DosDevIOCtl (hCom, IOCTL_ASYNC, ASYNC_SETBREAKOFF, 0,0,0, &error, ulParmLen, &ulParmLen);
}
Ejemplo n.º 12
0
bool SERIAL_open(const char* portname, COMPORT* port) {
	// allocate COMPORT structure
	COMPORT cp = (_COMPORT*)malloc(sizeof(_COMPORT));
	if(cp == NULL) return false;
	cp->porthandle=0;
	cp->breakstatus=false;

	ULONG ulAction = 0;
	APIRET rc = DosOpen(portname, &cp->porthandle,
		&ulAction, 0L, FILE_NORMAL, FILE_OPEN,
		OPEN_ACCESS_READWRITE | OPEN_SHARE_DENYNONE | OPEN_FLAGS_SEQUENTIAL, 0L);
	if (rc != NO_ERROR) {
		goto cleanup_error;
	}

	ULONG ulParmLen = sizeof(DCBINFO);
	rc = DosDevIOCtl(hCom, IOCTL_ASYNC, ASYNC_GETDCBINFO,
		0, 0, 0, &cp->orig_dcb, ulParmLen, &ulParmLen);
	if ( rc != NO_ERROR) {
		goto cleanup_error;
	}
	// configure the port for polling
	DCBINFO newdcb;
	memcpy(&newdcb,&cp->orig_dcb,sizeof(DCBINFO));

	newdcb.usWriteTimeout = 0;
	newdcb.usReadTimeout = 0; //65535;
	newdcb.fbCtlHndShake = dcb.fbFlowReplace = 0;
	newdcb.fbTimeout = 6;

	rc = DosDevIOCtl(hCom, IOCTL_ASYNC, ASYNC_SETDCBINFO,
		&newdcb, ulParmLen, &ulParmLen, 0, 0, 0);
	if ( rc != NO_ERROR) {
		goto cleanup_error;
	}

	USHORT errors = 0;
	ulParmLen = sizeof(errors);
	rc = DosDevIOCtl(hCom, IOCTL_ASYNC, ASYNC_GETCOMMERROR,
		0, 0, 0, &errors, ulParmLen, &ulParmLen);
	if ( rc != NO_ERROR) {
		goto cleanup_error;
	}

	*port = cp;
	return true;

cleanup_error:
	// TODO error string - rc value
	if (cp->porthandle != 0) CloseHandle(cp->porthandle);
	free(cp);
	return false;
}
Ejemplo n.º 13
0
/*!
  Set the volume of an audio CD.

  @param p_cdio the CD object to be acted upon.

*/
static driver_return_code_t
audio_set_volume_os2 ( void *p_user_data, cdio_audio_volume_t *p_volume)
{
  _img_private_t *p_env = p_user_data;

  struct {
    UCHAR auch_sign[4];
  } s_param = {{'C', 'D', '0', '1'}};

  struct {
    struct {
      BYTE  uc_in_ch;
      BYTE  uc_vol;
    } as_out_ch[4];
  } s_data;

  ULONG ul_param_len;
  ULONG ul_data_len;
  ULONG rc;
  int   i;

  /* first retrive current input ch. */
  rc = DosDevIOCtl(
          p_env->h_cd, IOCTL_CDROMAUDIO, CDROMAUDIO_GETCHANNEL,
          &s_param, sizeof( s_param ), &ul_param_len,
          &s_data, sizeof( s_data ), &ul_data_len );

  if( rc )
  {
    cdio_warn("audio_set_volume_os2 : DosDevIOCtl(GETCHANNEL) = 0x%lx\n", rc );

    return DRIVER_OP_ERROR;
  }

  for( i = 0; i < 4; i++ )
    s_data.as_out_ch[ i ].uc_vol = p_volume->level[ i ];

  /* now set volumes */
  rc = DosDevIOCtl(
          p_env->h_cd, IOCTL_CDROMAUDIO, CDROMAUDIO_SETCHANNELCTRL,
          &s_param, sizeof( s_param ), &ul_param_len,
          &s_data, sizeof( s_data ), &ul_data_len );

  if( rc )
  {
    cdio_warn("audio_set_volume_os2 : DosDevIOCtl(SETCHANNELCTRL) = 0x%lx\n", rc );

    return DRIVER_OP_ERROR;
  }

  return DRIVER_OP_SUCCESS;
}
Ejemplo n.º 14
0
static 
int _get_modem_state(int fd,ULONG* state) 
{
	ULONG state1,len;

	if (DosDevIOCtl((HFILE)fd,IOCTL_ASYNC,ASYNC_GETMODEMOUTPUT,
		NULL,0,NULL, state, sizeof(BYTE), &len) != 0 ||
	    DosDevIOCtl((HFILE)fd,IOCTL_ASYNC,ASYNC_GETMODEMINPUT,
		NULL,0,NULL, &state1, sizeof(BYTE), &len) != 0)
		return -1;
	*state |= state1;
	*state &= 0xff;
	return 0;	
}
Ejemplo n.º 15
0
static APIRET QueryCDROMDMDInfo(struct CDROMDMDInfo_t* pxInfo)
{
    APIRET rc;
    HFILE hfDMD;
    ULONG ulDataLen;
    union
    {
        struct DriveLetters_Data xDRIVELETTERS;
        struct Features_Data xFEATURES;
    } xData;
    rc = DosOpen(CDROMDMD_NAME,
                 &hfDMD,
                 &ulDataLen,
                 (ULONG)0,
                 FILE_NORMAL,
                 OPEN_ACTION_FAIL_IF_NEW | OPEN_ACTION_OPEN_IF_EXISTS,
                 OPEN_FLAGS_FAIL_ON_ERROR | OPEN_FLAGS_NOINHERIT | OPEN_SHARE_DENYNONE | OPEN_ACCESS_READONLY,
                 (PEAOP2)NULL);
    if(rc == NO_ERROR)
    {
        rc = DosDevIOCtl(hfDMD,
                         IOCTL_CDROMDISK2,
                         CDROMDISK2_DRIVELETTERS,
                         (PVOID)NULL,
                         (ULONG)0,
                         (PULONG)NULL,
                         (PVOID)&xData.xDRIVELETTERS,
                         ulDataLen = (ULONG)sizeof(xData.xDRIVELETTERS),
                         &ulDataLen);
        if(rc == NO_ERROR)
        {
            pxInfo->ucDriveFirst = (UCHAR)xData.xDRIVELETTERS.first_drive + (UCHAR)'A';
            pxInfo->ulDriveCount = (ULONG)xData.xDRIVELETTERS.drive_count;
            pxInfo->ulFeatureFlags = (ULONG)0;
            if(DosDevIOCtl(hfDMD,
                           IOCTL_CDROMDISK2,
                           CDROMDISK2_FEATURES,
                           (PVOID)NULL,
                           (ULONG)0,
                           (PULONG)NULL,
                           (PVOID)&xData.xFEATURES,
                           ulDataLen = (ULONG)sizeof(xData.xFEATURES),
                           &ulDataLen) == NO_ERROR)
                pxInfo->ulFeatureFlags = xData.xFEATURES.driver_status;
        }
        (VOID)DosClose(hfDMD);
    }
    return rc;
}
Ejemplo n.º 16
0
void nflowcontrol( KWBoolean flow )
{
   APIRET rc;

#ifdef __OS2__
   ULONG ParmLengthInOut;
   ULONG DataLengthInOut;
#endif

   if ( flow )
       com_dcbinfo.fbFlowReplace = (char)
            (com_dcbinfo.fbFlowReplace |
            (MODE_AUTO_TRANSMIT | MODE_AUTO_RECEIVE));
   else
      com_dcbinfo.fbFlowReplace = (char)
            (com_dcbinfo.fbFlowReplace &
            (0xff - MODE_AUTO_TRANSMIT - MODE_AUTO_RECEIVE));

#ifdef __OS2__

   ParmLengthInOut = sizeof(com_dcbinfo);
   DataLengthInOut = 0;
   rc = DosDevIOCtl( commHandle,
                     IOCTL_ASYNC,
                     ASYNC_SETDCBINFO,
                     (PVOID) &com_dcbinfo,
                     sizeof(com_dcbinfo),
                     &ParmLengthInOut,
                     NULL,
                     0L,
                     &DataLengthInOut);

#else

   rc = DosDevIOCtl( FAR_NULL,
                     &com_dcbinfo,
                     ASYNC_SETDCBINFO,
                     IOCTL_ASYNC,
                     commHandle);

#endif

   if ( rc )
   {
      printOS2error( "ASYNC_SETDCBINFO", rc );
      panic();
   } /*if */

} /* nflowcontrol */
Ejemplo n.º 17
0
/****************************************************************************
REMARKS:
This function returns a pointer to the common graphics driver loaded in the
helper VxD. The memory for the VxD is shared between all processes via
the VxD, so that the VxD, 16-bit code and 32-bit code all see the same
state when accessing the graphics binary portable driver.
****************************************************************************/
GA_sharedInfo * NAPI GA_getSharedInfo(
    int device)
{
    /* Initialise the PM library and connect to our runtime DLL's */
    PM_init();

    /* Open our helper device driver */
    if (DosOpen(PMHELP_NAME,&hSDDHelp,&result,0,0,
	    FILE_OPEN, OPEN_SHARE_DENYNONE | OPEN_ACCESS_READWRITE,
	    NULL))
	PM_fatalError("Unable to open SDDHELP$ helper device driver!");
    outLen = sizeof(result);
    DosDevIOCtl(hSDDHelp,PMHELP_IOCTL,PMHELP_GETSHAREDINFO,
	NULL, 0, NULL,
	&result, outLen, &outLen);
    DosClose(hSDDHelp);
    if (result) {
	/* We have found the shared Nucleus packet. Because not all processes
	 * map to SDDPMI.DLL, we need to ensure that we connect to this
	 * DLL so that it gets mapped into our address space (that is
	 * where the shared Nucleus packet is located). Simply doing a
	 * DosLoadModule on it is enough for this.
	 */
	HMODULE hModSDDPMI;
	char    buf[80];
	DosLoadModule((PSZ)buf,sizeof(buf),(PSZ)"SDDPMI.DLL",&hModSDDPMI);
	}
    return (GA_sharedInfo*)result;
}
Ejemplo n.º 18
0
UCHAR lookup_bios(HFILE filehandle,USHORT deviceid,USHORT func,USHORT bus,USHORT index)
{
  APIRET rc;
  struct _READPCI_CONF
   {
      UCHAR sub_func;
      UCHAR bus_number;
      UCHAR dev_funcnum;
      UCHAR conf_reg;
      UCHAR size;
   } rpci_conf;
  struct _READPCI_CONF_RESP
   {
     UCHAR ret_code;
     ULONG data;
   } rpci_conf_resp;
  rpci_conf.sub_func    = 3;
  rpci_conf.bus_number  = bus;
  rpci_conf.dev_funcnum = deviceid * 8 + func;
  rpci_conf.conf_reg    = index;
  rpci_conf.size        = sizeof(UCHAR);
  rc = DosDevIOCtl( (PVOID) &rpci_conf_resp,(PVOID)&rpci_conf,OEMHLP_PCI,IOCTL_OEMHLP,filehandle);
  if (rc != 0)
    return 0xff;
  return rpci_conf_resp.data;
}
Ejemplo n.º 19
0
static int u_ioctl(HFILE fd, ULONG data)
{
	APIRET rc = DosDevIOCtl(fd,XFREE86_USER, data,
		NULL, 0, NULL,
		NULL, 0, NULL);
	return rc ? -1 : 0;
}
Ejemplo n.º 20
0
static int x_ioctl(HFILE fd, int func)
{
	APIRET rc = DosDevIOCtl(fd,XFREE86_PTY, func,
		NULL, 0, NULL,
		NULL, 0, NULL);
	return rc ? -1 : 0;
}
Ejemplo n.º 21
0
/* ARGSUSED */
void * map_phys_mem(unsigned long base, unsigned long size)
{
	DIOParPkt	par;
	ULONG		plen;
	DIODtaPkt	dta;
	ULONG		dlen;
	static BOOL	ErrRedir = FALSE;
	APIRET		rc;

	par.addr	= (ULONG)base;
	par.size	= (ULONG)size;
	plen 		= sizeof(par);
	dlen		= sizeof(dta);

	open_mmap();
	if (mapdev == -1)
	{
		perror("libdha: device xf86sup.sys is not installed");
		exit(1);
	}
	if ((rc=DosDevIOCtl(mapdev, (ULONG)0x76, (ULONG)0x44,
	      (PVOID)&par, (ULONG)plen, (PULONG)&plen,
	      (PVOID)&dta, (ULONG)dlen, (PULONG)&dlen)) == 0) {
		if (dlen==sizeof(dta)) {
			callcount++;
			return (void *)dta.addr;
		}
		/*else fail*/
	}
	return (void *)-1;
}
Ejemplo n.º 22
0
/* ARGSUSED */
void unmap_phys_mem(void * base, unsigned long size)
{
	DIOParPkt	par;
	ULONG		plen,vmaddr;

/* We need here the VIRTADDR for unmapping, not the physical address      */
/* This should be taken care of either here by keeping track of allocated */
/* pointers, but this is also already done in the driver... Thus it would */
/* be a waste to do this tracking twice. Can this be changed when the fn. */
/* is called? This would require tracking this function in all servers,   */
/* and changing it appropriately to call this with the virtual adress	  */
/* If the above mapping function is only called once, then we can store   */
/* the virtual adress and use it here.... 				  */
	
	par.addr	= (ULONG)base;
	par.size	= 0xffffffff; /* This is the virtual address parameter. Set this to ignore */
	plen 		= sizeof(par);

	if (mapdev != -1)
	{
	    DosDevIOCtl(mapdev, (ULONG)0x76, (ULONG)0x46,
	      (PVOID)&par, (ULONG)plen, (PULONG)&plen,
	      &vmaddr, sizeof(ULONG), &plen);
	    callcount--;
	}
/* Now if more than one region has been allocated and we close the driver,
 * the other pointers will immediately become invalid. We avoid closing
 * driver for now, but this should be fixed for server exit
 */
 
	if(!callcount) close_mmap();
}
Ejemplo n.º 23
0
static int _set_baudrate(HFILE fd,int baud) 
{
	USHORT br = baud;
	ULONG plen;
	return DosDevIOCtl(fd,IOCTL_ASYNC,ASYNC_SETBAUDRATE,
			   (PULONG)&br,sizeof(br),&plen,NULL,0,NULL);
}
Ejemplo n.º 24
0
/*!
  Close tray on CD-ROM.

  @param p_user_data the CD object to be acted upon.

*/
driver_return_code_t
close_tray_os2 (const char *psz_os2_drive)
{
#ifdef HAVE_OS2_CDROM
  struct {
    BYTE uc_cmd_info;
    BYTE uc_drive;
  } s_param;

  ULONG ul_param_len;
  ULONG ul_data_len;
  ULONG rc;

  s_param.uc_cmd_info = 3;
  s_param.uc_drive    = toupper(psz_os2_drive[0]) - 'A';

  rc = DosDevIOCtl(
             ( HFILE )-1, IOCTL_DISK, DSK_UNLOCKEJECTMEDIA,
             &s_param, sizeof( s_param ), &ul_param_len,
             NULL, 0, &ul_data_len );

  if( rc && rc != 99 /* device in use */ )
  {
    cdio_warn("close_tray_os2 : DosDevIOCtl(UNLOCKEJECTMEDIA) = 0x%lx\n", rc );

    return DRIVER_OP_ERROR;
  }

  return DRIVER_OP_SUCCESS;
#else
  return DRIVER_OP_UNSUPPORTED;
#endif /* HAVE_OS2_CDROM */
}
bool CD_drive::play(char track)
{
   ULONG ulParamLen;
   ULONG ulDataLen;
   ULONG rc;
   BOOL returnBool = FALSE;
   CDPLAYAUDIOPARAM playParam;
   CDTRACKINFO trackInfo;

   memcpy(playParam.signature,TAG,4);
   playParam.addressingMode = MODE_MSF;

   if(!readTrackInfo(track, &trackInfo))
       return FALSE;
   playParam.start = trackInfo.start;
   playParam.end = trackInfo.end;

   rc = DosDevIOCtl(hCDDrive, IOCTL_CDROMAUDIO, CDROMAUDIO_PLAYAUDIO,
                    &playParam, sizeof(playParam),
                    &ulParamLen, NULL,
                    0, &ulDataLen);
   if(rc)
      updateError("DosDevIOCtl failed with return code 0x%x playing track %d",rc,track);
   else
      returnBool = TRUE;

   return returnBool;
}
Ejemplo n.º 26
0
static driver_return_code_t
audio_stop_os2 (void *p_user_data)
{
  _img_private_t *p_env = p_user_data;

  struct {
    UCHAR auch_sign[4];
  } s_param = {{'C', 'D', '0', '1'}};

  ULONG ul_param_len;
  ULONG ul_data_len;
  ULONG rc;

  rc = DosDevIOCtl(
          p_env->h_cd, IOCTL_CDROMAUDIO, CDROMAUDIO_STOPAUDIO,
          &s_param, sizeof( s_param ), &ul_param_len,
          NULL, 0, &ul_data_len );

  if( rc )
  {
    cdio_warn("audio_stop_os2 : DosDevIOCtl(STOPAUDIO) = 0x%lx\n", rc );

    return DRIVER_OP_ERROR;
  }

  return DRIVER_OP_SUCCESS;
}
Ejemplo n.º 27
0
/******************************************************************
 * NAME: 	tell_LVM
 *
 * FUNCTION: 	Notify the LVM that it can remove, from its bad block list,
 *		the entries describing the bad LV blocks contained in the
 *		given file system block.
 *
 * PARAMETERS:	
 *	bdblk_recptr	ptr to the bad block record describing the file
 *			system block which is now allocated to the Bad 
 *			Block inode.
 *
 * NOTES:	Each bad block record describes one file system block
 *		which contains one or more bad LV blocks.
 *
 * RETURNS:
 *      success: 0
 *      failure: something else
 */
int32 tell_LVM( cbbl_bdblk_recptr thisrec ) 
{
    int32 tl_rc = 0;
    int32 lvidx;
    int32 bufsize = 0;
    DDI_OS2LVM_param LVMpp;
    DDI_OS2LVM_param *pLVMpp = &LVMpp;
    DDI_OS2LVM_data LVMdp;
    DDI_OS2LVM_data *pLVMdp = &LVMdp;
    ULONG ppLen = 0;
    ULONG dpLen = 0;

	/* 
	 * initialize the LVM DosDevIOCtl parm and data packets
	 */
    pLVMpp->Command = REMOVE_TBL_ENTRY;
    pLVMpp->DriveUnit = 0;
    pLVMpp->TableNumber = thisrec->LV_table;
    pLVMdp->ReturnData = 0;
    pLVMdp->UserBuffer = NULL; 

		/*
		 * process each LV block contained in the given
		 * FS block.
		 *
		 * N.B. We'll exit the loop if the DosDevIOCtl fails,
		 *      but not if the LVM fails to execute the request
		 *	successfully.
		 */
    for( lvidx = 0; 
	 ((lvidx < MAX_LVBLKS_PER_FSBLK) && (tl_rc == 0)); 
	 lvidx++ ) {
	if( thisrec->LV_blkno[lvidx] != 0 ) {  /*
				* 0 can never be an actual LV block number
				* in this context since the 1st block in
				* the file system is NEVER relocated.
				*/
		/*
		 * tell the LVM to forget this one 
		 */
	    pLVMpp->LSN = thisrec->LV_blkno[lvidx];
	    tl_rc = DosDevIOCtl( LVHandle,		IOC_DC,	 
				 IODC_LV,	 	(void *) pLVMpp, 
				 sizeof(DDI_OS2LVM_param),
				 &ppLen,		 (void *) pLVMdp, 
				 sizeof(DDI_OS2LVM_data), 	 &dpLen	
				);
	    }  /* end if */
	}  /* end for lvidx = ... */

    if( tl_rc != 0 ) {	
	return( CBBL_LVMRC_7 - tl_rc );
	}
    else {
	thisrec->LVM_notified = -1;
	agg_recptr->resolved_blocks += 1;
	}

    return( tl_rc );
}				/* end tell_LVM() */
Ejemplo n.º 28
0
/*!
   Return the size of the CD in logical block address (LBA) units.
 */
static lsn_t
get_disc_last_lsn_os2 (void *p_user_data)
{
  _img_private_t *p_env = p_user_data;

  struct {
    UCHAR auch_sign[4];
  } s_param = {{'C', 'D', '0', '1'}};

  ULONG ul_data_volume_size;
  ULONG ul_param_len;
  ULONG ul_data_len;
  ULONG rc;

  rc = DosDevIOCtl(
          p_env->h_cd, IOCTL_CDROMDISK, CDROMDISK_GETVOLUMESIZE,
          &s_param, sizeof( s_param ), &ul_param_len,
          &ul_data_volume_size, sizeof( ul_data_volume_size ), &ul_data_len );

  if( rc )
  {
    cdio_warn("get_disc_last_lsn_os2 : DosDevIOCtl(GETVOLUMESIZE) = 0x%lx\n", rc );

    return CDIO_INVALID_LSN;
  }

  return ul_data_volume_size;
}
Ejemplo n.º 29
0
APIRET
DosKillFastIo( PID pid )
{
  APIRET rc;
  HFILE  hfd;
  ULONG  action, plen;


  if(( rc = DosOpen((PSZ)"/dev/fastio$", (PHFILE)&hfd,
                    (PULONG)&action, (ULONG)0, FILE_SYSTEM, FILE_OPEN,
                    OPEN_SHARE_DENYNONE | OPEN_FLAGS_NOINHERIT | OPEN_ACCESS_READONLY,
                    (ULONG)0)) != NO_ERROR )
  {
    return rc;
  }

  if(( rc = DosDevIOCtl( hfd, (ULONG)0x76, (ULONG)0x65,
                        (PULONG*)&pid, sizeof(USHORT), &plen, NULL, 0, NULL)) != 0 )
  {
    DosClose( hfd );
    return rc;
  }

  DosClose(hfd);
  return NO_ERROR;
}
Ejemplo n.º 30
0
void main()
{
    USHORT rc, Action;
    HFILE FileHandle;

    DosSetSigHandler(BrkHandler, NULL, NULL, SIGA_ACCEPT, SIG_CTRLC);
    DosSetSigHandler(BrkHandler, NULL, NULL, SIGA_ACCEPT, SIG_KILLPROCESS);
    DosSetSigHandler(BrkHandler, NULL, NULL, SIGA_ACCEPT, SIG_CTRLBREAK);

    DosSetPrty(PRTYS_PROCESS, PRTYC_IDLETIME, 0, 0);

    rc = DosOpen("Idlehlt$", &FileHandle, &Action, 0L,
                 FILE_NORMAL, FILE_OPEN, OPEN_SHARE_DENYNONE, 0L);

    if(!rc) {
        while(!ExitWhile)
            DosDevIOCtl(NULL, NULL, 0x01, 0x91, FileHandle);
        DosClose(FileHandle);
    } else {
        char buf[6], Message[36] = "HLT Driver not installed? rc=";
        char *src = buf, *dst = &Message[29];
        int len;

        utoa(rc, buf, 10);
        while(*dst++ = *src++);
        len = dst - Message;
        Message[len-1] = '\r';
        Message[len] = '\n';

        DosWrite(STDERR_FILENO, Message, len+1, &Action);
    }
}