Beispiel #1
0
void wd33c93WriteCtrl(WD33C93* wd33c93, UInt16 port, UInt8 value)
{
    //SCSILOG2("wd33c93 write #%X, %X\n", wd33c93->latch, value);
    switch (wd33c93->latch) {
    case REG_OWN_ID:
        wd33c93->regs[REG_OWN_ID] = value;
        wd33c93->myId = value & 7;
        SCSILOG1("wd33c93 myid = %X\n", wd33c93->myId);
        break;

    case REG_TCH:
        wd33c93->tc = (wd33c93->tc & 0x0000ffff) + (value << 16);
        break;

    case REG_TCM:
        wd33c93->tc = (wd33c93->tc & 0x00ff00ff) + (value << 8);
        break;

    case REG_TCL:
        wd33c93->tc = (wd33c93->tc & 0x00ffff00) + value;
        break;

    case REG_CMD_PHASE:
        SCSILOG1("wd33c93 CMD_PHASE = %X\n", value);
        wd33c93->regs[REG_CMD_PHASE] = value;
        break;

    case REG_CMD:
        wd33c93ExecCmd(wd33c93, value);
        return;     

    case REG_DATA:
        wd33c93->regs[REG_DATA] = value;
        if (wd33c93->phase == DataOut) {
            *wd33c93->pBuf++ = value;
            --wd33c93->tc;
            if (--wd33c93->counter == 0) {
                wd33c93->counter = scsiDeviceDataOut(TARGET, &wd33c93->blockCounter);
                if (wd33c93->counter) {
                    wd33c93->pBuf = wd33c93->buffer;
                    return;
                }
                wd33c93->regs[REG_TLUN] = scsiDeviceGetStatusCode(TARGET);
                scsiDeviceMsgIn(TARGET);
                wd33c93->regs[REG_SCSI_STATUS] = SS_XFER_END;
                wd33c93Disconnect(wd33c93);
            }
        }
        return;

    case REG_AUX_STATUS:
        return;

    default:
        if (wd33c93->latch <= REG_SRC_ID) {
            wd33c93->regs[wd33c93->latch] = value;
        }
        break;
    }
    wd33c93->latch++;
    wd33c93->latch &= 0x1f;
}
Beispiel #2
0
static void mb89352ResetACKREQ(MB89352* spc)
{
    // ACK check
    if ((spc->regs[REG_PSNS] & (PSNS_ACK | PSNS_BSY)) != (PSNS_ACK | PSNS_BSY)) {
        SCSILOG("reset ACK/REQ: ACK/BSY check error\n");
        return;
    }

    // phase check
    if (spc->regs[FIX_PCTL] != (spc->regs[REG_PSNS] & 7)) {
        SCSILOG("reset ACK/REQ: phase check error\n");
        if (spc->isTransfer) {
            spc->regs[REG_INTS] |= INTS_ServiceRequited;
        }
        return;
    }

    switch (spc->phase) {
    // Transfer phase (data in)
    case DataIn:
        if (--spc->counter > 0) {
            spc->regs[REG_PSNS] = PSNS_REQ | PSNS_BSY | PSNS_DATAIN;
        } else {
            if (spc->blockCounter > 0) {
                spc->counter = scsiDeviceDataIn(TARGET, &spc->blockCounter);
                if (spc->counter) {
                    spc->regs[REG_PSNS] = PSNS_REQ | PSNS_BSY | PSNS_DATAIN;
                    spc->pBuffer = spc->buffer;
                    break;
                }
            }
            spc->regs[REG_PSNS] = PSNS_REQ | PSNS_BSY | PSNS_STATUS;
            spc->phase = Status;
        }
        break;

    // Transfer phase (data out)
    case DataOut:
        if (--spc->counter > 0) {
            spc->regs[REG_PSNS] = PSNS_REQ | PSNS_BSY | PSNS_DATAOUT;
        } else {
            spc->counter = scsiDeviceDataOut(TARGET, &spc->blockCounter);
            if (spc->counter) {
                spc->regs[REG_PSNS] = PSNS_REQ | PSNS_BSY | PSNS_DATAOUT;
                spc->pBuffer = spc->buffer;
                break;
            }
            spc->regs[REG_PSNS] = PSNS_REQ | PSNS_BSY | PSNS_STATUS;
            spc->phase = Status;
        }
        break;

    // Command phase
    case Command:
        if (--spc->counter > 0) {
            spc->regs[REG_PSNS] = PSNS_REQ | PSNS_BSY | PSNS_COMMAND;
        } else {
            spc->pBuffer = spc->buffer; // reset buffer pointer
            spc->devBusy = 1;
            spc->counter =
             scsiDeviceExecuteCmd(TARGET, spc->cdb, &spc->phase, &spc->blockCounter);

            switch (spc->phase) {
            case DataIn:
                spc->regs[REG_PSNS] = PSNS_REQ | PSNS_BSY | PSNS_DATAIN;
                break;
            case DataOut:
                spc->regs[REG_PSNS] = PSNS_REQ | PSNS_BSY | PSNS_DATAOUT;
                break;
            case Status:
                spc->regs[REG_PSNS] = PSNS_REQ | PSNS_BSY | PSNS_STATUS;
                break;
            case Execute:
                spc->regs[REG_PSNS] = PSNS_BSY;
                return;
            default:
                SCSILOG("phase error\n");
                break;
            }
            spc->devBusy = 0;
        }
        break;

    // Status phase
    case Status:
        spc->regs[REG_PSNS] = PSNS_REQ | PSNS_BSY | PSNS_MSGIN;
        spc->phase = MsgIn;
        break;

    // Message In phase
    case MsgIn:
        if (spc->msgin <= 0) {
            mb89352Disconnect(spc);
            break;
        }
        spc->msgin = 0;
        // throw to MsgOut...

    // Message Out phase
    case MsgOut:
        if (spc->msgin == -1) {
            mb89352Disconnect(spc);
            return;
        }

        if (spc->atn) {
            if (spc->msgin & 2) {
                mb89352Disconnect(spc);
                return;
            }
            spc->regs[REG_PSNS] = PSNS_REQ | PSNS_BSY | PSNS_MSGOUT;
            return;
        }

        if (spc->msgin & 1) {
            spc->phase = MsgIn;
        } else {
            if (spc->msgin & 4) {
                spc->phase = Status;
                spc->nextPhase = -1;
            } else {
                spc->phase = spc->nextPhase;
                spc->nextPhase = -1;
            }
        }

        spc->msgin = 0;

        switch (spc->phase) {
        case Command:
            spc->regs[REG_PSNS] = PSNS_REQ | PSNS_BSY | PSNS_COMMAND;
            break;
        case DataIn:
            spc->regs[REG_PSNS] = PSNS_REQ | PSNS_BSY | PSNS_DATAIN;
            break;
        case DataOut:
            spc->regs[REG_PSNS] = PSNS_REQ | PSNS_BSY | PSNS_DATAOUT;
            break;
        case Status:
            spc->regs[REG_PSNS] = PSNS_REQ | PSNS_BSY | PSNS_STATUS;
            break;
        case MsgIn:
            spc->regs[REG_PSNS] = PSNS_REQ | PSNS_BSY | PSNS_MSGIN;
            break;
        default:
            SCSILOG("MsgOut code error\n");
            break;
        }
        return;

    default:
        //assert(false);
        SCSILOG("reset ACK/REQ code error\n");
        break;
    }

    if (spc->atn) {
        spc->nextPhase = spc->phase;
        spc->phase = MsgOut;
        spc->regs[REG_PSNS] = PSNS_REQ | PSNS_BSY | PSNS_MSGOUT;
    }
} // end of mb89352ResetACKREQ()