1 // Copyright (C) 2014 Michael McMaster <michael@codesrc.com>
\r
3 // This file is part of SCSI2SD.
\r
5 // SCSI2SD is free software: you can redistribute it and/or modify
\r
6 // it under the terms of the GNU General Public License as published by
\r
7 // the Free Software Foundation, either version 3 of the License, or
\r
8 // (at your option) any later version.
\r
10 // SCSI2SD is distributed in the hope that it will be useful,
\r
11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
\r
12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
\r
13 // GNU General Public License for more details.
\r
15 // You should have received a copy of the GNU General Public License
\r
16 // along with SCSI2SD. If not, see <http://www.gnu.org/licenses/>.
\r
19 #include "scsiPhy.h"
\r
21 #include "diagnostic.h"
\r
23 #include "inquiry.h"
\r
28 //#include "cdrom.h"
\r
29 //#include "debug.h"
\r
35 // Global SCSI device state.
\r
36 ScsiDevice scsiDev S2S_DMA_ALIGN;
\r
38 static void enter_SelectionPhase(void);
\r
39 static void process_SelectionPhase(void);
\r
40 static void enter_BusFree(void);
\r
41 static void enter_MessageIn(uint8_t message);
\r
42 static void enter_Status(uint8_t status);
\r
43 static void enter_DataIn(int len);
\r
44 static void process_DataIn(void);
\r
45 static void process_DataOut(void);
\r
46 static void process_Command(void);
\r
48 static void doReserveRelease(void);
\r
50 static void enter_BusFree()
\r
52 // This delay probably isn't needed for most SCSI hosts, but it won't
\r
53 // hurt either. It's possible some of the samplers needed this delay.
\r
54 if (scsiDev.compatMode < COMPAT_SCSI2)
\r
60 if (scsiDev.status != GOOD && isDebugEnabled())
\r
62 // We want to capture debug information for failure cases.
\r
69 // Wait for the initiator to cease driving signals
\r
70 // Bus settle delay + bus clear delay = 1200ns
\r
75 scsiDev.phase = BUS_FREE;
\r
78 static void enter_MessageIn(uint8_t message)
\r
80 scsiDev.msgIn = message;
\r
81 scsiDev.phase = MESSAGE_IN;
\r
84 void process_MessageIn()
\r
86 scsiEnterPhase(MESSAGE_IN);
\r
87 scsiWriteByte(scsiDev.msgIn);
\r
89 if (unlikely(scsiDev.atnFlag))
\r
91 // If there was a parity error, we go
\r
92 // back to MESSAGE_OUT first, get out parity error message, then come
\r
95 else if ((scsiDev.msgIn == MSG_LINKED_COMMAND_COMPLETE) ||
\r
96 (scsiDev.msgIn == MSG_LINKED_COMMAND_COMPLETE_WITH_FLAG))
\r
98 // Go back to the command phase and start again.
\r
99 scsiDev.phase = COMMAND;
\r
100 scsiDev.parityError = 0;
\r
101 scsiDev.dataPtr = 0;
\r
102 scsiDev.savedDataPtr = 0;
\r
103 scsiDev.dataLen = 0;
\r
104 scsiDev.status = GOOD;
\r
105 transfer.blocks = 0;
\r
106 transfer.currentBlock = 0;
\r
108 else /*if (scsiDev.msgIn == MSG_COMMAND_COMPLETE)*/
\r
114 static void messageReject()
\r
116 scsiEnterPhase(MESSAGE_IN);
\r
117 scsiWriteByte(MSG_REJECT);
\r
120 static void enter_Status(uint8_t status)
\r
122 scsiDev.status = status;
\r
123 scsiDev.phase = STATUS;
\r
125 scsiDev.lastStatus = scsiDev.status;
\r
126 scsiDev.lastSense = scsiDev.target->sense.code;
\r
127 scsiDev.lastSenseASC = scsiDev.target->sense.asc;
\r
130 void process_Status()
\r
132 scsiEnterPhase(STATUS);
\r
136 uint8_t control = scsiDev.cdb[scsiDev.cdbLen - 1];
\r
137 if ((scsiDev.status == GOOD) && (control & 0x01))
\r
140 scsiDev.status = INTERMEDIATE;
\r
141 if (control & 0x02)
\r
143 message = MSG_LINKED_COMMAND_COMPLETE_WITH_FLAG;
\r
147 message = MSG_LINKED_COMMAND_COMPLETE;
\r
152 message = MSG_COMMAND_COMPLETE;
\r
154 scsiWriteByte(scsiDev.status);
\r
156 scsiDev.lastStatus = scsiDev.status;
\r
157 scsiDev.lastSense = scsiDev.target->sense.code;
\r
158 scsiDev.lastSenseASC = scsiDev.target->sense.asc;
\r
161 // Command Complete occurs AFTER a valid status has been
\r
162 // sent. then we go bus-free.
\r
163 enter_MessageIn(message);
\r
166 static void enter_DataIn(int len)
\r
168 scsiDev.dataLen = len;
\r
169 scsiDev.phase = DATA_IN;
\r
172 static void process_DataIn()
\r
176 if (scsiDev.dataLen > sizeof(scsiDev.data))
\r
178 scsiDev.dataLen = sizeof(scsiDev.data);
\r
181 len = scsiDev.dataLen - scsiDev.dataPtr;
\r
184 scsiEnterPhase(DATA_IN);
\r
185 scsiWrite(scsiDev.data + scsiDev.dataPtr, len);
\r
186 scsiDev.dataPtr += len;
\r
189 if ((scsiDev.dataPtr >= scsiDev.dataLen) &&
\r
190 (transfer.currentBlock == transfer.blocks))
\r
192 enter_Status(GOOD);
\r
196 static void process_DataOut()
\r
200 if (scsiDev.dataLen > sizeof(scsiDev.data))
\r
202 scsiDev.dataLen = sizeof(scsiDev.data);
\r
205 scsiDev.parityError = 0;
\r
206 len = scsiDev.dataLen - scsiDev.dataPtr;
\r
209 scsiEnterPhase(DATA_OUT);
\r
211 scsiRead(scsiDev.data + scsiDev.dataPtr, len);
\r
212 scsiDev.dataPtr += len;
\r
214 if (scsiDev.parityError &&
\r
215 (scsiDev.boardCfg.flags & S2S_CFG_ENABLE_PARITY) &&
\r
216 (scsiDev.compatMode >= COMPAT_SCSI2))
\r
218 scsiDev.target->sense.code = ABORTED_COMMAND;
\r
219 scsiDev.target->sense.asc = SCSI_PARITY_ERROR;
\r
220 enter_Status(CHECK_CONDITION);
\r
224 if ((scsiDev.dataPtr >= scsiDev.dataLen) &&
\r
225 (transfer.currentBlock == transfer.blocks))
\r
227 if (scsiDev.postDataOutHook != NULL)
\r
229 scsiDev.postDataOutHook();
\r
233 enter_Status(GOOD);
\r
238 static const uint8_t CmdGroupBytes[8] = {6, 10, 10, 6, 6, 12, 6, 6};
\r
239 static void process_Command()
\r
245 scsiEnterPhase(COMMAND);
\r
246 scsiDev.parityError = 0;
\r
248 memset(scsiDev.cdb, 0, sizeof(scsiDev.cdb));
\r
249 scsiDev.cdb[0] = scsiReadByte();
\r
251 group = scsiDev.cdb[0] >> 5;
\r
252 scsiDev.cdbLen = CmdGroupBytes[group];
\r
253 scsiRead(scsiDev.cdb + 1, scsiDev.cdbLen - 1);
\r
255 command = scsiDev.cdb[0];
\r
257 // Prefer LUN's set by IDENTIFY messages for newer hosts.
\r
258 if (scsiDev.lun < 0)
\r
260 scsiDev.lun = scsiDev.cdb[1] >> 5;
\r
263 control = scsiDev.cdb[scsiDev.cdbLen - 1];
\r
265 scsiDev.cmdCount++;
\r
266 // TODO const S2S_TargetCfg* cfg = scsiDev.target->cfg;
\r
268 if (unlikely(scsiDev.resetFlag))
\r
270 // Don't log bogus commands
\r
271 scsiDev.cmdCount--;
\r
272 memset(scsiDev.cdb, 0xff, sizeof(scsiDev.cdb));
\r
275 else if (scsiDev.parityError &&
\r
276 (scsiDev.boardCfg.flags & S2S_CFG_ENABLE_PARITY) &&
\r
277 (scsiDev.compatMode >= COMPAT_SCSI2))
\r
279 scsiDev.target->sense.code = ABORTED_COMMAND;
\r
280 scsiDev.target->sense.asc = SCSI_PARITY_ERROR;
\r
281 enter_Status(CHECK_CONDITION);
\r
283 else if ((control & 0x02) && ((control & 0x01) == 0))
\r
285 // FLAG set without LINK flag.
\r
286 scsiDev.target->sense.code = ILLEGAL_REQUEST;
\r
287 scsiDev.target->sense.asc = INVALID_FIELD_IN_CDB;
\r
288 enter_Status(CHECK_CONDITION);
\r
290 else if (command == 0x12)
\r
294 else if (command == 0x03)
\r
297 uint32_t allocLength = scsiDev.cdb[4];
\r
299 // As specified by the SASI and SCSI1 standard.
\r
300 // Newer initiators won't be specifying 0 anyway.
\r
301 if (allocLength == 0) allocLength = 4;
\r
303 memset(scsiDev.data, 0, 256); // Max possible alloc length
\r
304 scsiDev.data[0] = 0xF0;
\r
305 scsiDev.data[2] = scsiDev.target->sense.code & 0x0F;
\r
307 scsiDev.data[3] = transfer.lba >> 24;
\r
308 scsiDev.data[4] = transfer.lba >> 16;
\r
309 scsiDev.data[5] = transfer.lba >> 8;
\r
310 scsiDev.data[6] = transfer.lba;
\r
312 // Additional bytes if there are errors to report
\r
313 scsiDev.data[7] = 10; // additional length
\r
314 scsiDev.data[12] = scsiDev.target->sense.asc >> 8;
\r
315 scsiDev.data[13] = scsiDev.target->sense.asc;
\r
317 // Silently truncate results. SCSI-2 spec 8.2.14.
\r
318 enter_DataIn(allocLength);
\r
320 // This is a good time to clear out old sense information.
\r
321 scsiDev.target->sense.code = NO_SENSE;
\r
322 scsiDev.target->sense.asc = NO_ADDITIONAL_SENSE_INFORMATION;
\r
324 // Some old SCSI drivers do NOT properly support
\r
325 // unitAttention. eg. the Mac Plus would trigger a SCSI reset
\r
326 // on receiving the unit attention response on boot, thus
\r
327 // triggering another unit attention condition.
\r
328 else if (scsiDev.target->unitAttention &&
\r
329 (scsiDev.boardCfg.flags & S2S_CFG_ENABLE_UNIT_ATTENTION))
\r
331 scsiDev.target->sense.code = UNIT_ATTENTION;
\r
332 scsiDev.target->sense.asc = scsiDev.target->unitAttention;
\r
334 // If initiator doesn't do REQUEST SENSE for the next command, then
\r
336 scsiDev.target->unitAttention = 0;
\r
338 enter_Status(CHECK_CONDITION);
\r
340 else if (scsiDev.lun)
\r
342 scsiDev.target->sense.code = ILLEGAL_REQUEST;
\r
343 scsiDev.target->sense.asc = LOGICAL_UNIT_NOT_SUPPORTED;
\r
344 enter_Status(CHECK_CONDITION);
\r
346 else if (command == 0x17 || command == 0x16)
\r
348 doReserveRelease();
\r
350 else if ((scsiDev.target->reservedId >= 0) &&
\r
351 (scsiDev.target->reservedId != scsiDev.initiatorId))
\r
353 enter_Status(CONFLICT);
\r
356 // Handle odd device types first that may override basic read and
\r
357 // write commands. Will fall-through to generic disk handling.
\r
358 else if (((cfg->deviceType == S2S_CFG_OPTICAL) && scsiCDRomCommand()) ||
\r
359 ((cfg->deviceType == S2S_CFG_SEQUENTIAL) && scsiTapeCommand()) ||
\r
360 ((cfg->deviceType == S2S_CFG_MO) && scsiMOCommand()))
\r
362 // Already handled.
\r
365 else if (scsiDiskCommand())
\r
367 // Already handled.
\r
368 // check for the performance-critical read/write
\r
371 else if (command == 0x1C)
\r
373 scsiReceiveDiagnostic();
\r
375 else if (command == 0x1D)
\r
377 scsiSendDiagnostic();
\r
379 else if (command == 0x3B)
\r
383 else if (command == 0x3C)
\r
387 else if (!scsiModeCommand())
\r
389 scsiDev.target->sense.code = ILLEGAL_REQUEST;
\r
390 scsiDev.target->sense.asc = INVALID_COMMAND_OPERATION_CODE;
\r
391 enter_Status(CHECK_CONDITION);
\r
395 if (scsiDev.phase == COMMAND) // No status set, and not in DATA_IN
\r
397 enter_Status(GOOD);
\r
402 static void doReserveRelease()
\r
404 int extentReservation = scsiDev.cdb[1] & 1;
\r
405 int thirdPty = scsiDev.cdb[1] & 0x10;
\r
406 int thirdPtyId = (scsiDev.cdb[1] >> 1) & 0x7;
\r
407 uint8_t command = scsiDev.cdb[0];
\r
410 (!thirdPty && (scsiDev.initiatorId == scsiDev.target->reservedId)) ||
\r
412 (scsiDev.target->reserverId == scsiDev.initiatorId) &&
\r
413 (scsiDev.target->reservedId == thirdPtyId)
\r
416 if (extentReservation)
\r
419 scsiDev.target->sense.code = ILLEGAL_REQUEST;
\r
420 scsiDev.target->sense.asc = INVALID_FIELD_IN_CDB;
\r
421 enter_Status(CHECK_CONDITION);
\r
423 else if (command == 0x17) // release
\r
425 if ((scsiDev.target->reservedId < 0) || canRelease)
\r
427 scsiDev.target->reservedId = -1;
\r
428 scsiDev.target->reserverId = -1;
\r
432 enter_Status(CONFLICT);
\r
435 else // assume reserve.
\r
437 if ((scsiDev.target->reservedId < 0) || canRelease)
\r
439 scsiDev.target->reserverId = scsiDev.initiatorId;
\r
442 scsiDev.target->reservedId = thirdPtyId;
\r
446 scsiDev.target->reservedId = scsiDev.initiatorId;
\r
451 // Already reserved by someone else!
\r
452 enter_Status(CONFLICT);
\r
457 static void scsiReset()
\r
459 scsiDev.rstCount++;
\r
464 scsiDev.parityError = 0;
\r
465 scsiDev.phase = BUS_FREE;
\r
466 scsiDev.atnFlag = 0;
\r
467 scsiDev.resetFlag = 0;
\r
469 scsiDev.compatMode = COMPAT_UNKNOWN;
\r
471 if (scsiDev.target)
\r
473 if (scsiDev.target->unitAttention != POWER_ON_RESET)
\r
475 scsiDev.target->unitAttention = SCSI_BUS_RESET;
\r
477 scsiDev.target->reservedId = -1;
\r
478 scsiDev.target->reserverId = -1;
\r
479 scsiDev.target->sense.code = NO_SENSE;
\r
480 scsiDev.target->sense.asc = NO_ADDITIONAL_SENSE_INFORMATION;
\r
482 scsiDev.target = NULL;
\r
485 scsiDev.postDataOutHook = NULL;
\r
487 // Sleep to allow the bus to settle down a bit.
\r
488 // We must be ready again within the "Reset to selection time" of
\r
490 // There is no guarantee that the RST line will be negated by then.
\r
491 // NOTE: We could be connected and powered by USB for configuration,
\r
492 // in which case TERMPWR cannot be supplied, and reset will ALWAYS
\r
493 // be true. Therefore, the sleep here must be slow to avoid slowing
\r
495 s2s_delay_ms(1); // 1ms.
\r
498 static void enter_SelectionPhase()
\r
500 // Ignore stale versions of this flag, but ensure we know the
\r
501 // current value if the flag is still set.
\r
502 scsiDev.atnFlag = 0;
\r
503 scsiDev.parityError = 0;
\r
504 scsiDev.dataPtr = 0;
\r
505 scsiDev.savedDataPtr = 0;
\r
506 scsiDev.dataLen = 0;
\r
507 scsiDev.status = GOOD;
\r
508 scsiDev.phase = SELECTION;
\r
510 scsiDev.discPriv = 0;
\r
512 scsiDev.initiatorId = -1;
\r
513 scsiDev.target = NULL;
\r
515 transfer.blocks = 0;
\r
516 transfer.currentBlock = 0;
\r
518 scsiDev.postDataOutHook = NULL;
\r
521 static void process_SelectionPhase()
\r
523 // Selection delays.
\r
524 // Many SCSI1 samplers that use a 5380 chip need a delay of at least 1ms.
\r
525 // The Mac Plus boot-time (ie. rom code) selection abort time
\r
526 // is < 1ms and must have no delay (standard suggests 250ms abort time)
\r
527 // Most newer SCSI2 hosts don't care either way.
\r
528 if (scsiDev.boardCfg.selectionDelay == 255) // auto
\r
530 if (scsiDev.compatMode < COMPAT_SCSI2)
\r
535 else if (scsiDev.boardCfg.selectionDelay != 0)
\r
537 s2s_delay_ms(scsiDev.boardCfg.selectionDelay);
\r
540 uint8_t selStatus = *SCSI_STS_SELECTED;
\r
543 int sel = SCSI_ReadFilt(SCSI_Filt_SEL);
\r
544 int bsy = SCSI_ReadFilt(SCSI_Filt_BSY);
\r
545 int io = SCSI_ReadPin(SCSI_In_IO);
\r
547 // Only read these pins AFTER SEL and BSY - we don't want to catch them
\r
548 // during a transition period.
\r
549 uint8_t mask = scsiReadDBxPins();
\r
550 int atnFlag = SCSI_ReadFilt(SCSI_Filt_ATN);
\r
553 TargetState* target = NULL;
\r
554 for (tgtIndex = 0; tgtIndex < S2S_MAX_TARGETS; ++tgtIndex)
\r
556 if (scsiDev.targets[tgtIndex].targetId == (selStatus & 7))
\r
558 target = &scsiDev.targets[tgtIndex];
\r
562 if ((target != NULL) && (selStatus & 0x40))
\r
563 // TODO (goodParity || !(scsiDev.boardCfg.flags & S2S_CFG_ENABLE_PARITY) || !atnFlag)
\r
565 // We've been selected!
\r
566 // Assert BSY - Selection success!
\r
567 // must happen within 200us (Selection abort time) of seeing our
\r
569 // (Note: the initiator will be waiting the "Selection time-out delay"
\r
570 // for our BSY response, which is actually a very generous 250ms)
\r
571 *SCSI_CTRL_BSY = 1;
\r
574 scsiDev.target = target;
\r
576 // Do we enter MESSAGE OUT immediately ? SCSI 1 and 2 standards says
\r
577 // move to MESSAGE OUT if ATN is true before we assert BSY.
\r
578 // The initiator should assert ATN with SEL.
\r
579 scsiDev.atnFlag = selStatus & 0x80;
\r
582 // Unit attention breaks many older SCSI hosts. Disable it completely
\r
583 // for SCSI-1 (and older) hosts, regardless of our configured setting.
\r
584 // Enable the compatability mode also as many SASI and SCSI1
\r
585 // controllers don't generate parity bits.
\r
586 if (!scsiDev.atnFlag)
\r
588 target->unitAttention = 0;
\r
589 scsiDev.compatMode = COMPAT_SCSI1;
\r
591 else if (!(scsiDev.boardCfg.flags & S2S_CFG_ENABLE_SCSI2))
\r
593 scsiDev.compatMode = COMPAT_SCSI1;
\r
595 else if (scsiDev.compatMode == COMPAT_UNKNOWN)
\r
597 scsiDev.compatMode = COMPAT_SCSI2;
\r
600 scsiDev.selCount++;
\r
603 // Save our initiator now that we're no longer in a time-critical
\r
605 // SCSI1/SASI initiators may not set their own ID.
\r
606 scsiDev.initiatorId = (selStatus >> 3) & 0x7;
\r
608 // Wait until the end of the selection phase.
\r
609 while (likely(!scsiDev.resetFlag))
\r
611 if ((*SCSI_STS_SELECTED & 0x40) == 0)
\r
617 scsiDev.phase = COMMAND;
\r
619 else if (!selStatus)
\r
621 scsiDev.phase = BUS_BUSY;
\r
625 static void process_MessageOut()
\r
627 scsiEnterPhase(MESSAGE_OUT);
\r
629 scsiDev.atnFlag = 0;
\r
630 scsiDev.parityError = 0;
\r
631 scsiDev.msgOut = scsiReadByte();
\r
632 scsiDev.msgCount++;
\r
634 if (scsiDev.parityError &&
\r
635 (scsiDev.boardCfg.flags & S2S_CFG_ENABLE_PARITY) &&
\r
636 (scsiDev.compatMode >= COMPAT_SCSI2))
\r
638 // Skip the remaining message bytes, and then start the MESSAGE_OUT
\r
639 // phase again from the start. The initiator will re-send the
\r
640 // same set of messages.
\r
641 while (scsiStatusATN() && !scsiDev.resetFlag)
\r
646 // Go-back and try the message again.
\r
647 scsiDev.atnFlag = 1;
\r
648 scsiDev.parityError = 0;
\r
650 else if (scsiDev.msgOut == 0x00)
\r
652 // COMMAND COMPLETE. but why would the target be receiving this ? nfi.
\r
655 else if (scsiDev.msgOut == 0x06)
\r
661 else if (scsiDev.msgOut == 0x0C)
\r
663 // BUS DEVICE RESET
\r
667 scsiDev.target->unitAttention = SCSI_BUS_RESET;
\r
669 // ANY initiator can reset the reservation state via this message.
\r
670 scsiDev.target->reservedId = -1;
\r
671 scsiDev.target->reserverId = -1;
\r
674 else if (scsiDev.msgOut == 0x05)
\r
676 // Initiate Detected Error
\r
679 else if (scsiDev.msgOut == 0x0F)
\r
681 // INITIATE RECOVERY
\r
684 else if (scsiDev.msgOut == 0x10)
\r
686 // RELEASE RECOVERY
\r
690 else if (scsiDev.msgOut == MSG_REJECT)
\r
694 scsiDev.resetFlag = 1;
\r
696 else if (scsiDev.msgOut == 0x08)
\r
700 else if (scsiDev.msgOut == 0x09)
\r
702 // Message Parity Error
\r
703 // Go back and re-send the last message.
\r
704 scsiDev.phase = MESSAGE_IN;
\r
706 else if (scsiDev.msgOut & 0x80) // 0x80 -> 0xFF
\r
709 if ((scsiDev.msgOut & 0x18) || // Reserved bits set.
\r
710 (scsiDev.msgOut & 0x20)) // We don't have any target routines!
\r
715 scsiDev.lun = scsiDev.msgOut & 0x7;
\r
716 scsiDev.discPriv =
\r
717 ((scsiDev.msgOut & 0x40) && (scsiDev.initiatorId >= 0))
\r
720 else if (scsiDev.msgOut >= 0x20 && scsiDev.msgOut <= 0x2F)
\r
722 // Two byte message. We don't support these. read and discard.
\r
725 if (scsiDev.msgOut == 0x23) {
\r
726 // Ignore Wide Residue. We're only 8 bit anyway.
\r
731 else if (scsiDev.msgOut == 0x01)
\r
735 // Extended message.
\r
736 int msgLen = scsiReadByte();
\r
737 if (msgLen == 0) msgLen = 256;
\r
738 uint8_t extmsg[256];
\r
739 for (i = 0; i < msgLen && !scsiDev.resetFlag; ++i)
\r
742 extmsg[i] = scsiReadByte();
\r
745 if (extmsg[0] == 3 && msgLen == 2) // Wide Data Request
\r
747 // Negotiate down to 8bit
\r
748 scsiEnterPhase(MESSAGE_IN);
\r
749 static const uint8_t WDTR[] = {0x01, 0x02, 0x03, 0x00};
\r
750 scsiWrite(WDTR, sizeof(WDTR));
\r
752 else if (extmsg[0] == 1 && msgLen == 3) // Synchronous data request
\r
754 // Negotiate back to async
\r
755 scsiEnterPhase(MESSAGE_IN);
\r
756 static const uint8_t SDTR[] = {0x01, 0x03, 0x01, 0x00, 0x00};
\r
757 scsiWrite(SDTR, sizeof(SDTR));
\r
770 // Re-check the ATN flag in case it stays asserted.
\r
771 scsiDev.atnFlag |= scsiStatusATN();
\r
774 void scsiPoll(void)
\r
776 if (unlikely(scsiDev.resetFlag))
\r
779 if ((scsiDev.resetFlag = scsiStatusRST()))
\r
781 // Still in reset phase. Do not try and process any commands.
\r
786 switch (scsiDev.phase)
\r
789 if (scsiStatusBSY())
\r
791 scsiDev.phase = BUS_BUSY;
\r
793 // The Arbitration phase is optional for SCSI1/SASI hosts if there is only
\r
794 // one initiator in the chain. Support this by moving
\r
795 // straight to selection if SEL is asserted.
\r
796 // ie. the initiator won't assert BSY and it's own ID before moving to selection.
\r
797 else if (*SCSI_STS_SELECTED)
\r
799 enter_SelectionPhase();
\r
804 // Someone is using the bus. Perhaps they are trying to
\r
806 if (*SCSI_STS_SELECTED)
\r
808 enter_SelectionPhase();
\r
810 else if (!scsiStatusBSY())
\r
812 scsiDev.phase = BUS_FREE;
\r
817 // TODO Support reselection.
\r
821 process_SelectionPhase();
\r
825 // Not currently supported!
\r
829 // Do not check ATN here. SCSI 1 & 2 initiators must set ATN
\r
830 // and SEL together upon entering the selection phase if they
\r
831 // want to send a message (IDENTIFY) immediately.
\r
832 if (scsiDev.atnFlag)
\r
834 process_MessageOut();
\r
843 scsiDev.atnFlag |= scsiStatusATN();
\r
844 if (scsiDev.atnFlag)
\r
846 process_MessageOut();
\r
855 scsiDev.atnFlag |= scsiStatusATN();
\r
856 if (scsiDev.atnFlag)
\r
858 process_MessageOut();
\r
867 scsiDev.atnFlag |= scsiStatusATN();
\r
868 if (scsiDev.atnFlag)
\r
870 process_MessageOut();
\r
879 scsiDev.atnFlag |= scsiStatusATN();
\r
880 if (scsiDev.atnFlag)
\r
882 process_MessageOut();
\r
886 process_MessageIn();
\r
892 process_MessageOut();
\r
899 static int firstInit = 1;
\r
901 scsiDev.atnFlag = 0;
\r
902 scsiDev.resetFlag = 1;
\r
903 scsiDev.phase = BUS_FREE;
\r
904 scsiDev.target = NULL;
\r
905 scsiDev.compatMode = COMPAT_UNKNOWN;
\r
908 for (i = 0; i < S2S_MAX_TARGETS; ++i)
\r
910 const S2S_TargetCfg* cfg = s2s_getConfigByIndex(i);
\r
911 if (cfg && (cfg->scsiId & S2S_CFG_TARGET_ENABLED))
\r
913 scsiDev.targets[i].targetId = cfg->scsiId & S2S_CFG_TARGET_ID_BITS;
\r
914 scsiDev.targets[i].cfg = cfg;
\r
916 scsiDev.targets[i].liveCfg.bytesPerSector = cfg->bytesPerSector;
\r
920 scsiDev.targets[i].targetId = 0xff;
\r
921 scsiDev.targets[i].cfg = NULL;
\r
923 scsiDev.targets[i].reservedId = -1;
\r
924 scsiDev.targets[i].reserverId = -1;
\r
927 scsiDev.targets[i].unitAttention = POWER_ON_RESET;
\r
931 scsiDev.targets[i].unitAttention = PARAMETERS_CHANGED;
\r
933 scsiDev.targets[i].sense.code = NO_SENSE;
\r
934 scsiDev.targets[i].sense.asc = NO_ADDITIONAL_SENSE_INFORMATION;
\r
940 void scsiDisconnect()
\r
942 scsiEnterPhase(MESSAGE_IN);
\r
943 scsiWriteByte(0x02); // save data pointer
\r
944 scsiWriteByte(0x04); // disconnect msg.
\r
946 // For now, the caller is responsible for tracking the disconnected
\r
947 // state, and calling scsiReconnect.
\r
948 // Ideally the client would exit their loop and we'd implement this
\r
949 // as part of scsiPoll
\r
950 int phase = scsiDev.phase;
\r
952 scsiDev.phase = phase;
\r
957 int scsiReconnect()
\r
959 int reconnected = 0;
\r
961 int sel = SCSI_ReadFilt(SCSI_Filt_SEL);
\r
962 int bsy = SCSI_ReadFilt(SCSI_Filt_BSY);
\r
966 sel = SCSI_ReadFilt(SCSI_Filt_SEL);
\r
967 bsy = SCSI_ReadFilt(SCSI_Filt_BSY);
\r
974 uint8_t scsiIdMask = 1 << scsiDev.target->targetId;
\r
975 SCSI_Out_Bits_Write(scsiIdMask);
\r
976 SCSI_Out_Ctl_Write(1); // Write bits manually.
\r
977 SCSI_SetPin(SCSI_Out_BSY);
\r
979 s2s_delay_us(3); // arbitrate delay. 2.4us.
\r
981 uint8_t dbx = scsiReadDBxPins();
\r
982 sel = SCSI_ReadFilt(SCSI_Filt_SEL);
\r
983 if (sel || ((dbx ^ scsiIdMask) > scsiIdMask))
\r
985 // Lost arbitration.
\r
986 SCSI_Out_Ctl_Write(0);
\r
987 SCSI_ClearPin(SCSI_Out_BSY);
\r
993 SCSI_SetPin(SCSI_Out_SEL);
\r
994 s2s_delay_us(1); // Bus clear + Bus settle.
\r
996 // Reselection phase
\r
997 SCSI_CTL_PHASE_Write(__scsiphase_io);
\r
998 SCSI_Out_Bits_Write(scsiIdMask | (1 << scsiDev.initiatorId));
\r
999 scsiDeskewDelay(); // 2 deskew delays
\r
1000 scsiDeskewDelay(); // 2 deskew delays
\r
1001 SCSI_ClearPin(SCSI_Out_BSY);
\r
1002 s2s_delay_us(1); // Bus Settle Delay
\r
1004 uint32_t waitStart_ms = getTime_ms();
\r
1005 bsy = SCSI_ReadFilt(SCSI_Filt_BSY);
\r
1006 // Wait for initiator.
\r
1009 !scsiDev.resetFlag &&
\r
1010 (elapsedTime_ms(waitStart_ms) < 250))
\r
1012 bsy = SCSI_ReadFilt(SCSI_Filt_BSY);
\r
1017 SCSI_SetPin(SCSI_Out_BSY);
\r
1018 scsiDeskewDelay(); // 2 deskew delays
\r
1019 scsiDeskewDelay(); // 2 deskew delays
\r
1020 SCSI_ClearPin(SCSI_Out_SEL);
\r
1022 // Prepare for the initial IDENTIFY message.
\r
1023 SCSI_Out_Ctl_Write(0);
\r
1024 scsiEnterPhase(MESSAGE_IN);
\r
1026 // Send identify command
\r
1027 scsiWriteByte(0x80);
\r
1029 scsiEnterPhase(scsiDev.phase);
\r
1034 // reselect timeout.
\r
1035 SCSI_Out_Ctl_Write(0);
\r
1036 SCSI_ClearPin(SCSI_Out_SEL);
\r
1037 SCSI_CTL_PHASE_Write(0);
\r
1042 return reconnected;
\r