ss80.c

Go to the documentation of this file.

 
#include "user_config.h"
 
#include "defines.h"
#include "gpib_hal.h"
#include "gpib.h"
#include "gpib_task.h"
#include "amigo.h"
#include "ss80.h"
#include "vector.h"
#include "debug.h"
 
 
extern uint8_t talking;
extern uint8_t listening;
extern uint8_t spoll;
 
enum ss80exec
{
    EXEC_IDLE,
    EXEC_LOCATE_AND_READ,
    EXEC_LOCATE_AND_WRITE,
    EXEC_SEND_STATUS,
    EXEC_DESCRIBE
};
 
int TD[] =
{
    0x3F,
    0x5f | ATN_FLAG,
    0x20 | ATN_FLAG,
    0x65 | ATN_FLAG,
    0x20,
    0x40,
    0x34,                                         // NOP
    0x37,                                         // Format
    0x00,
    0x0a,
    -1
};
 
void SS80_Test(void)
{
#if SDEBUG
    if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
        printf("[SS80 Test]\n");
#endif
#if SDEBUG
    if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
    {
        printf("[SS80 Test Done]\n");
        sep();
    }
#endif
}
 
 
 
void V2B_MSB_Index1(uint8_t *B, int index,int size, uint32_t val)
{
    V2B_MSB(B, index-1,size, val);
}
 
 
uint8_t *SS80ControllerPack(int *size)
{
    static uint8_t B[5];
    *size = 5;
/*
    uint8_t C1;  //<  MSB units installed bit field
                 //< one bit per unit, Unit 15 always set
    uint8_t C2;  //<  LSB
    uint8_t C3;  //<  MSB Instantaneous transfer rate in kb/s
    uint8_t C4;  //<  LSB
    uint8_t C5;  //<  Controller type
             //< 0 = CS/80 integrated single unit controller.
             //< 1 = CS/8O integrated multi-unit controller.
             //< 2 = CS/8O integrated multi-port controller.
             //< 4 = SS/8O integrated single unit controller.
//< 5 = SS/80 integrated multi-unit controller.
//< 6 = SS/80 integrated multi-port controller.
*/
    V2B_MSB_Index1(B,1,2,SS80p->CONTROLLER.UNITS_INSTALLED);
    V2B_MSB_Index1(B,2,2,SS80p->CONTROLLER.TRANSFER_RATE);
    V2B_MSB_Index1(B,5,1,SS80p->CONTROLLER.TYPE);
 
    return(B);
}
 
 
uint8_t *SS80UnitPack(int *size)
{
    static uint8_t B[19];
    *size = 19;
/*
    uint8_t U1;  //<  Type 0-Fixed, 1-Flexible, 2-Tape
                 //< (+128-dumb, does not detect media change)
    uint8_t U2;  //<  MSB Device number
    uint8_t U3;  //<  (HP 9133 = 09 13 30)
    uint8_t U4;  //<     LSB
    uint8_t U5;  //<  MSB Bytes per block
    uint8_t U6;  //<     LSB
    uint8_t U7;  //<  Number of buffered blocks
    uint8_t U8;  //<  Burst size (0 for SS/80)
    uint8_t U9;  //<  MSB Block time in ms
uint8_t U10; //<     LSB
uint8_t U11; //<  MSB Continous average transfer rate
uint8_t U12; //<     LSB
uint8_t U13; //<  MSB Optimal retry in tens of ms
uint8_t U14; //<     LSB
uint8_t U15; //<  MSB Access time in tens of ms
uint8_t U16; //<     LSB
uint8_t U17; //<  Maximum interleave or 0
uint8_t U18; //<  Fixed volume byte, one bit per volume,
//< ie 00000111 = 3 volumes
uint8_t U19; //<  Removable volume byte, one bit per volume,
//< ie 00000111 = 3 volumes
*/
    V2B_MSB_Index1(B,1,1,SS80p->UNIT.UNIT_TYPE);
    V2B_MSB_Index1(B,2,3,SS80p->UNIT.DEVICE_NUMBER);
    V2B_MSB_Index1(B,5,2,SS80p->UNIT.BYTES_PER_BLOCK);
    V2B_MSB_Index1(B,7,1,SS80p->UNIT.BUFFERED_BLOCKS);
    V2B_MSB_Index1(B,8,1,SS80p->UNIT.BURST_SIZE);
    V2B_MSB_Index1(B,9,2,SS80p->UNIT.BLOCK_TIME);
    V2B_MSB_Index1(B,11,2,SS80p->UNIT.CONTINUOUS_TRANSFER_RATE);
    V2B_MSB_Index1(B,13,2,SS80p->UNIT.OPTIMAL_RETRY_TIME);
    V2B_MSB_Index1(B,15,2,SS80p->UNIT.ACCESS_TIME);
    V2B_MSB_Index1(B,17,1,SS80p->UNIT.MAXIMUM_INTERLEAVE);
    V2B_MSB_Index1(B,18,1,SS80p->UNIT.FIXED_VOLUMES);
    V2B_MSB_Index1(B,19,1,SS80p->UNIT.REMOVABLE_VOLUMES);
    return(B);
}
 
 
uint8_t *SS80VolumePack(int *size)
{
    static uint8_t B[13];
    *size = 13;
/*
    uint8_t V1;  //<  MSB Max cylinder
    uint8_t V2;  //<
    uint8_t V3;  //<     LSB
    uint8_t V4;  //<  Maximum head 0 based
    uint8_t V5;  //<  MSB Maximum sector 0 based
    uint8_t V6;  //<     LSB
    uint8_t V7;  //<  MSB Max number of blocks
    uint8_t V8;
    uint8_t V9;
    uint8_t V10;
uint8_t V11;
uint8_t V12; //<     LSB
uint8_t V13; //<  Interleave
*/
    V2B_MSB_Index1(B,1,3,SS80p->VOLUME.MAX_CYLINDER);
    V2B_MSB_Index1(B,4,1,SS80p->VOLUME.MAX_HEAD);
    V2B_MSB_Index1(B,5,2,SS80p->VOLUME.MAX_SECTOR);
    V2B_MSB_Index1(B,7,6,SS80p->VOLUME.MAX_BLOCK_NUMBER);
    V2B_MSB_Index1(B,13,1,SS80p->VOLUME.INTERLEAVE);
    return(B);
}
 
 
void SS80_init(void)
{
 
    int i;
    for(i=MAX_DEVICES-1;i>=0;--i)
    {
        if(Devices[i].TYPE == SS80_TYPE)
        {
            if(!set_active_device(i))
                continue;
            Clear_Common(15);
// Power On State
            SS80s->qstat = 2;
#if SDEBUG
            if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
                printf("[SS80 %02XH INIT]\n", Devices[i].ADDRESS);
#endif
            gpib_disable_PPR(SS80p->HEADER.PPR);
        }
    }
}
 
 
int SS80_Execute_State(void)
{
    int ret = 0;
 
    gpib_disable_PPR(SS80p->HEADER.PPR);
    switch(SS80s->estate)
    {
        case EXEC_IDLE:
            break;
        case EXEC_LOCATE_AND_READ:
            ret = SS80_locate_and_read();
            SS80s->estate = EXEC_IDLE;
            break;
        case EXEC_LOCATE_AND_WRITE:
            ret = SS80_locate_and_write();
            SS80s->estate = EXEC_IDLE;
            break;
        case EXEC_SEND_STATUS:
            ret = SS80_send_status();
            SS80s->estate = EXEC_IDLE;
            break;
        case EXEC_DESCRIBE:
            ret = SS80_describe();
            SS80s->estate = EXEC_IDLE;
            break;
        default:
            if(debuglevel & GPIB_ERR)
                printf("[SS80 EXEC state:%d error]\n", SS80s->estate);
            SS80s->estate = EXEC_IDLE;
            break;
    }
    gpib_enable_PPR(SS80p->HEADER.PPR);
    return(ret);
}
 
 
uint32_t SS80_Blocks_to_Bytes(uint32_t block)
{
    return(block * SS80p->UNIT.BYTES_PER_BLOCK);
 
}
 
 
uint32_t SS80_Bytes_to_Blocks(uint32_t bytes)
{
    return(bytes / SS80p->UNIT.BYTES_PER_BLOCK);
}
 
 
 
int SS80_locate_and_read( void )
{
    DWORD total_bytes;
    DWORD count;
    int chunk;
    int len;
    uint16_t status;
    uint32_t Address = SS80_Blocks_to_Bytes(SS80s->AddressBlocks);
 
    SS80s->qstat = 0;
 
    status = 0;
 
    if( GPIB_IO_RD(IFC) == 0)
        return(IFC_FLAG);
 
 
#if SDEBUG
    if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
        printf("[SS80 Locate and Read at %08lXH(%lXH)]\n",
            (long) Address, (long) SS80s->Length);
#endif
 
    if( SS80_cmd_seek() )
    {
        return(SS80_error_return());
    }
 
    count = SS80s->Length;
    total_bytes = 0;
    while(count > 0 )
    {
        if( GPIB_IO_RD(IFC) == 0)
        {
            return(IFC_FLAG);
        }
 
        if(count > 256)
        {
            chunk = 256;
            status = 0;                           // GPIB status
        }
        else
        {
            chunk = count;
            status |= EOI_FLAG;                   // GPIB EOI on final charater
        }
 
#if SDEBUG
        if(debuglevel & GPIB_DISK_IO_TIMING)
            gpib_timer_elapsed_begin();
#endif
 
// FIXME len != chunk
        len = dbf_open_read(SS80p->HEADER.NAME, Address, gpib_iobuff, chunk, &SS80s->Errors);
 
#if SDEBUG
        if(debuglevel & GPIB_DISK_IO_TIMING)
            gpib_timer_elapsed_end("disk READ ");
        if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
            printf("[SS80 Disk Read %02XH bytes]\n", len);
#endif
        if(len < 0)
        {
            SS80s->qstat = 1;
            if(debuglevel & GPIB_ERR)
                printf("[SS80 Disk Read Error]\n");
            return( SS80_error_return() );
        }
 
#if SDEBUG
        if(debuglevel & GPIB_RW_STR_TIMING)
            gpib_timer_elapsed_begin();
#endif
        len = gpib_write_str(gpib_iobuff, chunk, &status);
#if SDEBUG
        if(debuglevel & GPIB_RW_STR_TIMING)
            gpib_timer_elapsed_end("GPIB write");
#endif
        if( len != chunk)
        {
            SS80s->qstat = 1;
            if(debuglevel & GPIB_ERR)
                printf("[SS80 GPIB Write Error]\n");
            if(status & ERROR_MASK)
            {
                SS80s->Errors |= ERR_GPIB;
                break;
            }
        }
 
        Address += chunk;
        total_bytes = total_bytes + len;
        count -= len;
    }
    if(count > 0)
    {
        if(debuglevel & GPIB_ERR)
            printf("[SS80 Buffered Read DID NOT FINISH]\n");
    }
    else
    {
#if SDEBUG
        if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
            printf("[SS80 Buffered Read Total(%lXH) bytes]\n", (long) total_bytes);
#endif
    }
 
    SS80s->AddressBlocks = SS80_Bytes_to_Blocks(Address);
    return (status & ERROR_MASK);
}
 
 
 
int SS80_locate_and_write(void)
{
    DWORD total_bytes;                            // Keeps track of data actually written to disk
    int chunk, count, len;
    int io_skip;
    uint16_t status;
    uint32_t Address = SS80_Blocks_to_Bytes(SS80s->AddressBlocks);
 
    io_skip = 0;
 
#if SDEBUG
    if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
        printf("[SS80 Locate and Write at %08lXH(%lXH)]\n", (long)Address, (long)SS80s->Length);
#endif
 
    SS80s->qstat = 0;
 
    if( GPIB_IO_RD(IFC) == 0)
        return(IFC_FLAG);
 
    if( SS80_cmd_seek() )
    {
        SS80s->Errors |= ERR_WRITE;
        io_skip = 1;
    }
 
    count = SS80s->Length;
    total_bytes = 0;
 
    status = 0;
 
    while(count > 0)                              // Loop until we have received Length sectors or EOI
    {
        if( GPIB_IO_RD(IFC) == 0)
        {
            return(IFC_FLAG);
        }
 
        if(count > 256)
            chunk = 256;
        else
            chunk = count;
 
        Mem_Clear(gpib_iobuff);
 
#if SDEBUG
        if(debuglevel & GPIB_RW_STR_TIMING)
            gpib_timer_elapsed_begin();
#endif
        len = gpib_read_str(gpib_iobuff, (UINT) chunk, &status);
 
#if SDEBUG
        if(debuglevel & GPIB_RW_STR_TIMING)
            gpib_timer_elapsed_end("GPIB read ");
#endif
 
        if( len != chunk)
        {
            if(status & ERROR_MASK)
            {
                if(debuglevel & GPIB_ERR)
                    printf("[GPIB Read Error]\n");
                SS80s->Errors |= ERR_WRITE;
                SS80s->qstat = 1;
                break;
            }
            if(!len && (EOI_FLAG & status))
                break;
        }
 
        if(!io_skip)
        {
            if(len)
            {
                int len2;
#if SDEBUG
                if(debuglevel & GPIB_DISK_IO_TIMING)
                    gpib_timer_elapsed_begin();
#endif
                len2 = dbf_open_write(SS80p->HEADER.NAME, Address, gpib_iobuff, len, &SS80s->Errors);
#if SDEBUG
                if(debuglevel & GPIB_DISK_IO_TIMING)
                    gpib_timer_elapsed_end("disk WRITE");
#endif
                if(len2 != len)
                {
                    SS80s->Errors |= ERR_WRITE;
                    if(mmc_wp_status())
                        SS80s->Errors |= ERR_WP;
                    SS80s->qstat = 1;
                    io_skip = 1;                  // Stop writing
                    if(debuglevel & GPIB_ERR)
                        printf("[Disk Write Error]\n");
                }
                else
                {
#if SDEBUG
                    if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
                        printf("[SS80 Locate and Write wrote(%02XH)]\n", len2);
#endif
                    Address += len;
                }
 
                if(len2 >= len)
                    total_bytes += len2;
                else
                    total_bytes += len;
            }                                     // len
        }                                         // io_skip
 
        count -= len;
 
        if(status & EOI_FLAG)
            break;
    }
 
    if(count > 0)
    {
        if(debuglevel & GPIB_ERR)
            printf("[SS80 Locate and Write DID NOT FINISH]\n");
    }
    else
    {
#if SDEBUG
        if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
            printf("[SS80 Locate and Write Wrote Total(%lxH)]\n", total_bytes);
#endif
    }
    SS80s->AddressBlocks = SS80_Bytes_to_Blocks(Address);
    return ( status & ERROR_MASK );
}
 
 
fault_t faults[] =
{
    { 2, "Channel Parity Error or the Loopback command failed." },
    { 5, "Illegal Opcode or command not allowed on Unit 15" },
    { 6, "illegal Volume or Unit number was specified for this device." },
    { 7, "Address Bounds exceeded for this device." },
    { 8, "Parameter Bounds error (other than unit, volume, or target address)"},
    { 9, "Parameter field wrong length for the opcode preceding it." },
    { 10,"Unexpected Secondary. Except for active reject,fault or access errors" },
    { 12,"Message Length error" },
    { 17,"Unit 15 Cross-unit error" },
    { 19,"Controller hardware Fault" },
    { 22,"Unit hardware Fault" },
    { 24,"Diagnostic failed selftest" },
    { 30,"Power Fail, or a new Tape or Flexible disc was loaded." },
    { 31,"Re-try preceding transaction" },
    { 33,"Uninitialized media" },
    { 34,"No Spares Available" },
    { 35,"Not Ready, medium has not loaded?" },
    { 36,"Write attempt while write protected" },
    { 37,"Tapes: read block accessed but not yet written. Disks: Validate key mismatch" },
    { 40,"Unrecoverable Data" },
    { 41,"Unrecoverable Data P1-P6 will contain the address of first bad block" },
    { 43,"End of File End encountered on file structured device." },
    { 44,"End of Volume attempted to access past end" },
    { 51,"Flexible disc or tape medium is wearing out" },
    { 52,"Latency induced bit because of retries" },
    { 55,"Device has automatically spared a block." },
    { 57,"Too many recoverable data error status messages queued since last request" },
    { 59,"Recoverable Data latency was introduced because of retries" },
    { -1,NULL }
};
 
int SS80_test_extended_status(uint8_t *p, int bit)
{
    uint8_t mask;
    int byte = bit >> 3;
    bit &= 7;
    mask = (0x80 >> bit);
    return((p[byte] & mask) ? 1 : 0);
}
 
 
void SS80_set_extended_status(uint8_t *p, int bit)
{
    uint8_t mask;
    int byte = bit >> 3;
    bit &= 7;
    mask = (0x80 >> bit);
    p[byte] |= mask;
}
 
 
void SS80_display_extended_status(uint8_t *p, char *message)
{
 
    int i,bit;
    int status = 0;
 
// See if ANY bits are set
    for(i=0;i<8;++i)
    {
        if(p[i])
            status = 1;
    }
// Display all of the messages
    if(status)
    {
        printf("%s:\n",message);
        for(i=0;faults[i].index != -1;++i)
        {
            bit = faults[i].index;
            if(SS80_test_extended_status(p,bit))
            {
                printf("    %d:%s\n", faults[i].index, faults[i].msg);
            }
        }
    }
}
 
 
 
int SS80_send_status( void )
{
    uint8_t tmp[20];
    uint16_t status;
 
#if SDEBUG
    if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
        printf("[SS80 Send Status]\n");
#endif
 
    Mem_Clear(tmp);
 
    tmp[0] = ((SS80s->volNO& 0x0f) << 4) | (SS80s->unitNO & 0x0f);
 
    tmp[1] = 0xff;
 
// Bit 6 Module addressing
// TODO unit support
    if(SS80s->Errors & ERR_UNIT)
        SS80_set_extended_status(tmp+2, 6);
 
// Bit 7 Address Bounds
    if(SS80s->Errors & ERR_SEEK)
        SS80_set_extended_status(tmp+2, 7);
 
// Bit 22 Unit fault
    if(SS80s->Errors & ERR_READ)
        SS80_set_extended_status(tmp+2, 22);
 
// Bit 22 Unit fault
    if(SS80s->Errors & ERR_WRITE)
        SS80_set_extended_status(tmp+2, 22);
 
 
// Bit 36 Write Protect
    if(SS80s->Errors & ERR_WP)
        tmp[6] = 0b00001000;
 
 
    if(!SS80s->Errors)
    {
/* tmp[10] = SS80s->AddressBlocks.B[5] MSB unused */
/* tmp[11] = SS80s->AddressBlocks.B[4] unused */
/* index 0 offset */
        V2B_MSB(tmp,10,6,SS80s->AddressBlocks);
    }
 
    if(SS80s->Errors)
        SS80s->qstat = 1;
 
    status = EOI_FLAG;
    if(gpib_write_str(tmp, sizeof(tmp), &status) != sizeof(tmp))
    {
        if(debuglevel & GPIB_ERR)
            printf("[SS80 Send Status FAILED]\n");
    }
 
    return ( status & ERROR_MASK );
}
 
 
 
int SS80_describe( void )
{
    uint16_t status;
 
    uint8_t *B;
    int size;
 
#if SDEBUG
    if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
        printf("[SS80 Describe]\n");
#endif
 
    status = 0;
 
    B = SS80ControllerPack(&size);
    if(gpib_write_str(B,size, &status) != size)
    {
        if(debuglevel & GPIB_ERR)
            printf("[SS80 Describe Controller FAILED]\n");
        return(status & ERROR_MASK);
    }
 
    status = 0;
 
    B = SS80UnitPack(&size);
    if(gpib_write_str(B,size, &status) != size)
    {
        if(debuglevel & GPIB_ERR)
            printf("[SS80 Describe Unit FAILED]\n");
        return(status & ERROR_MASK);
    }
 
    status = EOI_FLAG;
    B = SS80VolumePack(&size);
    if(gpib_write_str(B,size,&status) != size)
    {
        if(debuglevel & GPIB_ERR)
            printf("[SS80 Describe Volume FAILED]\n");
        return(status & ERROR_MASK);
    }
 
    return(0);
}
 
 
void SS80_Check_Unit(uint8_t unit)
{
    if(unit != 0 && unit != 15)
    {
        SS80s->Errors |= ERR_UNIT;
        if(debuglevel & GPIB_ERR)
            printf("[SS80 UNIT:%d invalid]\n", (int) unit);
    }
    else
    {
        SS80s->unitNO  = unit;
    }
}
 
 
void SS80_Check_Volume(uint8_t volume)
{
    if(volume != 0)
    {
        SS80s->Errors |= ERR_UNIT;
        if(debuglevel & GPIB_ERR)
            printf("[SS80 Volume:%d invalid]\n", (int) volume);
    }
    else
    {
        SS80s->volNO  = volume;
    }
}
 
 
 
int SS80_Command_State( void )
{
    int ch;                                       // Current OP Code
    uint16_t status;                              // Current status
    int len;                                      // Size of Data/Op Codes/Parameters read in bytes
    int ind;                                      // Buffer index
 
    gpib_disable_PPR(SS80p->HEADER.PPR);
 
    status = EOI_FLAG;
    len = gpib_read_str(gpib_iobuff, GPIB_IOBUFF_LEN, &status);
    if(status & ERROR_MASK)
    {
        if(debuglevel & GPIB_ERR)
            printf("[SS80 Command State GPIB Read ERROR]\n");
        return(status & ERROR_MASK);
    }
 
    if(!len)
        return(0);
 
    if( !(status & EOI_FLAG) )
    {
        if(debuglevel & GPIB_ERR)
            printf("[GPIB buffer OVERFLOW!]\n");
    }
 
    ind = 0;
    while(ind < len)
    {
        ch = gpib_iobuff[ind++];
 
        if(ch >= 0x20 && ch <= 0x2f)
        {
            SS80_Check_Unit(ch - 0x20);
// TODO unit support
 
#if SDEBUG
            if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
                printf("[SS80 Set Unit:(%d)]\n", SS80s->unitNO);
#endif
            continue;
        }
 
        if(ch >= 0x40 && ch <= 0x4f)
        {
            SS80_Check_Volume(ch - 0x40);
#if SDEBUG
            if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
                printf("[SS80 Set Volume: (%d)]\n", SS80s->volNO);
#endif
            continue;
        }
 
        if(ch == 0x00)
        {
            SS80s->estate = EXEC_LOCATE_AND_READ;
#if SDEBUG
            if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
                printf("[SS80 Locate and Read]\n");
#endif
            break;
        }
 
        if(ch == 0x02)
        {
            SS80s->estate = EXEC_LOCATE_AND_WRITE;
#if SDEBUG
            if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
                printf("[SS80 Locate and Write]\n");
#endif
            break;
        }
 
 
// Set address
        if (ch == 0x10)
        {
/* upper two MSB unused */
/* gpib_iobuff[ind+0] MSB unused */
/* gpib_iobuff[ind+1] MSB unused */
            SS80s->AddressBlocks = B2V_MSB(gpib_iobuff,ind,6);
            ind += 6;
#if SDEBUG
            if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
                printf("[SS80 Set Address:(%08lXH)]\n",
                    (long)SS80_Blocks_to_Bytes(SS80s->AddressBlocks));
#endif
            continue;
        }
 
// Set Length
        if(ch == 0x18)
        {
/* gpib_iobuff[ind+0] MSB */
            SS80s->Length = B2V_MSB(gpib_iobuff,ind,4);
            ind += 4;
#if SDEBUG
            if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
                printf("[SS80 Set Length:(%08lXH)]\n", (long)SS80s->Length);
#endif
            continue;
        }
 
// SS80 $S80 4-47
// NO OP
        if(ch == 0x34)
        {
#if SDEBUG
            if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
                printf("[SS80 NO-OP]\n");
#endif
            continue;
        }
// SS80 $S80 4-79
// Set RPS
        if (ch == 0x39)
        {
            ind += 2;
#if SDEBUG
            if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
                printf("[SS80 Set RPS NO-OP]\n");
#endif
            continue;
        }
 
// SS80 $S80 4-75
// Set Release
        if (ch == 0x3B)
        {
            ind++;
#if SDEBUG
            if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
                printf("[SS80 Set Release NO-OP]\n");
#endif
            continue;
        }
 
 
        if(ch == 0x48)
        {
            ind++;
#if SDEBUG
            if(debuglevel & (GPIB_TODO + GPIB_DEVICE_STATE_MESSAGES))
                printf("[SS80 Set Return Addressing - TODO]\n");
#endif
            continue;
        }
 
 
        if(ch == 0x04)
        {
#if SDEBUG
            if(debuglevel & (GPIB_TODO + GPIB_DEVICE_STATE_MESSAGES))
                printf("[SS80 Locate and Verify - TODO]\n");
#endif
            break;
        }
 
        if(ch == 0x0E)
        {
#if SDEBUG
            if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
                printf("[SS80 Release NO-OP]\n");
#endif
            break;
        }
        if(ch == 0x0F)
        {
#if SDEBUG
            if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
                printf("[SS80 Release Denied NO-OP]\n");
#endif
            break;
        }
 
 
        if(ch == 0x31)
        {
            ind += 2;
#if SDEBUG
            if(debuglevel & (GPIB_TODO + GPIB_DEVICE_STATE_MESSAGES))
                printf("[SS80 Validate Key - TODO]\n");
#endif
            break;
        }
 
        if(ch == 0x35)
        {
            SS80s->estate = EXEC_DESCRIBE;
#if SDEBUG
            if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
                printf("[SS80 Describe]\n");
#endif
            break;
        }
 
 
        if(ch == 0x37)
        {
            ind += 2;
#if SDEBUG
            if(debuglevel & (GPIB_TODO + GPIB_DEVICE_STATE_MESSAGES))
                printf("[SS80 Initialize Media TODO]\n");
#endif
            break;
        }
 
 
        if(ch == 0x3E)
        {
#if SDEBUG
            if(debuglevel & (GPIB_TODO + GPIB_DEVICE_STATE_MESSAGES))
            {
                printf("[SS80 Set Status Mask - TODO]\n");
                SS80_display_extended_status(gpib_iobuff+ind, "TODO Mask these Status Bits");
            }
#endif
            ind += 8;
            break;
        }
 
        if (ch == 0x4C)
        {
#if SDEBUG
            if(debuglevel & (GPIB_TODO + GPIB_DEVICE_STATE_MESSAGES))
                printf("[SS80 Door UnLock - TODO]\n");
#endif
            break;
        }
 
        if (ch == 0x4D)
        {
#if SDEBUG
            if(debuglevel & (GPIB_TODO + GPIB_DEVICE_STATE_MESSAGES))
                printf("[SS80 Door Lock - TODO]\n");
#endif
            break;
        }
 
        if(ch == 0x0D)
        {
            SS80s->estate = EXEC_SEND_STATUS;
#if SDEBUG
            if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
                printf("[SS80 Request Status]\n");
#endif
            break;
        }
 
 
        if(ch == 0x33)
        {
            ind += 3;
#if SDEBUG
            if(debuglevel & (GPIB_TODO + GPIB_DEVICE_STATE_MESSAGES))
                printf("[SS80 Initiate Diagnostic - TODO]\n");
#endif
            break;
        }
 
        if(debuglevel & GPIB_ERR)
            printf("[SS80 Invalid OP Code (%02XH)]\n", ch & 0xff);
 
        break;
    }
 
    if( ind != len)
    {
        if(debuglevel & GPIB_ERR)
            printf("[SS80 Execute Command, Error at (%d) of (%d) OP Codes]\n",
                ind, len);
    }
 
    gpib_enable_PPR(SS80p->HEADER.PPR);
 
    return(status & ERROR_MASK);
}
 
 
 
 
int SS80_Transparent_State( void )
{
 
    int ch;                                       // Current OP Code
    uint16_t status;                              // Current status
    int len;                                      // Size of Data/Op Codes/Parameters read in bytes
    int ind;                                      // Buffer index
 
    gpib_disable_PPR(SS80p->HEADER.PPR);
 
 
    status = EOI_FLAG;
    len = gpib_read_str(gpib_iobuff, GPIB_IOBUFF_LEN, &status);
    if(status & ERROR_MASK)
    {
        if(debuglevel & GPIB_ERR)
            printf("[GPIB Read ERROR]\n");
        return(status & ERROR_MASK);
    }
 
    if(!len)
        return(0);
 
    if( !(status & EOI_FLAG) )
    {
        if(debuglevel & GPIB_ERR)
            printf("[GPIB buffer OVERFLOW!]\n");
    }
 
    ind = 0;
 
    while(ind < len)
    {
        ch = gpib_iobuff[ind++];
        if(ch >= 0x20 && ch <= 0x2f)
        {
            SS80_Check_Unit(ch - 0x20);
            continue;
        }
 
        if(ch == 0x01)
        {
            ind++;
#if SDEBUG
            if(debuglevel & (GPIB_TODO + GPIB_DEVICE_STATE_MESSAGES))
                printf("[SS80 HP-IB Parity Checking - TODO]\n");
#endif
            gpib_enable_PPR(SS80p->HEADER.PPR);
            break;
        }
 
        if(ch == 0x02)
        {
            ind += 4;
#if SDEBUG
            if(debuglevel & (GPIB_TODO + GPIB_DEVICE_STATE_MESSAGES))
                printf("[SS80 Read Loopback - TODO]\n");
#endif
            break;
        }
 
        if(ch == 0x03)
        {
            ind += 4;
#if SDEBUG
            if(debuglevel & (GPIB_TODO + GPIB_DEVICE_STATE_MESSAGES))
                printf("[SS80 Write Loopback - TODO]\n");
#endif
            break;
        }
 
 
        if(ch == 0x08)                            // 0x08 OP Code
        {
#if SDEBUG
            if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
                printf("[SS80 Channel Independent Clear (%d)]\n", SS80s->unitNO);
#endif
            return(SS80_Channel_Independent_Clear( SS80s->unitNO ));
        }
 
 
        if(ch == 0x09)                            // 0x09 OP Code
        {
#if SDEBUG
            if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
                printf("[SS80 Cancel (%d)]\n", SS80s->unitNO);
#endif
            return(SS80_Cancel( ) );
 
            break;
        }
 
        if(debuglevel & GPIB_ERR)
            printf("[SS80 Invalid OP Code (%02XH)]\n", ch & 0xff);
        break;
    }
 
    if( ind != len)
    {
        if(debuglevel & GPIB_ERR)
            printf("[SS80 Transparent Command, Error at (%d) of (%d) OP Codes]\n",
                ind,len);
    }
 
    return(status & ERROR_MASK);
}
 
 
 
int SS80_cmd_seek( void )
{
    if ( (SS80s->AddressBlocks + SS80_Bytes_to_Blocks(SS80s->Length))
        > SS80p->VOLUME.MAX_BLOCK_NUMBER )
    {
        SS80s->qstat = 1;
        SS80s->Errors |= ERR_SEEK;
 
        if(debuglevel & GPIB_ERR)
            printf("[SS80 Seek OVERFLOW at %08lXH]\n",
                (long) SS80_Blocks_to_Bytes(SS80s->AddressBlocks));
        return(1);
    }
 
#if SDEBUG
    if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
        printf("[SS80 Seek:%08lXH]\n", (long)SS80_Blocks_to_Bytes(SS80s->AddressBlocks));
#endif
    return (0);
}
 
 
 
int SS80_Report( void )
{
    uint8_t tmp[1];
    uint16_t status;
 
    tmp[0] = SS80s->qstat;
 
    status = EOI_FLAG;
    if( gpib_write_str(tmp, sizeof(tmp), &status) != sizeof(tmp))
    {
        if(debuglevel & GPIB_ERR)
            printf("[SS80 qstat send FAILED]\n");
        return(status & ERROR_MASK);
    }
    else
    {
#if SDEBUG
        if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
            printf("[SS80 qstat %02X]\n", SS80s->qstat);
#endif
    }
    SS80s->qstat = 0;
    return ( 0 );
}
 
 
 
 
 
void Clear_Common(int u)
{
    if(u != SS80s->unitNO && u != 15)
        return;
 
    if(u == 15)
        SS80s->unitNO = 0;
    SS80s->volNO = 0;
    SS80s->AddressBlocks = 0;
    SS80s->Length = 0;
    SS80s->estate = EXEC_IDLE;
 
 
    SS80s->Errors = 0;                            // Status Mask
    SS80s->qstat = 0;                             // Clear qstat
}
 
 
 
int SS80_Channel_Independent_Clear( int u )
{
    Clear_Common( u );
    gpib_enable_PPR(SS80p->HEADER.PPR);
    return(0);
}
 
 
 
int SS80_Universal_Device_Clear(void)
{
    Clear_Common(15);
    gpib_enable_PPR(SS80p->HEADER.PPR);
    return(0);
}
 
 
 
int SS80_Selected_Device_Clear( int u )
{
#if SDEBUG
    if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
        printf("[SS80 SDC]\n");
#endif
    Clear_Common( u );
    gpib_enable_PPR(SS80p->HEADER.PPR);
    return(0);
}
 
 
 
int SS80_Amigo_Clear( void )
{
    uint8_t parity[1];
    uint16_t status;
 
    status = 0;
    if( gpib_read_str(parity, sizeof(parity), &status) != sizeof(parity))
    {
        if(debuglevel & GPIB_ERR)
            printf("[GPIB Read Error]\n");
        return(status & ERROR_MASK);
    }
    else
    {
#if SDEBUG
        if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
            printf("[Amigo Clear]\n");
#endif
    }
    Clear_Common(15);
    gpib_enable_PPR(SS80p->HEADER.PPR);
    return(0);
}
 
 
 
int SS80_Cancel( )
{
 
    SS80s->estate = EXEC_IDLE;
    gpib_enable_PPR(SS80p->HEADER.PPR);
    return(0);
}
 
 
 
int SS80_increment( void )
{
    SS80s->AddressBlocks += 1L;
#if SDEBUG
    if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
        printf("[SS80 Increment to (%lXH)]\n",
            (long) SS80_Blocks_to_Bytes(SS80s->AddressBlocks));
#endif
    return(0);
}
 
 
 
int SS80_error_return( void )
{
    uint8_t tmp[1];
    uint16_t status = EOI_FLAG;
 
    SS80s->qstat = 1;
    tmp[0] = SS80s->qstat;
 
    status = EOI_FLAG;
    if( gpib_write_str(tmp,sizeof(tmp), &status) != sizeof(tmp))
    {
        if(debuglevel & GPIB_ERR)
            printf("[GPIB Error Return - Write ERROR]\n");
        return(status & ERROR_MASK);
    }
    SS80s->qstat = 0;
    return(0);
}
 
 
int SS80_COMMANDS(uint8_t ch)
{
    if(SS80_is_MTA(talking) || SS80_is_MLA(listening))
    {
        if(ch == 0x65 )
        {
            if(SS80_is_MLA(listening))
            {
#if SDEBUG
                if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
                    printf("[SS80 Command State]\n");
#endif
                return ( SS80_Command_State() );
            }
            return(0);
        }
 
        if(ch == 0x6e )
        {
            if(SS80_is_MLA(listening)  || SS80_is_MTA(talking))
            {
                if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
                    printf("[SS00 Execute State]\n");
                return ( SS80_Execute_State() );
 
            }
            return(0);
        }
 
        if(ch == 0x70 )
        {
            if(SS80_is_MTA(talking) )
            {
#if SDEBUG
                if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
                    printf("[SS80 Report State]\n");
#endif
                return( SS80_Report() );
            }
 
            if(SS80_is_MLA(listening))
            {
#if SDEBUG
                if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
                    printf("[Amigo Clear]\n");
#endif
                gpib_disable_PPR(SS80p->HEADER.PPR);
                return( SS80_Amigo_Clear() );
            }
            return (0);
        }
        if(ch == 0x72 )
        {
            if(SS80_is_MLA(listening) )
            {
#if SDEBUG
                if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
                    printf("[SS80 Transparent]\n");
#endif
                return( SS80_Transparent_State() );
            }
        }
        if(debuglevel & GPIB_ERR)
            printf("[SS80 SC Unknown: %02XH, listen:%02XH, talk:%02XH]\n",
                0xff & ch, 0xff & listening, 0xff & talking);
        return(0);
    }
 
    if(debuglevel & GPIB_ERR)
        printf("[SS80 Unknown SC: %02XH, listen:%02XH, talk:%02XH]\n",
            0xff & ch, 0xff & listening, 0xff & talking);
    return(0);
}