amigo.c

Go to the documentation of this file.

 
#include "user_config.h"
 
#include "defines.h"
#include "gpib.h"
#include "gpib_hal.h"
#include "gpib_task.h"
#include "amigo.h"
#include "debug.h"
 
#ifdef AMIGO
 
 
 
 
extern uint8_t talking;
extern uint8_t listening;
 
enum AMIGO_states
{
    AMIGO_IDLE = 0,
    AMIGO_REQUEST_STATUS,
    AMIGO_REQUEST_STATUS_UNBUFFERED,
    AMIGO_REQUEST_STATUS_BUFFERED,
    AMIGO_REQUEST_LOGICAL_ADDRESS,
    AMIGO_COLD_LOAD_READ,
    AMIGO_READ_UNBUFFERED,
    AMIGO_READ_BUFFERED,
    AMIGO_WRITE_UNBUFFERED,
    AMIGO_WRITE_BUFFERED,
    AMIGO_INITIALIZE,
};
 
 
void amigo_init()
{
    int i;
    for(i=MAX_DEVICES-1;i>=0;--i)
    {
        if(Devices[i].TYPE == AMIGO_TYPE)
        {
            set_active_device(i);
            AMIGOs->state = AMIGO_IDLE;
 
            memset(AMIGOs->status,0,sizeof(AMIGOs->status));
            memset(AMIGOs->logical_address,0,sizeof(AMIGOs->logical_address));
 
            AMIGOs->unitNO = 0;
 
            AMIGOs->sector = 0;
            AMIGOs->head = 0;
            AMIGOs->cyl = 0;
 
            AMIGOs->dsj = 2;
            AMIGOs->Errors = 0;
 
            gpib_disable_PPR(AMIGOp->HEADER.PPR);
        }
    }
}
 
 
 
int amigo_request_logical_address()
{
 
    AMIGOs->logical_address[0] = 0xff & (AMIGOs->cyl >> 8);
//LSB
    AMIGOs->logical_address[1] = 0xff & (AMIGOs->cyl);
    AMIGOs->logical_address[2] = 0xff & (AMIGOs->head);
    AMIGOs->logical_address[3] = 0xff & (AMIGOs->sector);
    return(0);
}
 
 
 
int amigo_request_status()
{
#if SDEBUG
    if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
        printf("[AMIGO request status]\n");
#endif
    AMIGOs->status[0] = 0x00;                     // Status 1
    AMIGOs->status[1] = AMIGOs->unitNO;           // Unit
    AMIGOs->status[2] = 0x0d;                     // Status 2 (0110 = hp format) << 1, 1=HP9121
    AMIGOs->status[3] = 0x00;                     //
 
    if(mmc_wp_status())
    {
        AMIGOs->status[3] |= 0x40;                // Write protect 0x40, reserved = 0x20
        AMIGOs->status[3] |= 0x20;                // reserved = 0x20 ???
    }
 
    if(AMIGOs->dsj == 2)
    {
        AMIGOs->status[0] = 0b00010011;           // S1 error power on
        AMIGOs->status[3] |= 0x08;                // F bit, power up
    }
    else if(AMIGOs->Errors || AMIGOs->dsj == 1)
    {
//FIXME added invalid unit error
        if(AMIGOs->Errors & ERR_UNIT)
            AMIGOs->status[0] = 0b00010011;       // Unit Error
        else if(AMIGOs->Errors & ERR_GPIB)
            AMIGOs->status[0] = 0b00001010;       // S1 error I/O error
        else if(AMIGOs->Errors & ERR_DISK)
            AMIGOs->status[3] |= 0x03;            // Do disk in drive
        else if(AMIGOs->Errors & ERR_WRITE)
            AMIGOs->status[0] = 0b00010011;       // S1 error write error
        else if(AMIGOs->Errors & ERR_SEEK)
            AMIGOs->status[3] |= 0x04;            // Seek
 
        AMIGOs->status[3] |= 0x10;                // E bit hardware failure
        AMIGOs->status[2] |= 0x80;                // Bit 15
    }
 
    gpib_enable_PPR(AMIGOp->HEADER.PPR);
    return(0);
}
 
 
 
int amigo_send_logical_address()
{
    uint16_t status;
    UINT len;
 
#if SDEBUG
    if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
        printf("[AMIGO send logical address]\n");
#endif
    status = EOI_FLAG;
    len = gpib_write_str(AMIGOs->logical_address,4,&status);
 
    if(status & ERROR_MASK || len != 4)
    {
        AMIGOs->Errors |= ERR_GPIB;
        AMIGOs->dsj = 1;
        if(debuglevel & GPIB_ERR)
            printf("[AMIGO GPIB write error]\n");
    }
    gpib_enable_PPR(AMIGOp->HEADER.PPR);
    return(status & ERROR_MASK);
}
 
 
 
int amigo_send_status()
{
    uint16_t status;
    UINT len;
 
#if SDEBUG
    if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
        printf("[AMIGO send status]\n");
#endif
    status = EOI_FLAG;
    len = gpib_write_str(AMIGOs->status,4,&status);
    if(status & ERROR_MASK || len != 4)
    {
        AMIGOs->Errors |= ERR_GPIB;
        AMIGOs->dsj = 1;
        if(debuglevel & GPIB_ERR)
            printf("[AMIGO GPIB write error]\n");
    }
    else
    {
        AMIGOs->Errors = 0;
        AMIGOs->dsj = 0;
    }
    gpib_enable_PPR(AMIGOp->HEADER.PPR);
    return(status & ERROR_MASK);
}
 
 
 
static DWORD amigo_chs_to_logical(AMIGOStateType *p, char *msg)
{
    DWORD pos;
    pos =  (long) ( AMIGOp->GEOMETRY.SECTORS_PER_TRACK * p->head);
    pos += (long) ( (AMIGOp->GEOMETRY.SECTORS_PER_TRACK * AMIGOp->GEOMETRY.HEADS) * p->cyl);
    pos += (long) p->sector;
    pos *= (long) AMIGOp->GEOMETRY.BYTES_PER_SECTOR;
 
#if SDEBUG
    if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
        printf("[AMIGO %s, P:%08lxH, U:%d C:%d H:%d S:%d]\n",
            msg, pos, AMIGOs->unitNO, p->cyl, p->head, p->sector);
#endif
    return(pos);
}
 
 
 
static int amigo_overflow_check(AMIGOStateType *p, char *msg)
{
    int stat = 0;
    while(p->sector >= AMIGOp->GEOMETRY.SECTORS_PER_TRACK)
    {
        p->sector = 0;
        p->head++;
        while (p->head >= AMIGOp->GEOMETRY.HEADS)
        {
            p->head = 0;
            p->cyl++;
            if (p->cyl >= AMIGOp->GEOMETRY.CYLINDERS)
            {
                stat = 1;
                if(debuglevel & GPIB_ERR && msg != NULL)
                    printf("[AMIGO %s pos OVERFLOW]\n", msg);
            }
        }
    }
    return(stat);
}
 
 
 
int amigo_increment(char *msg)
{
    int stat = 0;
    AMIGOStateType tmp = *AMIGOs;
 
    ++tmp.sector;
 
    stat = amigo_overflow_check((AMIGOStateType *) &tmp, msg);
    if(!stat)
    {
        *AMIGOs = tmp;
    }
    return(stat);
}
 
 
 
int amigo_seek( AMIGOStateType *p)
{
    int stat = 0;
 
    stat = amigo_overflow_check(p, "Seek");
    if(stat)
    {
        AMIGOs->dsj = 1;
        AMIGOs->Errors |= ERR_SEEK;
    }
    else
    {
        AMIGOs->sector = p->sector;
        AMIGOs->head = p->head;
        AMIGOs->cyl = p->cyl;
    }
 
    gpib_enable_PPR(AMIGOp->HEADER.PPR);
    return(stat);
}
 
 
 
int amigo_verify(uint16_t sectors)
{
    int len;
    int stat = 0;
    DWORD pos;
 
    pos = amigo_chs_to_logical(AMIGOs, "Verify Start");
 
#if SDEBUG
    if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
        printf("[AMIGO verify P:%08lXH, sectors:%04XH]\n", pos, sectors);
#endif
 
    while(sectors--)
    {
        pos = amigo_chs_to_logical(AMIGOs, "Verfify");
 
#if SDEBUG
        if(debuglevel & GPIB_DISK_IO_TIMING)
            gpib_timer_elapsed_begin();
#endif
 
        // dbf_open_read sets error conditions like ERROR_READ, etc
        len = dbf_open_read(AMIGOp->HEADER.NAME, pos, gpib_iobuff, AMIGOp->GEOMETRY.BYTES_PER_SECTOR, &AMIGOs->Errors);
 
#if SDEBUG
        if(debuglevel & GPIB_DISK_IO_TIMING)
            gpib_timer_elapsed_end("disk READ ");
#endif
        if(AMIGOs->Errors || len != AMIGOp->GEOMETRY.BYTES_PER_SECTOR )
        {
            AMIGOs->dsj = 1;
            stat = 1;
            break;
        }
        if(amigo_increment("Verify"))             // address overflow
        {
            stat = 1;
            break;
        }
    }
    gpib_enable_PPR(AMIGOp->HEADER.PPR);
    return(stat);
}
 
 
int amigo_format(uint8_t db)
{
 
    DWORD pos;
    int len;
    int stat = 0;
 
    AMIGOs->sector = 0;
    AMIGOs->head = 0;
    AMIGOs->cyl = 0;
 
    memset((void *) gpib_iobuff, db, AMIGOp->GEOMETRY.BYTES_PER_SECTOR);
 
#if SDEBUG
    if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
        printf("[AMIGO format]\n");
    if(debuglevel & GPIB_DISK_IO_TIMING)
        gpib_timer_elapsed_begin();
#endif
    while( 1 )
    {
        pos = amigo_chs_to_logical(AMIGOs, "Format");
 
        len = dbf_open_write(AMIGOp->HEADER.NAME,
            pos, gpib_iobuff,AMIGOp->GEOMETRY.BYTES_PER_SECTOR, &AMIGOs->Errors);
 
        if(AMIGOs->Errors || len != AMIGOp->GEOMETRY.BYTES_PER_SECTOR)
        {
            AMIGOs->Errors |= ERR_WRITE;
            AMIGOs->dsj = 1;
            stat = 1;
            break;
        }
 
        if( amigo_increment(NULL) )
        {
// reset sector,head,cyl
            AMIGOs->sector = 0;
            AMIGOs->head = 0;
            AMIGOs->cyl = 0;
            AMIGOs->dsj = 0;
            stat = 0;
            break;
        }
 
    }
#if SDEBUG
    if(debuglevel & GPIB_DISK_IO_TIMING)
        gpib_timer_elapsed_end("Format");
    if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
        printf("[AMIGO Format Done]\n");
#endif
    gpib_enable_PPR(AMIGOp->HEADER.PPR);
    return(stat);
}
 
 
#if 0
 
int amigo_buffered_read()
{
    uint16_t status;
    int len;
    DWORD pos;
 
//READ SECTOR
    pos = amigo_chs_to_logical(AMIGOs, "Buffered Read");
#if SDEBUG
    if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
        printf("AMIGOs->state:%d\n", AMIGOs->state);
    if(debuglevel & GPIB_DISK_IO_TIMING)
        gpib_timer_elapsed_begin();
#endif
 
    len = dbf_open_read(AMIGOp->HEADER.NAME, pos, gpib_iobuff, AMIGOp->GEOMETRY.BYTES_PER_SECTOR, &AMIGOs->Errors);
 
#if SDEBUG
    if(debuglevel & GPIB_DISK_IO_TIMING)
        gpib_timer_elapsed_end("disk READ ");
#endif
    if(AMIGOs->Errors)
    {
        // Any AMIGOs->Errors errors were set in the dbf_pen_read() call
        AMIGOs->dsj = 1;
        if(debuglevel & GPIB_ERR)
            printf("[AMIGO GPIB disk read error]\n");
        gpib_enable_PPR(AMIGOp->HEADER.PPR);
        return(0);
    }
 
#if SDEBUG
    if(debuglevel & GPIB_RW_STR_TIMING)
        gpib_timer_elapsed_begin();
#endif
 
// WRITE DATA
    status = EOI_FLAG;
    len = gpib_write_str(gpib_iobuff, AMIGOp->GEOMETRY.BYTES_PER_SECTOR, &status);
#if SDEBUG
    if(debuglevel & GPIB_RW_STR_TIMING)
        gpib_timer_elapsed_end("GPIB write");
#endif
    if(status & ERROR_MASK || len != AMIGOp->GEOMETRY.BYTES_PER_SECTOR)
    {
        AMIGOs->dsj = 1;
        AMIGOs->Errors |= ERR_GPIB;
        if(debuglevel & GPIB_ERR)
            printf("[AMIGO GPIB bus write error]\n");
        gpib_enable_PPR(AMIGOp->HEADER.PPR);
        return(status & ERROR_MASK);
    }
 
    if( amigo_increment("Buffered Read") )        //overflow
    {
        AMIGOs->dsj = 1;
        AMIGOs->Errors |= ERR_SEEK;
    }
 
    gpib_enable_PPR(AMIGOp->HEADER.PPR);
    return(0);
}
#endif
 
// ====================================================
 
int amigo_buffered_read_command()
{
    int len;
    DWORD pos;
 
//READ SECTOR
    pos = amigo_chs_to_logical(AMIGOs, "Buffered Read");
#if SDEBUG
    if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
        printf("AMIGOs->state:%d\n", AMIGOs->state);
    if(debuglevel & GPIB_DISK_IO_TIMING)
        gpib_timer_elapsed_begin();
#endif
 
    len = dbf_open_read(AMIGOp->HEADER.NAME, pos, gpib_iobuff, AMIGOp->GEOMETRY.BYTES_PER_SECTOR, &AMIGOs->Errors);
 
#if SDEBUG
    if(debuglevel & GPIB_DISK_IO_TIMING)
        gpib_timer_elapsed_end("disk READ ");
#endif
 
    if(AMIGOs->Errors || len != AMIGOp->GEOMETRY.BYTES_PER_SECTOR)
    {
        AMIGOs->dsj = 1;
        gpib_enable_PPR(AMIGOp->HEADER.PPR);
        return(0);
    }
 
    if( amigo_increment("Buffered Read") )        //overflow
    {
        AMIGOs->dsj = 1;
        AMIGOs->Errors |= ERR_SEEK;
    }
 
    gpib_enable_PPR(AMIGOp->HEADER.PPR);
    return(0);
}
 
 
int amigo_buffered_read_execute()
{
    uint16_t status;
    int len;
 
#if SDEBUG
    if(debuglevel & GPIB_RW_STR_TIMING)
        gpib_timer_elapsed_begin();
#endif
 
// WRITE DATA
    status = EOI_FLAG;
    len = gpib_write_str(gpib_iobuff, AMIGOp->GEOMETRY.BYTES_PER_SECTOR, &status);
 
#if SDEBUG
    if(debuglevel & GPIB_RW_STR_TIMING)
        gpib_timer_elapsed_end("GPIB write");
#endif
 
    if(status & ERROR_MASK || len != AMIGOp->GEOMETRY.BYTES_PER_SECTOR)
    {
        AMIGOs->dsj = 1;
        AMIGOs->Errors |= ERR_GPIB;
        if(debuglevel & GPIB_ERR)
            printf("[AMIGO GPIB write error]\n");
    }
 
    gpib_enable_PPR(AMIGOp->HEADER.PPR);
    return(status);
}
 
 
 
 
int amigo_buffered_write()
{
    uint16_t status;
    int len;
 
    DWORD pos;
 
    pos = amigo_chs_to_logical(AMIGOs, "Buffered Write");
 
#if SDEBUG
    if(debuglevel & GPIB_RW_STR_TIMING)
        gpib_timer_elapsed_begin();
#endif
    status = 0;
    len = gpib_read_str(gpib_iobuff, AMIGOp->GEOMETRY.BYTES_PER_SECTOR, &status);
 
 
#if SDEBUG
    if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
        printf("AMIGOs->state:%d\n", AMIGOs->state);
    if(debuglevel & GPIB_RW_STR_TIMING)
        gpib_timer_elapsed_end("GPIB read");
#endif
 
    if(status & ERROR_MASK || len != AMIGOp->GEOMETRY.BYTES_PER_SECTOR)
    {
        AMIGOs->dsj = 1;
        AMIGOs->Errors |= ERR_GPIB;
        if(debuglevel & GPIB_ERR)
            printf("[AMIGO Write GPIB read error]\n");
        gpib_enable_PPR(AMIGOp->HEADER.PPR);
        return(status & ERROR_MASK);
    }
 
#if SDEBUG
    if(debuglevel & GPIB_DISK_IO_TIMING)
        gpib_timer_elapsed_begin();
#endif
 
    len = dbf_open_write(AMIGOp->HEADER.NAME, pos, gpib_iobuff, AMIGOp->GEOMETRY.BYTES_PER_SECTOR, &AMIGOs->Errors);
 
#if SDEBUG
    if(debuglevel & GPIB_DISK_IO_TIMING)
        gpib_timer_elapsed_end("disk WRITE");
#endif
 
    if(AMIGOs->Errors)
    {
        AMIGOs->dsj = 1;
        if(debuglevel & GPIB_ERR)
            printf("[AMIGO Write disk write error]\n");
        gpib_enable_PPR(AMIGOp->HEADER.PPR);
        return(0);
    }
 
    if( amigo_increment("Buffered Write") )       //overflow
    {
        AMIGOs->dsj = 1;
        AMIGOs->Errors |= ERR_SEEK;
    }
 
    gpib_enable_PPR(AMIGOp->HEADER.PPR);
 
    return(status & ERROR_MASK);
}
 
 
 
int amigo_cmd_dsj()
{
    uint8_t tmp[1];
    uint16_t status;
    int len;
 
    tmp[0] = AMIGOs->dsj;
 
    status = EOI_FLAG;
    len = gpib_write_str(tmp, sizeof(tmp), &status);
    if(status & ERROR_MASK || len != sizeof(tmp) )
    {
        AMIGOs->dsj = 1;
        AMIGOs->Errors |= ERR_GPIB;
        if(debuglevel & GPIB_ERR)
            printf("[AIMGO: DSJ send failed]\n");
        return(status & ERROR_MASK);
    }
    else
    {
#if SDEBUG
        if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
            printf("[DSJ %02XH]\n", AMIGOs->dsj);
#endif
    }
    AMIGOs->dsj = 0;
    AMIGOs->Errors = 0;
    return ( 0 );
}
 
 
 
int amigo_cmd_wakeup()
{
    uint8_t tmp[1];
    uint16_t status;
    UINT len;
 
#if SDEBUG
    if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
        printf("[AMIGO Wakeup]\n");
#endif
    tmp[0] = AMIGOs->dsj;
    len = gpib_write_str(tmp, 1, &status);
    if(status & ERROR_MASK || len != 1)
    {
        AMIGOs->dsj = 1;
        AMIGOs->Errors |= ERR_GPIB;
        if(debuglevel & GPIB_ERR)
            printf("[AMIGO GPIB write error]\n");
    }
    gpib_enable_PPR(AMIGOp->HEADER.PPR);
    AMIGOs->dsj = 0;
    return(status & ERROR_MASK);
}
 
 
 
int amigo_cmd_clear()
{
#if SDEBUG
    if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
        printf("[AMIGO Clear]\n");
#endif
    AMIGOs->sector = 0;
    AMIGOs->head = 0;
    AMIGOs->cyl = 0;
    AMIGOs->dsj = 0;
    AMIGOs->Errors =0;
 
    gpib_enable_PPR(AMIGOp->HEADER.PPR);
    return(0);
}
 
 
 
int amigo_todo_op(uint8_t secondary, uint8_t opcode, int len)
{
    if(AMIGO_is_MLA(listening))
        printf("[L   Amigo TODO secondary: %02XH, state:%02XH, opcode:%02XH, len:%3d, listening:%02XH, talking:%02XH]\n",
            secondary, AMIGOs->state, opcode, len, listening, talking);
    else if(AMIGO_is_MTA(talking))
        printf("[T   Amigo TODO secondary: %02XH, state:%02XH, opcode:%02XH, len:%3d, listening:%02XH, talking:%02XH]\n",
                secondary, AMIGOs->state, opcode, len, listening, talking);
    else if(talking == UNT)
        printf("[UNT Amigo TODO secondary: %02XH, state:%02XH, opcode:%02XH, len:%3d, listening:%02XH, talking:%02XH]\n",
                secondary, AMIGOs->state, opcode, len, listening, talking);
    else
        printf("[U Amigo TODO secondary: %02XH, state:%02XH, opcode:%02XH, len:%3d, listening:%02XH, talking:%02XH]\n",
            secondary, AMIGOs->state, opcode, len, listening, talking);
    gpib_enable_PPR(AMIGOp->HEADER.PPR);
    return(0);
}
 
 
 
int amigo_todo(uint8_t secondary)
{
    if(AMIGO_is_MLA(listening))
        printf("[L   Amigo TODO secondary: %02XH, state:%02XH, listening:%02XH, talking:%02XH]\n",
            secondary,AMIGOs->state,listening,talking);
    else if(AMIGO_is_MTA(talking))
        printf("[T   Amigo TODO secondary: %02XH, state:%02XH, listening:%02XH, talking:%02XH]\n",
                secondary,AMIGOs->state,listening,talking);
    else if(talking == UNT)
        printf("[UNT Amigo TODO secondary: %02XH, state:%02XH, listening:%02XH, talking:%02XH]\n",
                secondary,AMIGOs->state,listening,talking);
    else
        printf("[E   Amigo ERROR secondary: %02XH, state:%02XH, listening:%02XH, talking:%02XH]\n",
            secondary,AMIGOs->state,listening,talking);
    gpib_enable_PPR(AMIGOp->HEADER.PPR);
    return(0);
}
 
 
void amigo_check_unit(uint8_t unit)
{
    if(unit != 15)
        AMIGOs->unitNO = unit;
    if(AMIGOs->unitNO != 0)
        AMIGOs->Errors |= ERR_UNIT;
}
 
 
 
int Amigo_Command( int secondary )
{
    uint8_t op;                                   // Current OP Code
    uint8_t *ptr;
    uint16_t status;                              // Current status
    UINT len;                                     // Size of Data/Op Codes/Parameters read in bytes
 
#if SDEBUG
    if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
        printf("[AMIGO Command(%02XH): listen:%02XH, talk:%02XH]\n",
            secondary, listening, talking);
#endif
 
    if (secondary == 0x7e && AMIGO_is_MTA(talking))
    {
        gpib_disable_PPR(AMIGOp->HEADER.PPR);
        status = EOI_FLAG;
        len = gpib_write_str(gpib_iobuff, GPIB_IOBUFF_LEN, &status);
        gpib_enable_PPR(AMIGOp->HEADER.PPR);
        if(status & ERROR_MASK)
        {
            AMIGOs->dsj = 1;
            AMIGOs->Errors |= ERR_GPIB;
            if(debuglevel & GPIB_ERR)
                printf("[AMIGO_Command:GPIB write error]\n");
        }
        return(status & ERROR_MASK);
    }
 
    if (secondary == 0x7f && AMIGO_is_MLA(listening))
    {
        gpib_disable_PPR(AMIGOp->HEADER.PPR);
#if SDEBUG
        if(debuglevel & GPIB_RW_STR_TIMING)
            gpib_timer_elapsed_begin();
#endif
        status = EOI_FLAG;
        len = gpib_read_str(gpib_iobuff, GPIB_IOBUFF_LEN, &status);
#if SDEBUG
        if(debuglevel & GPIB_RW_STR_TIMING)
            gpib_timer_elapsed_end("GPIB read");
#endif
        gpib_enable_PPR(AMIGOp->HEADER.PPR);
        if(status & ERROR_MASK)
        {
            AMIGOs->dsj = 1;
            AMIGOs->Errors |= ERR_GPIB;
            if(debuglevel & GPIB_ERR)
                printf("[AMIGO Command:GPIB read error]\n");
        }
        return(status & ERROR_MASK);
    }
 
    if( !AMIGO_is_MLA(listening) || AMIGO_is_MTA(talking))
        return(0);
 
    gpib_disable_PPR(AMIGOp->HEADER.PPR);
 
 
    status = EOI_FLAG;
    len = gpib_read_str(gpib_iobuff, GPIB_IOBUFF_LEN, &status);
    if(status & ERROR_MASK)
    {
        AMIGOs->dsj = 1;
        AMIGOs->Errors |= ERR_GPIB;
        if(debuglevel & GPIB_ERR)
            printf("[AMIGO Command:GPIB read error]\n");
        return(status & ERROR_MASK);
    }
#if SDEBUG
    if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
        printf("[AMIGO Command(%02XH): GPIB read bytes:%02XH]\n",
            secondary, len);
#endif
    if(!len)
    {
        AMIGOs->dsj = 1;
        AMIGOs->Errors |= ERR_GPIB;
        return(status & ERROR_MASK);
    }
 
    ptr = gpib_iobuff;
    op = *ptr++;
 
    if (secondary == 0x68)
    {
        if(op == 0x00 && len == 2)
        {
 
            AMIGOStateType tmp;
#if SDEBUG
            if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
                printf("[AMIGO Cold Load Read Command]\n");
#endif
            AMIGOs->unitNO = 0;
            AMIGOs->dsj = 0;
            AMIGOs->Errors = 0;
            tmp.cyl = 0;
            tmp.head = ( (0xff & *ptr) >> 6) & 0x03;
            tmp.sector = 0x3f & *ptr;
            ++ptr;
//update to real address on sucess
            amigo_seek((AMIGOStateType *) &tmp);
            AMIGOs->state = AMIGO_COLD_LOAD_READ;
            gpib_enable_PPR(AMIGOp->HEADER.PPR);
            return(status & ERROR_MASK);
        }
        else if(op == 0x02 && len == 5)
        {
 
            AMIGOStateType tmp;
#if SDEBUG
            if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
                printf("[AMIGO Seek len=5]\n");
#endif
            amigo_check_unit(0xff & *ptr++);
 
            tmp.cyl = 0xff & *ptr++;
            tmp.head = 0xff & *ptr++;
            tmp.sector = 0xff & *ptr++;
//update to real address on sucess
            amigo_seek((AMIGOStateType *)&tmp);
            gpib_enable_PPR(AMIGOp->HEADER.PPR);
            return(status & ERROR_MASK);
        }
        else if(op == 0x02 && len == 6)
        {
 
            AMIGOStateType tmp;
#if SDEBUG
            if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
                printf("[AMIGO Seek len=6]\n");
#endif
            amigo_check_unit(0xff & *ptr++);
            tmp.cyl = (0xff & *ptr++) << 8;       // MSB
            tmp.cyl |= (0xff & *ptr++);           // LSB
            tmp.head = 0xff & *ptr++;
            tmp.sector = 0xff & *ptr++;
//update to real address on sucess
            amigo_seek((AMIGOStateType *)&tmp);
            gpib_enable_PPR(AMIGOp->HEADER.PPR);
            return(status & ERROR_MASK);
        }
        else if(op == 0x03 && len == 2)
        {
#if SDEBUG
            if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
                printf("[AMIGO Request Status Buffered Command]\n");
#endif
            amigo_check_unit(0xff & *ptr++);
            amigo_request_status();
            AMIGOs->state = AMIGO_REQUEST_STATUS_BUFFERED;
            return(status & ERROR_MASK);
        }
        else if(op == 0x05 && len == 2)
        {
#if SDEBUG
            if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
                printf("[AMIGO Read Unbuffered Command]\n");
#endif
            amigo_check_unit(0xff & *ptr++);
            AMIGOs->state = AMIGO_READ_UNBUFFERED;
            
#if 0
            gpib_enable_PPR(AMIGOp->HEADER.PPR);
            return(status & ERROR_MASK);
#else
            return( amigo_buffered_read_command() );
#endif
        }
        else if(op == 0x07 && len == 4)
        {
            uint16_t sectors;
#if SDEBUG
            if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
                printf("[AMIGO Verify]\n");
#endif
            amigo_check_unit(0xff & *ptr++);
            sectors = (0xff & *ptr++) << 8;
            sectors |= (0xff & *ptr++);
            return ( amigo_verify( sectors) );
        }
        else if(op == 0x08 && len == 2)
        {
#if SDEBUG
            if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
                printf("[AMIGO Write Unbuffered Command]\n");
#endif
            amigo_check_unit(0xff & *ptr++);
            AMIGOs->state = AMIGO_WRITE_UNBUFFERED;
            gpib_enable_PPR(AMIGOp->HEADER.PPR);
            return(status & ERROR_MASK);
        }
        else if((op == 0x0B || op == 0x2b) && len == 2)
        {
#if SDEBUG
            if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
                printf("[AMIGO Initialize Command]\n");
#endif
            amigo_check_unit(0xff & *ptr++);
            AMIGOs->state = AMIGO_INITIALIZE;
            gpib_enable_PPR(AMIGOp->HEADER.PPR);
            return(status & ERROR_MASK);
        }
        else if(op == 0x14 && len == 2)
        {
#if SDEBUG
            if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
                printf("[AMIGO Request Logical Address Command]\n");
#endif
            amigo_request_logical_address();
            AMIGOs->state = AMIGO_REQUEST_LOGICAL_ADDRESS;
            gpib_enable_PPR(AMIGOp->HEADER.PPR);
            return(status & ERROR_MASK);
        }
    }
    else if (secondary == 0x69)
    {
        if(op == 0x08 && len == 2)
        {
#if SDEBUG
            if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
                printf("[AMIGO Write Buffered Command]\n");
#endif
            amigo_check_unit(0xff & *ptr++);
            AMIGOs->state = AMIGO_WRITE_BUFFERED;
            gpib_enable_PPR(AMIGOp->HEADER.PPR);
            return(status & ERROR_MASK);
        }
    }
    else if (secondary == 0x6A)
    {
        if(op == 0x03 && len == 2)
        {
#if SDEBUG
            if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
                printf("[AMIGO Request Status Unbuffered Command]\n");
#endif
            amigo_check_unit(0xff & *ptr++);
            AMIGOs->state = AMIGO_REQUEST_STATUS_UNBUFFERED;
            amigo_request_status();
            return(status & ERROR_MASK);
        }
        if(op == 0x05 && len == 2)
        {
#if SDEBUG
            if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
                printf("[AMIGO Read Buffered Command]\n");
#endif
            amigo_check_unit(0xff & *ptr++);
            AMIGOs->state = AMIGO_READ_BUFFERED;
 
#if 0
            gpib_enable_PPR(AMIGOp->HEADER.PPR);
            return(status & ERROR_MASK);
#else
            return( amigo_buffered_read_command() );
#endif
        }
    }
    else if (secondary == 0x6C)
    {
        if(op == 0x18 && len == 5)
        {
 
            uint8_t db;
#if SDEBUG
            if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
                printf("[AMIGO Format]\n");
#endif
            amigo_check_unit(0xff & *ptr++);
            ++ptr;                                // override not used
            ++ptr;                                // interleave not used
            db = 0xff & *ptr++;
            amigo_format(db);
            return(status & ERROR_MASK);
        }
    }
    else if (secondary == 0x70)                   // HP-300 Clear
    {
        ++ptr;                                    // Dummy byte
        return(status & ERROR_MASK);
    }
    return ( amigo_todo_op(secondary, op, len) );
}
 
 
 
int Amigo_Execute( int secondary )
{
#if SDEBUG
    if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
        printf("[AMIGO Execute(%02XH): listen:%02XH, talk:%02XH]\n",
            secondary, listening, talking);
#endif
 
    if(talking == UNT)
        return(0);
 
    if(!AMIGO_is_MTA(talking) && !AMIGO_is_MLA(listening))
        return(0);
 
    if(secondary != 0x60 && secondary != 0x68)
        return(0);
 
    gpib_disable_PPR(AMIGOp->HEADER.PPR);
 
    if(secondary == 0x60)
    {
        switch(AMIGOs->state)
        {
            case AMIGO_IDLE:
                return(0);
            case AMIGO_COLD_LOAD_READ:
#if SDEBUG
                if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
                    printf("[AMIGO Execute Cold Load Read]\n");
#endif
                return ( amigo_buffered_read_execute() );
            case AMIGO_READ_UNBUFFERED:
#if SDEBUG
                if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
                    printf("[AMIGO Execute Read Unbuffered]\n");
#endif
                return ( amigo_buffered_read_execute() );
            case AMIGO_READ_BUFFERED:
#if SDEBUG
                if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
                    printf("[AMIGO Execute Read Buffered]\n");
#endif
                return ( amigo_buffered_read_execute() );
            case AMIGO_WRITE_UNBUFFERED:
#if SDEBUG
                if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
                    printf("[AMIGO Execute Write Unbuffered]\n");
#endif
                return ( amigo_buffered_write() );
            case AMIGO_INITIALIZE:
#if SDEBUG
                if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
                    printf("[AMIGO Execute Initialize]\n");
#endif
                return ( amigo_buffered_write() );
            case AMIGO_WRITE_BUFFERED:
#if SDEBUG
                if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
                    printf("[AMIGO Execute Write Buffered]\n");
#endif
                return ( amigo_buffered_write() );
            default:
                return ( amigo_todo(secondary) );
        }
        AMIGOs->state = AMIGO_IDLE;
    }
    if(secondary == 0x68)
    {
        switch(AMIGOs->state)
        {
            case AMIGO_IDLE:
                return(0);
            case AMIGO_REQUEST_STATUS_BUFFERED:
#if SDEBUG
                if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
                    printf("[AMIGO Execute Request Status Buffered]\n");
#endif
                return ( amigo_send_status() );
            case AMIGO_REQUEST_STATUS_UNBUFFERED:
#if SDEBUG
                if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
                    printf("[AMIGO Exicute Request Status Unbuffered]\n");
#endif
                return ( amigo_send_status() );
            case AMIGO_REQUEST_LOGICAL_ADDRESS:
#if SDEBUG
                if(debuglevel & GPIB_DEVICE_STATE_MESSAGES)
                    printf("[AMIGO Execute Request Logical Address]\n");
#endif
                return ( amigo_send_logical_address() );
            default:
                return ( amigo_todo(secondary) );
        }
        AMIGOs->state = AMIGO_IDLE;
    }
    return(0);
}
 
 
 
int AMIGO_COMMANDS(uint8_t ch)
{
 
    if(AMIGO_is_MTA(talking) || AMIGO_is_MLA(listening))
    {
 
        if(talking == UNT && AMIGO_is_MLA(listening))
        {
// printf("AMIGO COMMANDS %02XH NO TALK ADDRESS!\n", ch);
        }
        if(listening == 0 && AMIGO_is_MTA(talking))
        {
// printf("AMIGO COMMANDS %02XH NO LISTEN ADDRESS!\n", ch);
        }
 
        if(ch == 0x60 && (AMIGO_is_MTA(talking) || AMIGO_is_MLA(listening)) )
        {
            return (Amigo_Execute(ch) );
        }
 
        if(ch == 0x68 && AMIGO_is_MTA(talking) )
        {
            return (Amigo_Execute(ch) );
        }
 
        if(ch == 0x68 && AMIGO_is_MLA(listening) )// Single byte command
        {
            return (Amigo_Command(ch) );
        }
        if(ch == 0x69 && AMIGO_is_MLA(listening) )// Single byte command
        {
            return (Amigo_Command(ch) );
        }
        if(ch == 0x6a && AMIGO_is_MLA(listening) )// Single byte command
        {
            return (Amigo_Command(ch) );
        }
        if(ch == 0x6c && AMIGO_is_MLA(listening) )// Single byte command
        {
            return (Amigo_Command(ch) );
        }
        if(ch == 0x70 && AMIGO_is_MTA(talking))
        {
            gpib_disable_PPR(AMIGOp->HEADER.PPR);
            return( amigo_cmd_dsj() );
        }
        if(ch == 0x7e && ch == 0x7f)
        {
            return (Amigo_Command(ch) );
        }
        if(ch == 0x70 && AMIGO_is_MLA(listening))
        {
// NOP
        }
    }
    return(0);
}
#endif                                            //ifdef AMIGO