-- MouseVerifyControl.mesa
-- created by Haeberli: 23-Dec-81 13:00:45

DIRECTORY
  JaMFnsDefs,
  InlineDefs,
  IODefs,
  Mouse,
  MouseMossimImpl,
  MouseSimImpl;

MouseVerifyControl: PROGRAM
  IMPORTS Chip: MouseMossimImpl, InlineDefs, IODefs, JaMFnsDefs, Sim: MouseSimImpl
  =
  {
  OPEN JaMFnsDefs;

  maxDebounceTest: CARDINAL = 100;

  Bit: TYPE = [0..1];
  Sensor: TYPE = [0..16);
  Pattern: TYPE = ARRAY Sensor OF Bit;
  PatIndex: TYPE = [0..30);
  lastPattern: PatIndex _ 0;
  currentPattern: PatIndex _ 0;

  PatOrderLeftToRight: ARRAY Sensor OF Sensor = [
    15, 11, 7, 3, 14, 10, 6, 2, 13, 9, 5, 1, 12, 8, 4, 0];

  PatOrderRightToLeft: ARRAY Sensor OF Sensor = [
    0, 4, 8, 12, 1, 5, 9, 13, 2, 6, 10, 14, 3, 7, 11, 15];

  PatOrder: ARRAY Sensor OF Sensor _ PatOrderLeftToRight;

  version: Mouse.ChipVersion _ Rev3;


  TestPatterns: ARRAY PatIndex OF Pattern = [
    [0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [
    0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0], [
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0], [
    0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0], [
    1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1], [
    0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0], [
    0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0], [
    0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0], [
    0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0], [
    0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0], [
    0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0], [
    0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0], [
    0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0], [
    0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0], [
    1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0], [
    1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0], [
    0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0], [
    0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [
    0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1], [
    0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1], [
    0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0], [
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0], [
    1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0], [
    1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0], [
    0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0], [
    0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0], [
    0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1], [
    0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1], [
    0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0], [
    0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0]];

  TestIndex: TYPE = [0..1000);
  indexTest: TestIndex _ 0;
  TestEntry: TYPE = RECORD [curPat: PatIndex, sXA, sXB, sYA, sYB: Mouse.Value];

  -- Local Procedures

  BothSetPin: PROCEDURE [pin: Mouse.Pin, val: Mouse.Value] = {
    Sim.SetPin[pin, val]; Chip.SetPin[pin, val]};

  CheckResult: PROCEDURE RETURNS [equal: BOOLEAN] = {
    equal _ (ComparePin[XA]) AND (ComparePin[XB]) AND (ComparePin[YA])
      AND (ComparePin[YB]);
    RETURN[equal]};

  ChipSetPin: PROCEDURE [pin: Mouse.Pin, val: Mouse.Value] = {
    Chip.SetPin[pin, val]};

  ComparePin: PROCEDURE [pin: Mouse.Pin] RETURNS [equal: BOOLEAN] = {
    equal _ Sim.GetPin[pin] = Chip.GetPin[pin]};

  FullTest: PROCEDURE RETURNS [success: BOOLEAN _ TRUE] = {
    SetPin _ BothSetPin;
    FOR p: PatIndex IN PatIndex DO
      FOR q: PatIndex IN [p..LAST[PatIndex]] DO
        SetPattern[q];
        success _ success AND CheckResult[];
        IF NOT success THEN EXIT;
        SetPattern[p];
        success _ success AND CheckResult[];
        IF NOT success THEN EXIT
        ENDLOOP;
      IF NOT success THEN EXIT;
      ENDLOOP;
    RETURN[success]};

  GateTestPattern: PROCEDURE = {
    SetPin[GateTest, zero];
    SetPin[TestEnable, one];
    SetPin[GateTest, one];
    SetPin[GateTest, zero];
    SetPin[TestEnable, zero];
    };

  GetPin: PROCEDURE [pin: Mouse.Pin] RETURNS [value: Mouse.Value] = {
    RETURN[Chip.GetPin[pin]]};

  InitializeCounters: PROCEDURE RETURNS [success: BOOLEAN] = {
    maxInitTries: CARDINAL = 16;

    HCI: TYPE = [0..4);
    HCT: TYPE = ARRAY HCI OF PatIndex;

    xhct: HCT = [4, 28, 11, 24];
    yhct: HCT = [4, 25, 13, 29];

    Counter: PROC [a, b: Mouse.Pin] RETURNS [c: [0..4)] = {
      av: INTEGER _ LOOPHOLE[GetPin[a]];
      bv: INTEGER _ LOOPHOLE[GetPin[b]];
      c _ InlineDefs.BITSHIFT[av, 1] + bv;
      };
    InitAll: PROC = {FOR i: CARDINAL IN [0..4) DO SetPattern[4] ENDLOOP};
    InitCounter: PROC [a, b: Mouse.Pin, hct: HCT]
      RETURNS [success: BOOLEAN _ TRUE] = {
      SetPattern[4];
      SetPattern[4];
      FOR l: CARDINAL IN [0..maxInitTries) DO
        FOR i: HCI IN HCI DO
          SetPattern[hct[i]]; IF Counter[a, b] = 3 THEN EXIT ENDLOOP;
        IF Counter[a, b] = 3 THEN EXIT
        REPEAT FINISHED => success _ FALSE
        ENDLOOP;
      SetPattern[4];
      SetPattern[4];
      FOR l: CARDINAL IN [0..maxInitTries) DO
        FOR i: HCI IN HCI DO
          SetPattern[hct[i]]; IF Counter[a, b] = 0 THEN EXIT ENDLOOP;
        IF Counter[a, b] = 0 THEN EXIT
        REPEAT FINISHED => success _ FALSE
        ENDLOOP;
      SetPattern[4];
      SetPattern[4];
      SetPattern[5]};

    SetPin _ ChipSetPin;

    SetPin[GateTest, zero];
    InitAll;
    success _ InitCounter[XA, XB, xhct];
    success _ InitCounter[YA, YB, yhct] AND success;
    success _ (Counter[XA, XB] = 0) AND (Counter[YA, YB] = 0) AND success;
    SetPin _ BothSetPin};

  OneTestDebounce: PROCEDURE [a, b: Mouse.Pin]
    RETURNS [success: BOOLEAN _ FALSE] = {
    SetPin[a, x];
    SetPin[b, x];
    SetPin[a, zero];
    SetPin[a, x];
    success _ ComparePin[a] AND ComparePin[b];
    SetPin[b, zero];
    SetPin[b, x];
    success _ ComparePin[a] AND ComparePin[b] AND success;
    };

  SetPattern: PROCEDURE [pat: PatIndex, gate: BOOLEAN _ TRUE] = {
    ShiftTestBit: PROC [bit: Bit] = {
      SetPin[TestData, zero];
      SetPin[TestClock, zero];
      SetPin[TestData, LOOPHOLE[1 - bit, Mouse.Value]];
      SetPin[TestClock, one];
      SetPin[TestClock, zero];
      SetPin[TestData, zero]};

    SetPin[TestEnable, one];
    SELECT version FROM
      Rev3 => {FOR s: Sensor IN Sensor DO
        ShiftTestBit[TestPatterns[pat][PatOrder[s]]]; ENDLOOP;
};
      Rev4, Rev5 => {FOR s: Sensor IN Sensor DO
        ShiftTestBit[LOOPHOLE[1 - TestPatterns[pat][PatOrder[s]]]]; ENDLOOP;
      ShiftTestBit[1];
};
      Rev6, Rev7 => {FOR s: Sensor IN Sensor DO
        ShiftTestBit[LOOPHOLE[1 - TestPatterns[pat][PatOrder[s]]]]; ENDLOOP;
      ShiftTestBit[1]; ShiftTestBit[1];
};
      ENDCASE;

    SetPin[TestEnable, zero];
    IF gate THEN {
      GateTestPattern[]; lastPattern _ currentPattern; currentPattern _ pat}};

  SetPin: PROCEDURE [pin: Mouse.Pin, val: Mouse.Value] _ BothSetPin;

  SimSetPin: PROCEDURE [pin: Mouse.Pin, val: Mouse.Value] = {
    Sim.SetPin[pin, val]};

  TestDebounce: PROCEDURE [color: STRING, a, b: Mouse.Pin]
    RETURNS [success: BOOLEAN _ FALSE] = {
    FOR i: CARDINAL IN [0..maxDebounceTest) DO
      IF NOT OneTestDebounce[a, b] THEN GOTO Failed;
      REPEAT Failed => {success _ FALSE}; FINISHED => {success _ TRUE};
      ENDLOOP};

  TestDebouncers: PROCEDURE RETURNS [success: BOOLEAN] = {
    success _ TestDebounce["Red", RedA, RedB];
    success _ TestDebounce["Yellow", YellowA, YellowB] AND success;
    success _ TestDebounce["Blue", BlueA, BlueB] AND success};


  -- JaM Procedures

  CGP: PROCEDURE = {
    pin: Mouse.Pin = LOOPHOLE[PopInteger[]];
    PushInteger[LOOPHOLE[Chip.GetPin[pin]]];
    };

  CSP: PROCEDURE = {
    val: Mouse.Value = LOOPHOLE[PopInteger[]];
    pin: Mouse.Pin = LOOPHOLE[PopInteger[]];

    Chip.SetPin[pin, val];
    };

  Mouse16Pin: PROCEDURE = {
    pinMap: Mouse.PinMap = [
      RedA: 98, RedB: 99, YellowA: 108, YellowB: 109, BlueA: 110, BlueB: 111,
      TestEnable: 112, Gnd: 114, YA: 119, YB: 118, XA: 117, XB: 116,
      TestData: 115, TestClock: 114, GateTest: 107, Vdd: 106, AnyGood: 105,
      Jump: 104];

    Chip.SetPinMap[pinMap]};

  Mouse40Pin: PROCEDURE = {
    pinMap: Mouse.PinMap = [
      RedA: 3, RedB: 4, YellowA: 12, YellowB: 13, BlueA: 14, BlueB: 15,
      TestEnable: 32, Gnd: 33, YA: 41, YB: 40, XA: 23, XB: 22, TestData: 21,
      TestClock: 20, GateTest: 1, Vdd: 2, AnyGood: 11, Jump: 24];

    Chip.SetPinMap[pinMap]};

  MouseProbeCard: PROCEDURE = {
    pinMap: Mouse.PinMap = [
      RedA: 38, RedB: 39, YellowA: 59, YellowB: 69, BlueA: 61, BlueB: 60,
      TestEnable: 33, Gnd: 31, YA: 29, YB: 19, XA: 1, XB: 0, TestData: 6,
      TestClock: 8, GateTest: 27, Vdd: 37, AnyGood: 10, Jump: 3];

    Chip.SetPinMap[pinMap]};

  Reset: PROCEDURE = {Chip.Reset; Sim.Reset; MouseProbeCard; SetPin _ BothSetPin};

  JaMSetPattern: PROCEDURE = {
    patIndex: PatIndex = LOOPHOLE[PopInteger[]];
    SetPin _ ChipSetPin;
    SetPattern[patIndex];
    SetPin _ BothSetPin};

  JaMSetPatternNG: PROCEDURE = {
    patIndex: PatIndex = LOOPHOLE[PopInteger[]];
    SetPin _ ChipSetPin;
    SetPattern[patIndex, FALSE];
    SetPin _ BothSetPin};

  SetVersions: PROCEDURE [v: Mouse.ChipVersion] = {
    Sim.SetVersion[v];
    Chip.SetVersion[v];
    version _ v;
    PatOrder _ IF v = Rev3 THEN PatOrderLeftToRight ELSE PatOrderRightToLeft};

  SetVersion: PROCEDURE = {
    version: Mouse.ChipVersion = LOOPHOLE[PopInteger[]];
    SetVersions[version]};

  SGP: PROCEDURE = {
    pin: Mouse.Pin = LOOPHOLE[PopInteger[]];
    PushInteger[LOOPHOLE[Sim.GetPin[pin]]];
    };

  SSP: PROCEDURE = {
    val: Mouse.Value = LOOPHOLE[PopInteger[]];
    pin: Mouse.Pin = LOOPHOLE[PopInteger[]];

    Sim.SetPin[pin, val];
    };

  TestAMouse: PROCEDURE = {
    OPEN IODefs;

    status: INTEGER _ 0;
    Sim.Reset;

    IF TestDebouncers[] THEN WriteLine["Debouncers Tested OK"]
    ELSE {WriteLine["Debouncer test failed"]; status _ 1};
    IF InitializeCounters[] THEN {
      IF FullTest[] THEN WriteLine["Mouse is Good!"]
      ELSE {
        WriteString["Initialized OK, full test failed at step from: "];
        WriteDecimal[lastPattern];
        WriteString["  to: "];
        WriteDecimal[currentPattern];
        WriteLine[""];
        status _ status + 2 + (8*currentPattern) + (30*8*lastPattern)}}
    ELSE {WriteLine["Unable to initialize counters"]; status _ status + 4};
    PushInteger[status];
    };

  {
  Register["cgp", CGP];
  Register["csp", CSP];
  Register["mouse16pin", Mouse16Pin];
  Register["mouse40pin", Mouse40Pin];
  Register["mouseprobecard", MouseProbeCard];
  Register["reset", Reset];
  Register["setpattern", JaMSetPattern];
  Register["spng", JaMSetPatternNG];
  Register["setversion", SetVersion];
  Register["sgp", SGP];
  Register["ssp", SSP];
  Register["testamouse", TestAMouse];

  Reset;
  };

  }.