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
17 #pragma GCC push_options
\r
18 #pragma GCC optimize("-flto")
\r
22 #include "scsiPhy.h"
\r
25 #include "diagnostic.h"
\r
27 #include "inquiry.h"
\r
37 // Global SCSI device state.
\r
40 static void enter_SelectionPhase(void);
\r
41 static void process_SelectionPhase(void);
\r
42 static void enter_BusFree(void);
\r
43 static void enter_MessageIn(uint8 message);
\r
44 static void enter_Status(uint8 status);
\r
45 static void enter_DataIn(int len);
\r
46 static void process_DataIn(void);
\r
47 static void process_DataOut(void);
\r
48 static void process_Command(void);
\r
50 static void doReserveRelease(void);
\r
52 static void enter_BusFree()
\r
54 // This delay probably isn't needed for most SCSI hosts, but it won't
\r
55 // hurt either. It's possible some of the samplers needed this delay.
\r
56 if (scsiDev.compatMode)
\r
61 if (scsiDev.status != GOOD && isDebugEnabled())
\r
63 // We want to capture debug information for failure cases.
\r
67 SCSI_ClearPin(SCSI_Out_BSY);
\r
68 // We now have a Bus Clear Delay of 800ns to release remaining signals.
\r
69 SCSI_CTL_PHASE_Write(0);
\r
71 // Wait for the initiator to cease driving signals
\r
72 // Bus settle delay + bus clear delay = 1200ns
\r
76 scsiDev.phase = BUS_FREE;
\r
79 static void enter_MessageIn(uint8 message)
\r
81 scsiDev.msgIn = message;
\r
82 scsiDev.phase = MESSAGE_IN;
\r
85 void process_MessageIn()
\r
87 scsiEnterPhase(MESSAGE_IN);
\r
88 scsiWriteByte(scsiDev.msgIn);
\r
90 if (unlikely(scsiDev.atnFlag))
\r
92 // If there was a parity error, we go
\r
93 // back to MESSAGE_OUT first, get out parity error message, then come
\r
96 else if ((scsiDev.msgIn == MSG_LINKED_COMMAND_COMPLETE) ||
\r
97 (scsiDev.msgIn == MSG_LINKED_COMMAND_COMPLETE_WITH_FLAG))
\r
99 // Go back to the command phase and start again.
\r
100 scsiDev.phase = COMMAND;
\r
101 scsiDev.parityError = 0;
\r
102 scsiDev.dataPtr = 0;
\r
103 scsiDev.savedDataPtr = 0;
\r
104 scsiDev.dataLen = 0;
\r
105 scsiDev.status = GOOD;
\r
106 transfer.blocks = 0;
\r
107 transfer.currentBlock = 0;
\r
109 else /*if (scsiDev.msgIn == MSG_COMMAND_COMPLETE)*/
\r
115 static void messageReject()
\r
117 scsiEnterPhase(MESSAGE_IN);
\r
118 scsiWriteByte(MSG_REJECT);
\r
121 static void enter_Status(uint8 status)
\r
123 scsiDev.status = status;
\r
124 scsiDev.phase = STATUS;
\r
126 scsiDev.lastStatus = scsiDev.status;
\r
127 scsiDev.lastSense = scsiDev.target->sense.code;
\r
128 scsiDev.lastSenseASC = scsiDev.target->sense.asc;
\r
131 void process_Status()
\r
133 scsiEnterPhase(STATUS);
\r
137 uint8 control = scsiDev.cdb[scsiDev.cdbLen - 1];
\r
138 if ((scsiDev.status == GOOD) && (control & 0x01))
\r
141 scsiDev.status = INTERMEDIATE;
\r
142 if (control & 0x02)
\r
144 message = MSG_LINKED_COMMAND_COMPLETE_WITH_FLAG;
\r
148 message = MSG_LINKED_COMMAND_COMPLETE;
\r
153 message = MSG_COMMAND_COMPLETE;
\r
155 scsiWriteByte(scsiDev.status);
\r
157 scsiDev.lastStatus = scsiDev.status;
\r
158 scsiDev.lastSense = scsiDev.target->sense.code;
\r
159 scsiDev.lastSenseASC = scsiDev.target->sense.asc;
\r
162 // Command Complete occurs AFTER a valid status has been
\r
163 // sent. then we go bus-free.
\r
164 enter_MessageIn(message);
\r
167 static void enter_DataIn(int len)
\r
169 scsiDev.dataLen = len;
\r
170 scsiDev.phase = DATA_IN;
\r
173 static void process_DataIn()
\r
177 if (scsiDev.dataLen > sizeof(scsiDev.data))
\r
179 scsiDev.dataLen = sizeof(scsiDev.data);
\r
182 len = scsiDev.dataLen - scsiDev.dataPtr;
\r
185 scsiEnterPhase(DATA_IN);
\r
186 scsiWrite(scsiDev.data + scsiDev.dataPtr, len);
\r
187 scsiDev.dataPtr += len;
\r
190 if ((scsiDev.dataPtr >= scsiDev.dataLen) &&
\r
191 (transfer.currentBlock == transfer.blocks))
\r
193 enter_Status(GOOD);
\r
197 static void process_DataOut()
\r
201 if (scsiDev.dataLen > sizeof(scsiDev.data))
\r
203 scsiDev.dataLen = sizeof(scsiDev.data);
\r
206 scsiDev.parityError = 0;
\r
207 len = scsiDev.dataLen - scsiDev.dataPtr;
\r
210 scsiEnterPhase(DATA_OUT);
\r
212 scsiRead(scsiDev.data + scsiDev.dataPtr, len);
\r
213 scsiDev.dataPtr += len;
\r
215 if (scsiDev.parityError &&
\r
216 (scsiDev.target->cfg->flags & CONFIG_ENABLE_PARITY) &&
\r
217 !scsiDev.compatMode)
\r
219 scsiDev.target->sense.code = ABORTED_COMMAND;
\r
220 scsiDev.target->sense.asc = SCSI_PARITY_ERROR;
\r
221 enter_Status(CHECK_CONDITION);
\r
225 if ((scsiDev.dataPtr >= scsiDev.dataLen) &&
\r
226 (transfer.currentBlock == transfer.blocks))
\r
228 if (scsiDev.postDataOutHook != NULL)
\r
230 scsiDev.postDataOutHook();
\r
234 enter_Status(GOOD);
\r
239 static const uint8 CmdGroupBytes[8] = {6, 10, 10, 6, 6, 12, 6, 6};
\r
240 static void process_Command()
\r
246 scsiEnterPhase(COMMAND);
\r
247 scsiDev.parityError = 0;
\r
249 memset(scsiDev.cdb, 0, sizeof(scsiDev.cdb));
\r
250 scsiDev.cdb[0] = scsiReadByte();
\r
252 group = scsiDev.cdb[0] >> 5;
\r
253 scsiDev.cdbLen = CmdGroupBytes[group];
\r
254 scsiRead(scsiDev.cdb + 1, scsiDev.cdbLen - 1);
\r
256 command = scsiDev.cdb[0];
\r
258 // Prefer LUN's set by IDENTIFY messages for newer hosts.
\r
259 if (scsiDev.lun < 0)
\r
261 scsiDev.lun = scsiDev.cdb[1] >> 5;
\r
264 control = scsiDev.cdb[scsiDev.cdbLen - 1];
\r
266 scsiDev.cmdCount++;
\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.target->cfg->flags & CONFIG_ENABLE_PARITY) &&
\r
277 !scsiDev.compatMode)
\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 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.target->cfg->flags & CONFIG_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
355 else if (scsiDiskCommand())
\r
357 // Already handled.
\r
358 // check for the performance-critical read/write
\r
361 else if (command == 0x1C)
\r
363 scsiReceiveDiagnostic();
\r
365 else if (command == 0x1D)
\r
367 scsiSendDiagnostic();
\r
369 else if (command == 0x3B)
\r
373 else if (command == 0x3C)
\r
378 !scsiCDRomCommand() &&
\r
379 !scsiModeCommand())
\r
381 scsiDev.target->sense.code = ILLEGAL_REQUEST;
\r
382 scsiDev.target->sense.asc = INVALID_COMMAND_OPERATION_CODE;
\r
383 enter_Status(CHECK_CONDITION);
\r
387 if (scsiDev.phase == COMMAND) // No status set, and not in DATA_IN
\r
389 enter_Status(GOOD);
\r
394 static void doReserveRelease()
\r
396 int extentReservation = scsiDev.cdb[1] & 1;
\r
397 int thirdPty = scsiDev.cdb[1] & 0x10;
\r
398 int thirdPtyId = (scsiDev.cdb[1] >> 1) & 0x7;
\r
399 uint8 command = scsiDev.cdb[0];
\r
402 (!thirdPty && (scsiDev.initiatorId == scsiDev.target->reservedId)) ||
\r
404 (scsiDev.target->reserverId == scsiDev.initiatorId) &&
\r
405 (scsiDev.target->reservedId == thirdPtyId)
\r
408 if (extentReservation)
\r
411 scsiDev.target->sense.code = ILLEGAL_REQUEST;
\r
412 scsiDev.target->sense.asc = INVALID_FIELD_IN_CDB;
\r
413 enter_Status(CHECK_CONDITION);
\r
415 else if (command == 0x17) // release
\r
417 if ((scsiDev.target->reservedId < 0) || canRelease)
\r
419 scsiDev.target->reservedId = -1;
\r
420 scsiDev.target->reserverId = -1;
\r
424 enter_Status(CONFLICT);
\r
427 else // assume reserve.
\r
429 if ((scsiDev.target->reservedId < 0) || canRelease)
\r
431 scsiDev.target->reserverId = scsiDev.initiatorId;
\r
434 scsiDev.target->reservedId = thirdPtyId;
\r
438 scsiDev.target->reservedId = scsiDev.initiatorId;
\r
443 // Already reserved by someone else!
\r
444 enter_Status(CONFLICT);
\r
449 static void scsiReset()
\r
451 scsiDev.rstCount++;
\r
455 SCSI_Out_Ctl_Write(0);
\r
457 scsiDev.parityError = 0;
\r
458 scsiDev.phase = BUS_FREE;
\r
459 scsiDev.atnFlag = 0;
\r
460 scsiDev.resetFlag = 0;
\r
463 if (scsiDev.target)
\r
465 if (scsiDev.target->unitAttention != POWER_ON_RESET)
\r
467 scsiDev.target->unitAttention = SCSI_BUS_RESET;
\r
469 scsiDev.target->reservedId = -1;
\r
470 scsiDev.target->reserverId = -1;
\r
471 scsiDev.target->sense.code = NO_SENSE;
\r
472 scsiDev.target->sense.asc = NO_ADDITIONAL_SENSE_INFORMATION;
\r
474 scsiDev.target = NULL;
\r
477 scsiDev.postDataOutHook = NULL;
\r
479 // Sleep to allow the bus to settle down a bit.
\r
480 // We must be ready again within the "Reset to selection time" of
\r
482 // There is no guarantee that the RST line will be negated by then.
\r
483 // NOTE: We could be connected and powered by USB for configuration,
\r
484 // in which case TERMPWR cannot be supplied, and reset will ALWAYS
\r
485 // be true. Therefore, the sleep here must be slow to avoid slowing
\r
487 CyDelay(1); // 1ms.
\r
490 static void enter_SelectionPhase()
\r
492 // Ignore stale versions of this flag, but ensure we know the
\r
493 // current value if the flag is still set.
\r
494 scsiDev.atnFlag = 0;
\r
495 scsiDev.parityError = 0;
\r
496 scsiDev.dataPtr = 0;
\r
497 scsiDev.savedDataPtr = 0;
\r
498 scsiDev.dataLen = 0;
\r
499 scsiDev.status = GOOD;
\r
500 scsiDev.phase = SELECTION;
\r
502 scsiDev.discPriv = 0;
\r
503 scsiDev.compatMode = 0;
\r
505 scsiDev.initiatorId = -1;
\r
506 scsiDev.target = NULL;
\r
508 transfer.blocks = 0;
\r
509 transfer.currentBlock = 0;
\r
511 scsiDev.postDataOutHook = NULL;
\r
514 static void process_SelectionPhase()
\r
516 int sel = SCSI_ReadFilt(SCSI_Filt_SEL);
\r
517 int bsy = SCSI_ReadFilt(SCSI_Filt_BSY);
\r
519 // Only read these pins AFTER SEL and BSY - we don't want to catch them
\r
520 // during a transition period.
\r
521 uint8 mask = scsiReadDBxPins();
\r
522 int maskBitCount = countBits(mask);
\r
523 int goodParity = (Lookup_OddParity[mask] == SCSI_ReadPin(SCSI_In_DBP));
\r
524 int atnFlag = SCSI_ReadFilt(SCSI_Filt_ATN);
\r
527 TargetState* target = NULL;
\r
528 for (tgtIndex = 0; tgtIndex < MAX_SCSI_TARGETS; ++tgtIndex)
\r
530 if (mask & (1 << scsiDev.targets[tgtIndex].targetId))
\r
532 target = &scsiDev.targets[tgtIndex];
\r
538 (goodParity || !(target->cfg->flags & CONFIG_ENABLE_PARITY) || !atnFlag) &&
\r
539 likely(maskBitCount <= 2))
\r
541 scsiDev.target = target;
\r
543 // Do we enter MESSAGE OUT immediately ? SCSI 1 and 2 standards says
\r
544 // move to MESSAGE OUT if ATN is true before we assert BSY.
\r
545 // The initiator should assert ATN with SEL.
\r
546 scsiDev.atnFlag = atnFlag;
\r
548 // Unit attention breaks many older SCSI hosts. Disable it completely
\r
549 // for SCSI-1 (and older) hosts, regardless of our configured setting.
\r
550 // Enable the compatability mode also as many SASI and SCSI1
\r
551 // controllers don't generate parity bits.
\r
552 if (!scsiDev.atnFlag)
\r
554 target->unitAttention = 0;
\r
555 scsiDev.compatMode = 1;
\r
558 // We've been selected!
\r
559 // Assert BSY - Selection success!
\r
560 // must happen within 200us (Selection abort time) of seeing our
\r
562 // (Note: the initiator will be waiting the "Selection time-out delay"
\r
563 // for our BSY response, which is actually a very generous 250ms)
\r
564 SCSI_SetPin(SCSI_Out_BSY);
\r
567 scsiDev.selCount++;
\r
569 // Wait until the end of the selection phase.
\r
570 while (likely(!scsiDev.resetFlag))
\r
572 if (!SCSI_ReadFilt(SCSI_Filt_SEL))
\r
578 // Save our initiator now that we're no longer in a time-critical
\r
580 // SCSI1/SASI initiators may not set their own ID.
\r
583 uint8_t initiatorMask = mask ^ (1 << target->targetId);
\r
584 scsiDev.initiatorId = -1;
\r
585 for (i = 0; i < 8; ++i)
\r
587 if (initiatorMask & (1 << i))
\r
589 scsiDev.initiatorId = i;
\r
595 scsiDev.phase = COMMAND;
\r
599 scsiDev.phase = BUS_BUSY;
\r
603 static void process_MessageOut()
\r
605 scsiEnterPhase(MESSAGE_OUT);
\r
607 scsiDev.atnFlag = 0;
\r
608 scsiDev.parityError = 0;
\r
609 scsiDev.msgOut = scsiReadByte();
\r
610 scsiDev.msgCount++;
\r
612 if (scsiDev.parityError &&
\r
613 (scsiDev.target->cfg->flags & CONFIG_ENABLE_PARITY) &&
\r
614 !scsiDev.compatMode)
\r
616 // Skip the remaining message bytes, and then start the MESSAGE_OUT
\r
617 // phase again from the start. The initiator will re-send the
\r
618 // same set of messages.
\r
619 while (SCSI_ReadFilt(SCSI_Filt_ATN) && !scsiDev.resetFlag)
\r
624 // Go-back and try the message again.
\r
625 scsiDev.atnFlag = 1;
\r
626 scsiDev.parityError = 0;
\r
628 else if (scsiDev.msgOut == 0x00)
\r
630 // COMMAND COMPLETE. but why would the target be receiving this ? nfi.
\r
633 else if (scsiDev.msgOut == 0x06)
\r
639 else if (scsiDev.msgOut == 0x0C)
\r
641 // BUS DEVICE RESET
\r
645 scsiDev.target->unitAttention = SCSI_BUS_RESET;
\r
647 // ANY initiator can reset the reservation state via this message.
\r
648 scsiDev.target->reservedId = -1;
\r
649 scsiDev.target->reserverId = -1;
\r
652 else if (scsiDev.msgOut == 0x05)
\r
654 // Initiate Detected Error
\r
657 else if (scsiDev.msgOut == 0x0F)
\r
659 // INITIATE RECOVERY
\r
662 else if (scsiDev.msgOut == 0x10)
\r
664 // RELEASE RECOVERY
\r
668 else if (scsiDev.msgOut == MSG_REJECT)
\r
672 scsiDev.resetFlag = 1;
\r
674 else if (scsiDev.msgOut == 0x08)
\r
678 else if (scsiDev.msgOut == 0x09)
\r
680 // Message Parity Error
\r
681 // Go back and re-send the last message.
\r
682 scsiDev.phase = MESSAGE_IN;
\r
684 else if (scsiDev.msgOut & 0x80) // 0x80 -> 0xFF
\r
687 if ((scsiDev.msgOut & 0x18) || // Reserved bits set.
\r
688 (scsiDev.msgOut & 0x20)) // We don't have any target routines!
\r
693 scsiDev.lun = scsiDev.msgOut & 0x7;
\r
694 scsiDev.discPriv =
\r
695 ((scsiDev.msgOut & 0x40) && (scsiDev.initiatorId >= 0))
\r
698 else if (scsiDev.msgOut >= 0x20 && scsiDev.msgOut <= 0x2F)
\r
700 // Two byte message. We don't support these. read and discard.
\r
703 else if (scsiDev.msgOut == 0x01)
\r
707 // Extended message.
\r
708 int msgLen = scsiReadByte();
\r
709 if (msgLen == 0) msgLen = 256;
\r
710 uint8_t extmsg[256];
\r
711 for (i = 0; i < msgLen && !scsiDev.resetFlag; ++i)
\r
714 extmsg[i] = scsiReadByte();
\r
717 if (extmsg[0] == 3 && msgLen == 2) // Wide Data Request
\r
719 // Negotiate down to 8bit
\r
720 scsiEnterPhase(MESSAGE_IN);
\r
721 static const uint8_t WDTR[] = {0x01, 0x02, 0x03, 0x00};
\r
722 scsiWrite(WDTR, sizeof(WDTR));
\r
724 else if (extmsg[0] == 1 && msgLen == 5) // Synchronous data request
\r
726 // Negotiate back to async
\r
727 scsiEnterPhase(MESSAGE_IN);
\r
728 static const uint8_t SDTR[] = {0x01, 0x03, 0x01, 0x00, 0x00};
\r
729 scsiWrite(SDTR, sizeof(SDTR));
\r
742 // Re-check the ATN flag in case it stays asserted.
\r
743 scsiDev.atnFlag |= SCSI_ReadFilt(SCSI_Filt_ATN);
\r
746 void scsiPoll(void)
\r
748 if (unlikely(scsiDev.resetFlag))
\r
751 if ((scsiDev.resetFlag = SCSI_ReadFilt(SCSI_Filt_RST)))
\r
753 // Still in reset phase. Do not try and process any commands.
\r
758 switch (scsiDev.phase)
\r
761 if (SCSI_ReadFilt(SCSI_Filt_BSY))
\r
763 scsiDev.phase = BUS_BUSY;
\r
765 // The Arbitration phase is optional for SCSI1/SASI hosts if there is only
\r
766 // one initiator in the chain. Support this by moving
\r
767 // straight to selection if SEL is asserted.
\r
768 // ie. the initiator won't assert BSY and it's own ID before moving to selection.
\r
769 else if (SCSI_ReadFilt(SCSI_Filt_SEL))
\r
771 enter_SelectionPhase();
\r
776 // Someone is using the bus. Perhaps they are trying to
\r
778 if (SCSI_ReadFilt(SCSI_Filt_SEL))
\r
780 enter_SelectionPhase();
\r
782 else if (!SCSI_ReadFilt(SCSI_Filt_BSY))
\r
784 scsiDev.phase = BUS_FREE;
\r
789 // TODO Support reselection.
\r
793 process_SelectionPhase();
\r
797 // Not currently supported!
\r
801 // Do not check ATN here. SCSI 1 & 2 initiators must set ATN
\r
802 // and SEL together upon entering the selection phase if they
\r
803 // want to send a message (IDENTIFY) immediately.
\r
804 if (scsiDev.atnFlag)
\r
806 process_MessageOut();
\r
815 scsiDev.atnFlag |= SCSI_ReadFilt(SCSI_Filt_ATN);
\r
816 if (scsiDev.atnFlag)
\r
818 process_MessageOut();
\r
827 scsiDev.atnFlag |= SCSI_ReadFilt(SCSI_Filt_ATN);
\r
828 if (scsiDev.atnFlag)
\r
830 process_MessageOut();
\r
839 scsiDev.atnFlag |= SCSI_ReadFilt(SCSI_Filt_ATN);
\r
840 if (scsiDev.atnFlag)
\r
842 process_MessageOut();
\r
851 scsiDev.atnFlag |= SCSI_ReadFilt(SCSI_Filt_ATN);
\r
852 if (scsiDev.atnFlag)
\r
854 process_MessageOut();
\r
858 process_MessageIn();
\r
864 process_MessageOut();
\r
871 scsiDev.atnFlag = 0;
\r
872 scsiDev.resetFlag = 1;
\r
873 scsiDev.phase = BUS_FREE;
\r
874 scsiDev.target = NULL;
\r
877 for (i = 0; i < MAX_SCSI_TARGETS; ++i)
\r
879 const TargetConfig* cfg = getConfigByIndex(i);
\r
880 if (cfg && (cfg->scsiId & CONFIG_TARGET_ENABLED))
\r
882 scsiDev.targets[i].targetId = cfg->scsiId & CONFIG_TARGET_ID_BITS;
\r
883 scsiDev.targets[i].cfg = cfg;
\r
885 scsiDev.targets[i].liveCfg.bytesPerSector = cfg->bytesPerSector;
\r
889 scsiDev.targets[i].targetId = 0xff;
\r
890 scsiDev.targets[i].cfg = NULL;
\r
892 scsiDev.targets[i].reservedId = -1;
\r
893 scsiDev.targets[i].reserverId = -1;
\r
894 scsiDev.targets[i].unitAttention = POWER_ON_RESET;
\r
895 scsiDev.targets[i].sense.code = NO_SENSE;
\r
896 scsiDev.targets[i].sense.asc = NO_ADDITIONAL_SENSE_INFORMATION;
\r
900 void scsiDisconnect()
\r
902 scsiEnterPhase(MESSAGE_IN);
\r
903 scsiWriteByte(0x02); // save data pointer
\r
904 scsiWriteByte(0x04); // disconnect msg.
\r
906 // For now, the caller is responsible for tracking the disconnected
\r
907 // state, and calling scsiReconnect.
\r
908 // Ideally the client would exit their loop and we'd implement this
\r
909 // as part of scsiPoll
\r
910 int phase = scsiDev.phase;
\r
912 scsiDev.phase = phase;
\r
915 int scsiReconnect()
\r
917 int reconnected = 0;
\r
919 int sel = SCSI_ReadFilt(SCSI_Filt_SEL);
\r
920 int bsy = SCSI_ReadFilt(SCSI_Filt_BSY);
\r
924 sel = SCSI_ReadFilt(SCSI_Filt_SEL);
\r
925 bsy = SCSI_ReadFilt(SCSI_Filt_BSY);
\r
932 uint8_t scsiIdMask = 1 << scsiDev.target->targetId;
\r
933 SCSI_Out_Bits_Write(scsiIdMask);
\r
934 SCSI_Out_Ctl_Write(1); // Write bits manually.
\r
935 SCSI_SetPin(SCSI_Out_BSY);
\r
937 CyDelayUs(3); // arbitrate delay. 2.4us.
\r
939 uint8_t dbx = scsiReadDBxPins();
\r
940 sel = SCSI_ReadFilt(SCSI_Filt_SEL);
\r
941 if (sel || ((dbx ^ scsiIdMask) > scsiIdMask))
\r
943 // Lost arbitration.
\r
944 SCSI_Out_Ctl_Write(0);
\r
945 SCSI_ClearPin(SCSI_Out_BSY);
\r
951 SCSI_SetPin(SCSI_Out_SEL);
\r
952 CyDelayUs(1); // Bus clear + Bus settle.
\r
954 // Reselection phase
\r
955 SCSI_CTL_PHASE_Write(__scsiphase_io);
\r
956 SCSI_Out_Bits_Write(scsiIdMask | (1 << scsiDev.initiatorId));
\r
957 scsiDeskewDelay(); // 2 deskew delays
\r
958 scsiDeskewDelay(); // 2 deskew delays
\r
959 SCSI_ClearPin(SCSI_Out_BSY);
\r
960 CyDelayUs(1); // Bus Settle Delay
\r
962 uint32_t waitStart_ms = getTime_ms();
\r
963 bsy = SCSI_ReadFilt(SCSI_Filt_BSY);
\r
964 // Wait for initiator.
\r
967 !scsiDev.resetFlag &&
\r
968 (elapsedTime_ms(waitStart_ms) < 250))
\r
970 bsy = SCSI_ReadFilt(SCSI_Filt_BSY);
\r
975 SCSI_SetPin(SCSI_Out_BSY);
\r
976 scsiDeskewDelay(); // 2 deskew delays
\r
977 scsiDeskewDelay(); // 2 deskew delays
\r
978 SCSI_ClearPin(SCSI_Out_SEL);
\r
980 // Prepare for the initial IDENTIFY message.
\r
981 SCSI_Out_Ctl_Write(0);
\r
982 scsiEnterPhase(MESSAGE_IN);
\r
984 // Send identify command
\r
985 scsiWriteByte(0x80);
\r
987 scsiEnterPhase(scsiDev.phase);
\r
992 // reselect timeout.
\r
993 SCSI_Out_Ctl_Write(0);
\r
994 SCSI_ClearPin(SCSI_Out_SEL);
\r
995 SCSI_CTL_PHASE_Write(0);
\r
1000 return reconnected;
\r
1003 #pragma GCC pop_options
\r