Quelltext /~heha/hs/glpntdrv.zip/h#s/KrnlInterfaceHdw.cpp

#include "glpntdrv.h"

/*************
 ** BasicIO **
 *************/

void BasicIO::WRITE(int offset, UCHAR data) {
 WRITE_PORT_UCHAR(PUCHAR(lptport+offset),data);
 old[offset]=data;
}

UCHAR BasicIO::READ(int offset) {
 if (!(offset&1)) return old[offset];	// Kurzschluss für +0 und +2
 return READ_PORT_UCHAR(PUCHAR(lptport+offset));
}

// Zustand von Busy abfragen, dabei <busywaitcount> Zyklen (etwa µs) warten
// Liefert 0x80 wenn BUSY = HIGH
UCHAR BasicIO::Busy() {
 for (int i=0; i<pCmdBuf->busywaitcount; i++) READ(1);
 return ~READ(1)&0x80;
}

/* Datenbyte (7 Bit) mit Taktung (= Toggeln von Bit 7) ausgeben
0x20 - StartPgmImpuls
0x00 - ReadDatenRegByte, ReadDatenRegWord, ReadDatenRegPin1_20, ReadDatenRegPin21_40
argn - DataOut
0x71 - SwitchInterfaceMode(true) bei SetL1, ResetL1
0x70 - SwitchInterfaceMode(false) sonst
0x1? - SetL1
flag_0c7d - ResetL1
0x5? - SetReadbackChannel
0x3? - LoadTimerSerReg, Bit 0 = serielle Daten, Bit 15 zuerst
Tatsächlich wird nur _eine_Flanke ausgegeben! Das GALEP benutzt offenbar beide Flanken. */
void BasicIO::DataOut(UCHAR b) {
 if (pCmdBuf->loopcount) {
  WRITE(0,READ(0)&0x80|b);
  for (int i=0; i<pCmdBuf->loopcount; i++) {
   WRITE(0,READ(0)&0x80|b);
  }
  WRITE(0,READ(0)^0x80);
 }else{
  WRITE(0,~READ(0)&0x80|b);
 }
}

/**********************
 ** KrnlInterfaceHdw **
 **********************/

BOOL KrnlInterfaceHdw::WaitForNotBusy() {
 for (int i=0; i<=pCmdBuf->busyloopcount; i++) {
  if (!Busy()) return TRUE;
 }
 return FALSE;
}

void KrnlInterfaceHdw::SwitchInterfaceMode(bool mode) {
 if (pCmdBuf->interfacemode!=mode) {
  pCmdBuf->interfacemode=mode;
  DataOut(0x70|(UCHAR)mode);
 }
}

void KrnlInterfaceHdw::SetL1_Q11() {
 if (!pCmdBuf->flag_9C7F) {
  pCmdBuf->flag_9C7F=0x10;
  SwitchInterfaceMode(true);
  DataOut(0x11|pCmdBuf->flag_9C7E);
 }
}

void KrnlInterfaceHdw::ResetL1_Q00() {
 if (pCmdBuf->flag_9C7C) {
  pCmdBuf->flag_9C7C=false;
  SwitchInterfaceMode(true);
  DataOut(pCmdBuf->flag_9C7D);
 }
}

void KrnlInterfaceHdw::SetReadbackChannel(UCHAR chn) {
 SwitchInterfaceMode(false);
 DataOut(0x50|chn);
}

// ReadbackChannel == 2: ReadDatenRegByte (bits==8), ReadDatenRegWord (bits==16)
// == 0x0A: ReadDatenRegPin1_20  (bits==20) -> // Pinreihe 1..20 lesen (20 Bit)
// == 0x0C: ReadDatenRegPin21_40 (bits==20) -> // Pinreihe 21..40 lesen (20 Bit)
ULONG KrnlInterfaceHdw::ReadDatenReg(UCHAR ReadbackChannel, int bits) {
 SetL1_Q11();
 if (!(ReadbackChannel&8)) ResetL1_Q00();	// nur für ReadDatenReg[Byte|Word]
 SetReadbackChannel(ReadbackChannel);
 ULONG ret=0;
 for (int i=0; i<bits; i++) {	// 8 oder 16 Bits lesen
  ret<<=1;
  if (Busy()) ret++;
  DataOut(0);
 }
 return ret;
}

void KrnlInterfaceHdw::LoadTimerSerReg(ULONG val) {
 SwitchInterfaceMode(false);
 for (ULONG mask=0x8000; mask; mask>>=1) DataOut(val&mask ? 0x31 : 0x30);
}

void KrnlInterfaceHdw::StartPgmImpuls() {
 SwitchInterfaceMode(false);
 DataOut(0x20);		// 0x20 == StartPgmImpuls
}

bool KrnlInterfaceHdw::MeasureBusySpeed() {
 LoadTimerSerReg(CalcTimerWert(100));
 /*
 DisableCallCount++;
 if (!IsIrplHigh) {
  IsIrplHigh=true;
  SetIrqlHigh();
 }
 */
 StartPgmImpuls();
 SetReadbackChannel(6);
 ULONG i;
 for (i=0;Busy();i++);
 //Enable();
 if (i>=1) {
  pCmdBuf->BusySpeed=i;
  return true;
 }
 return false;
}