/* Copyright(c) 2000, Compaq Computer Corporation * Fibre Channel Host Bus Adapter * 64-bit, 66MHz PCI * Originally developed and tested on: * (front): [chip] Tachyon TS HPFC-5166A/1.2 L2C1090 ... * SP# P225CXCBFIEL6T, Rev XC * SP# 161290-001, Rev XD * (back): Board No. 010008-001 A/W Rev X5, FAB REV X5 * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License as published by the * Free Software Foundation; either version 2, or (at your option) any * later version. * * This program is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * General Public License for more details. * Written by Don Zimmerman */ #include <linux/sched.h> #include <linux/timer.h> #include <linux/string.h> #include <linux/slab.h> #include <linux/ioport.h> #include <linux/kernel.h> #include <linux/stat.h> #include <linux/blkdev.h> #include <linux/interrupt.h> #include <linux/delay.h> #include <linux/smp_lock.h> #include <linux/pci.h> #define SHUTDOWN_SIGS (sigmask(SIGKILL)|sigmask(SIGINT)|sigmask(SIGTERM)) #include <asm/system.h> #include <asm/irq.h> #include <asm/dma.h> #include "scsi.h" #include <scsi/scsi_host.h> // struct Scsi_Host definition for T handler #include "cpqfcTSchip.h" #include "cpqfcTSstructs.h" #include "cpqfcTStrigger.h" //#define LOGIN_DBG 1 // REMARKS: // Since Tachyon chips may be permitted to wait from 500ms up to 2 sec // to empty an outgoing frame from its FIFO to the Fibre Channel stream, // we cannot do everything we need to in the interrupt handler. Specifically, // every time a link re-init (e.g. LIP) takes place, all SCSI I/O has to be // suspended until the login sequences have been completed. Login commands // are frames just like SCSI commands are frames; they are subject to the same // timeout issues and delays. Also, various specs provide up to 2 seconds for // devices to log back in (i.e. respond with ACC to a login frame), so I/O to // that device has to be suspended. // A serious problem here occurs on highly loaded FC-AL systems. If our FC port // has a low priority (e.g. high arbitrated loop physical address, alpa), and // some other device is hogging bandwidth (permissible under FC-AL), we might // time out thinking the link is hung, when it's simply busy. Many such // considerations complicate the design. Although Tachyon assumes control // (in silicon) for many link-specific issues, the Linux driver is left with the // rest, which turns out to be a difficult, time critical chore. // These "worker" functions will handle things like FC Logins; all // processes with I/O to our device must wait for the Login to complete // and (if successful) I/O to resume. In the event of a malfunctioning or // very busy loop, it may take hundreds of millisecs or even seconds to complete // a frame send. We don't want to hang up the entire server (and all // processes which don't depend on Fibre) during this wait. // The Tachyon chip can have around 30,000 I/O operations ("exchanges") // open at one time. However, each exchange must be initiated // synchronously (i.e. each of the 30k I/O had to be started one at a // time by sending a starting frame via Tachyon's outbound que). // To accommodate kernel "module" build, this driver limits the exchanges // to 256, because of the contiguous physical memory limitation of 128M. // Typical FC Exchanges are opened presuming the FC frames start without errors, // while Exchange completion is handled in the interrupt handler. This // optimizes performance for the "everything's working" case. // However, when we have FC related errors or hot plugging of FC ports, we pause // I/O and handle FC-specific tasks in the worker thread. These FC-specific // functions will handle things like FC Logins and Aborts. As the Login sequence // completes to each and every target, I/O can resume to that target. // Our kernel "worker thread" must share the HBA with threads calling // "queuecommand". We define a "BoardLock" semaphore which indicates // to "queuecommand" that the HBA is unavailable, and Cmnds are added to a // board lock Q. When the worker thread finishes with the board, the board // lock Q commands are completed with status causing immediate retry. // Typically, the board is locked while Logins are in progress after an // FC Link Down condition. When Cmnds are re-queued after board lock, the // particular Scsi channel/target may or may not have logged back in. When // the device is waiting for login, the "prli" flag is clear, in which case // commands are passed to a Link Down Q. Whenever the login finally completes, // the LinkDown Q is completed, again with status causing immediate retry. // When FC devices are logged in, we build and start FC commands to the // devices. // NOTE!! As of May 2000, kernel 2.2.14, the error recovery logic for devices // that never log back in (e.g. physically removed) is NOT completely // understood. I've still seen instances of system hangs on failed Write // commands (possibly from the ext2 layer?) on device removal. Such special // cases need to be evaluated from a system/application view - e.g., how // exactly does the system want me to complete commands when the device is // physically removed?? // local functions static void SetLoginFields( PFC_LOGGEDIN_PORT pLoggedInPort, TachFCHDR_GCMND* fchs, BOOLEAN PDisc, BOOLEAN Originator); static void AnalyzeIncomingFrame( CPQFCHBA *cpqfcHBAdata, ULONG QNdx ); static void SendLogins( CPQFCHBA *cpqfcHBAdata, __u32 *FabricPortIds ); static int verify_PLOGI( PTACHYON fcChip, TachFCHDR_GCMND* fchs, ULONG* reject_explain); static int verify_PRLI( TachFCHDR_GCMND* fchs, ULONG* reject_explain); static void LoadWWN( PTACHYON fcChip, UCHAR* dest, UCHAR type); static void BuildLinkServicePayload( PTACHYON fcChip, ULONG type, void* payload); static void UnblockScsiDevice( struct Scsi_Host *HostAdapter, PFC_LOGGEDIN_PORT pLoggedInPort); static void cpqfcTSCheckandSnoopFCP( PTACHYON fcChip, ULONG x_ID); static void CompleteBoardLockCmnd( CPQFCHBA *cpqfcHBAdata); static void RevalidateSEST( struct Scsi_Host *HostAdapter, PFC_LOGGEDIN_PORT pLoggedInPort); static void IssueReportLunsCommand( CPQFCHBA* cpqfcHBAdata, TachFCHDR_GCMND* fchs); // (see scsi_error.c comments on kernel task creation) void cpqfcTSWorkerThread( void *host) { struct Scsi_Host *HostAdapter = (struct Scsi_Host*)host; CPQFCHBA *cpqfcHBAdata = (CPQFCHBA *)HostAdapter->hostdata; #ifdef PCI_KERNEL_TRACE PTACHYON fcChip = &cpqfcHBAdata->fcChip; #endif DECLARE_MUTEX_LOCKED(fcQueReady); DECLARE_MUTEX_LOCKED(fcTYOBcomplete); DECLARE_MUTEX_LOCKED(TachFrozen); DECLARE_MUTEX_LOCKED(BoardLock); ENTER("WorkerThread"); lock_kernel(); daemonize("cpqfcTS_wt_%d", HostAdapter->host_no); siginitsetinv(¤t->blocked, SHUTDOWN_SIGS); cpqfcHBAdata->fcQueReady = &fcQueReady; // primary wait point cpqfcHBAdata->TYOBcomplete = &fcTYOBcomplete; cpqfcHBAdata->TachFrozen = &TachFrozen; cpqfcHBAdata->worker_thread = current; unlock_kernel(); if( cpqfcHBAdata->notify_wt != NULL ) up( cpqfcHBAdata->notify_wt); // OK to continue while(1) { unsigned long flags; down_interruptible( &fcQueReady); // wait for something to do if (signal_pending(current) ) break; PCI_TRACE( 0x90) // first, take the IO lock so the SCSI upper layers can't call // into our _quecommand function (this also disables INTs) spin_lock_irqsave( HostAdapter->host_lock, flags); // STOP _que function PCI_TRACE( 0x90) CPQ_SPINLOCK_HBA( cpqfcHBAdata) // next, set this pointer to indicate to the _quecommand function // that the board is in use, so it should que the command and // immediately return (we don't actually require the semaphore function // in this driver rev) cpqfcHBAdata->BoardLock = &BoardLock; PCI_TRACE( 0x90) // release the IO lock (and re-enable interrupts) spin_unlock_irqrestore( HostAdapter->host_lock, flags); // disable OUR HBA interrupt (keep them off as much as possible // during error recovery) disable_irq( cpqfcHBAdata->HostAdapter->irq); // OK, let's process the Fibre Channel Link Q and do the work cpqfcTS_WorkTask( HostAdapter); // hopefully, no more "work" to do; // re-enable our INTs for "normal" completion processing enable_irq( cpqfcHBAdata->HostAdapter->irq); cpqfcHBAdata->BoardLock = NULL; // allow commands to be queued CPQ_SPINUNLOCK_HBA( cpqfcHBAdata) // Now, complete any Cmnd we Q'd up while BoardLock was held CompleteBoardLockCmnd( cpqfcHBAdata); } // hopefully, the signal was for our module exit... if( cpqfcHBAdata->notify_wt != NULL ) up( cpqfcHBAdata->notify_wt); // yep, we're outta here } // Freeze Tachyon routine. // If Tachyon is already frozen, return FALSE // If Tachyon is not frozen, call freeze function, return TRUE // static BOOLEAN FreezeTach( CPQFCHBA *cpqfcHBAdata) { PTACHYON fcChip = &cpqfcHBAdata->fcChip; BOOLEAN FrozeTach = FALSE; // It's possible that the chip is already frozen; if so, // "Freezing" again will NOT! generate another Freeze // Completion Message. if( (fcChip->Registers.TYstatus.value & 0x70000) != 0x70000) { // (need to freeze...) fcChip->FreezeTachyon( fcChip, 2); // both ERQ and FCP assists // 2. Get Tach freeze confirmation // (synchronize SEST manipulation with Freeze Completion Message) // we need INTs on so semaphore can be set. enable_irq( cpqfcHBAdata->HostAdapter->irq); // only way to get Semaphore down_interruptible( cpqfcHBAdata->TachFrozen); // wait for INT handler sem. // can we TIMEOUT semaphore wait?? TBD disable_irq( cpqfcHBAdata->HostAdapter->irq); FrozeTach = TRUE; } // (else, already frozen) return FrozeTach; } // This is the kernel worker thread task, which processes FC // tasks which were queued by the Interrupt handler or by // other WorkTask functions. #define DBG 1 //#undef DBG void cpqfcTS_WorkTask( struct Scsi_Host *HostAdapter) { CPQFCHBA *cpqfcHBAdata = (CPQFCHBA *)HostAdapter->hostdata; PTACHYON fcChip = &cpqfcHBAdata->fcChip; FC_EXCHANGES *Exchanges = fcChip->Exchanges; ULONG QconsumerNdx; LONG ExchangeID; ULONG ulStatus=0; TachFCHDR_GCMND fchs; PFC_LINK_QUE fcLQ = cpqfcHBAdata->fcLQ; ENTER("WorkTask"); // copy current index to work on QconsumerNdx = fcLQ->consumer; PCI_TRACEO( fcLQ->Qitem[QconsumerNdx].Type, 0x90) // NOTE: when this switch completes, we will "consume" the Que item // printk("Que type %Xh\n", fcLQ->Qitem[QconsumerNdx].Type); switch( fcLQ->Qitem[QconsumerNdx].Type ) { // incoming frame - link service (ACC, UNSOL REQ, etc.) // or FCP-SCSI command case SFQ_UNKNOWN: AnalyzeIncomingFrame( cpqfcHBAdata, QconsumerNdx ); break; case EXCHANGE_QUEUED: // an Exchange (i.e. FCP-SCSI) was previously // Queued because the link was down. The // heartbeat timer detected it and Queued it here. // We attempt to start it again, and if // successful we clear the EXCHANGE_Q flag. // If the link doesn't come up, the Exchange // will eventually time-out. ExchangeID = (LONG) // x_ID copied from DPC timeout function fcLQ->Qitem[QconsumerNdx].ulBuff[0]; // It's possible that a Q'd exchange could have already // been started by other logic (e.g. ABTS process) // Don't start if already started (Q'd flag clear) if( Exchanges->fcExchange[ExchangeID].status & EXCHANGE_QUEUED ) { // printk(" *Start Q'd x_ID %Xh: type %Xh ", // ExchangeID, Exchanges->fcExchange[ExchangeID].type); ulStatus = cpqfcTSStartExchange( cpqfcHBAdata, ExchangeID); if( !ulStatus ) { // printk("success* "); } else { #ifdef DBG if( ulStatus == EXCHANGE_QUEUED) printk("Queued* "); else printk("failed* "); #endif } } break; case LINKDOWN: // (lots of things already done in INT handler) future here? break; case LINKACTIVE: // Tachyon set the Lup bit in FM status // NOTE: some misbehaving FC ports (like Tach2.1) // can re-LIP immediately after a LIP completes. // if "initiator", need to verify LOGs with ports // printk("\n*LNKUP* "); if( fcChip->Options.initiator ) SendLogins( cpqfcHBAdata, NULL ); // PLOGI or PDISC, based on fcPort data // if SendLogins successfully completes, PortDiscDone // will be set. // If SendLogins was successful, then we expect to get incoming // ACCepts or REJECTs, which are handled below. break; // LinkService and Fabric request/reply processing case ELS_FDISC: // need to send Fabric Discovery (Login) case ELS_FLOGI: // need to send Fabric Login case ELS_SCR: // need to send State Change Registration case FCS_NSR: // need to send Name Service Request case ELS_PLOGI: // need to send PLOGI case ELS_ACC: // send generic ACCept case ELS_PLOGI_ACC: // need to send ELS ACCept frame to recv'd PLOGI case ELS_PRLI_ACC: // need to send ELS ACCept frame to recv'd PRLI case ELS_LOGO: // need to send ELS LOGO (logout) case ELS_LOGO_ACC: // need to send ELS ACCept frame to recv'd PLOGI case ELS_RJT: // ReJecT reply case ELS_PRLI: // need to send ELS PRLI // printk(" *ELS %Xh* ", fcLQ->Qitem[QconsumerNdx].Type); // if PortDiscDone is not set, it means the SendLogins routine // failed to complete -- assume that LDn occurred, so login frames // are invalid if( !cpqfcHBAdata->PortDiscDone) // cleared by LDn { printk("Discard Q'd ELS login frame\n"); break; } ulStatus = cpqfcTSBuildExchange( cpqfcHBAdata, fcLQ->Qitem[QconsumerNdx].Type, // e.g. PLOGI (TachFCHDR_GCMND*) fcLQ->Qitem[QconsumerNdx].ulBuff, // incoming fchs NULL, // no data (no scatter/gather list) &ExchangeID );// fcController->fcExchanges index, -1 if failed if( !ulStatus ) // Exchange setup? { ulStatus = cpqfcTSStartExchange( cpqfcHBAdata, ExchangeID ); if( !ulStatus ) { // submitted to Tach's Outbound Que (ERQ PI incremented) // waited for completion for ELS type (Login frames issued // synchronously) } else // check reason for Exchange not being started - we might // want to Queue and start later, or fail with error { } } else // Xchange setup failed... printk(" cpqfcTSBuildExchange failed: %Xh\n", ulStatus ); break; case SCSI_REPORT_LUNS: // pass the incoming frame (actually, it's a PRLI frame) // so we can send REPORT_LUNS, in order to determine VSA/PDU // FCP-SCSI Lun address mode IssueReportLunsCommand( cpqfcHBAdata, (TachFCHDR_GCMND*) fcLQ->Qitem[QconsumerNdx].ulBuff); break; case BLS_ABTS: // need to ABORT one or more exchanges { LONG x_ID = fcLQ->Qitem[QconsumerNdx].ulBuff[0]; BOOLEAN FrozeTach = FALSE; if ( x_ID >= TACH_SEST_LEN ) // (in)sanity check { // printk( " cpqfcTS ERROR! BOGUS x_ID %Xh", x_ID); break; } if( Exchanges->fcExchange[ x_ID].Cmnd == NULL ) // should be RARE { // printk(" ABTS %Xh Scsi Cmnd null! ", x_ID); break; // nothing to abort! } //#define ABTS_DBG #ifdef ABTS_DBG printk("INV SEST[%X] ", x_ID); if( Exchanges->fcExchange[x_ID].status & FC2_TIMEOUT) { printk("FC2TO"); } if( Exchanges->fcExchange[x_ID].status & INITIATOR_ABORT) { printk("IA"); } if( Exchanges->fcExchange[x_ID].status & PORTID_CHANGED) { printk("PORTID"); } if( Exchanges->fcExchange[x_ID].status & DEVICE_REMOVED) { printk("DEVRM"); } if( Exchanges->fcExchange[x_ID].status & LINKFAIL_TX) { printk("LKF"); } if( Exchanges->fcExchange[x_ID].status & FRAME_TO) { printk("FRMTO"); } if( Exchanges->fcExchange[x_ID].status & ABORTSEQ_NOTIFY) { printk("ABSQ"); } if( Exchanges->fcExchange[x_ID].status & SFQ_FRAME) { printk("SFQFR"); } if( Exchanges->fcExchange[ x_ID].type == 0x2000) printk(" WR"); else if( Exchanges->fcExchange[ x_ID].type == 0x3000) printk(" RD"); else if( Exchanges->fcExchange[ x_ID].type == 0x10) printk(" ABTS"); else printk(" %Xh", Exchanges->fcExchange[ x_ID].type); if( !(Exchanges->fcExchange[x_ID].status & INITIATOR_ABORT)) { printk(" Cmd %p, ", Exchanges->fcExchange[ x_ID].Cmnd); printk(" brd/chn/trg/lun %d/%d/%d/%d port_id %06X\n", cpqfcHBAdata->HBAnum, Exchanges->fcExchange[ x_ID].Cmnd->channel, Exchanges->fcExchange[ x_ID].Cmnd->target, Exchanges->fcExchange[ x_ID].Cmnd->lun, Exchanges->fcExchange[ x_ID].fchs.d_id & 0xFFFFFF); } else // assume that Cmnd ptr is invalid on _abort() { printk(" Cmd ptr invalid\n"); } #endif // Steps to ABORT a SEST exchange: // 1. Freeze TL SCSI assists & ERQ (everything) // 2. Receive FROZEN inbound CM (must succeed!) // 3. Invalidate x_ID SEST entry // 4. Resume TL SCSI assists & ERQ (everything) // 5. Build/start on exchange - change "type" to BLS_ABTS, // timeout to X sec (RA_TOV from PLDA is actually 0) // 6. Set Exchange Q'd status if ABTS cannot be started, // or simply complete Exchange in "Terminate" condition PCI_TRACEO( x_ID, 0xB4) // 1 & 2 . Freeze Tach & get confirmation of freeze FrozeTach = FreezeTach( cpqfcHBAdata); // 3. OK, Tachyon is frozen, so we can invalidate SEST exchange. // FC2_TIMEOUT means we are originating the abort, while // TARGET_ABORT means we are ACCepting an abort. // LINKFAIL_TX, ABORTSEQ_NOFITY, INV_ENTRY or FRAME_TO are // all from Tachyon: // Exchange was corrupted by LDn or other FC physical failure // INITIATOR_ABORT means the upper layer driver/application // requested the abort. // clear bit 31 (VALid), to invalidate & take control from TL fcChip->SEST->u[ x_ID].IWE.Hdr_Len &= 0x7FFFFFFF; // examine and Tach's "Linked List" for IWEs that // received (nearly) simultaneous transfer ready (XRDY) // repair linked list if necessary (TBD!) // (If we ignore the "Linked List", we will time out // WRITE commands where we received the FCP-SCSI XFRDY // frame (because Tachyon didn't processes it). Linked List // management should be done as an optimization. // readl( fcChip->Registers.ReMapMemBase+TL_MEM_SEST_LINKED_LIST )); // 4. Resume all Tachlite functions (for other open Exchanges) // as quickly as possible to allow other exchanges to other ports // to resume. Freezing Tachyon may cause cascading errors, because // any received SEST frame cannot be processed by the SEST. // Don't "unfreeze" unless Link is operational if( FrozeTach ) // did we just freeze it (above)? fcChip->UnFreezeTachyon( fcChip, 2); // both ERQ and FCP assists PCI_TRACEO( x_ID, 0xB4) // Note there is no confirmation that the chip is "unfrozen". Also, // if the Link is down when unfreeze is called, it has no effect. // Chip will unfreeze when the Link is back up. // 5. Now send out Abort commands if possible // Some Aborts can't be "sent" (Port_id changed or gone); // if the device is gone, there is no port_id to send the ABTS to. if( !(Exchanges->fcExchange[ x_ID].status & PORTID_CHANGED) && !(Exchanges->fcExchange[ x_ID].status & DEVICE_REMOVED) ) { Exchanges->fcExchange[ x_ID].type = BLS_ABTS; fchs.s_id = Exchanges->fcExchange[ x_ID].fchs.d_id; ulStatus = cpqfcTSBuildExchange( cpqfcHBAdata, BLS_ABTS, &fchs, // (uses only s_id) NULL, // (no scatter/gather list for ABTS) &x_ID );// ABTS on this Exchange ID if( !ulStatus ) // Exchange setup build OK? { // ABTS may be needed because an Exchange was corrupted // by a Link disruption. If the Link is UP, we can // presume that this ABTS can start immediately; otherwise, // set Que'd status so the Login functions // can restart it when the FC physical Link is restored if( ((fcChip->Registers.FMstatus.value &0xF0) &0x80)) // loop init? { // printk(" *set Q status x_ID %Xh on LDn* ", x_ID); Exchanges->fcExchange[ x_ID].status |= EXCHANGE_QUEUED; } else // what FC device (port_id) does the Cmd belong to? { PFC_LOGGEDIN_PORT pLoggedInPort = Exchanges->fcExchange[ x_ID].pLoggedInPort; // if Port is logged in, we might start the abort. if( (pLoggedInPort != NULL) && (pLoggedInPort->prli == TRUE) ) { // it's possible that an Exchange has already been Queued // to start after Login completes. Check and don't // start it (again) here if Q'd status set // printk(" ABTS xchg %Xh ", x_ID); if( Exchanges->fcExchange[x_ID].status & EXCHANGE_QUEUED) { // printk("already Q'd "); } else { // printk("starting "); fcChip->fcStats.FC2aborted++; ulStatus = cpqfcTSStartExchange( cpqfcHBAdata, x_ID ); if( !ulStatus ) { // OK // submitted to Tach's Outbound Que (ERQ PI incremented) } else { /* printk("ABTS exchange start failed -status %Xh, x_ID %Xh ", ulStatus, x_ID); */ } } } else { /* printk(" ABTS NOT starting xchg %Xh, %p ", x_ID, pLoggedInPort); if( pLoggedInPort ) printk("prli %d ", pLoggedInPort->prli); */ } } } else // what the #@! { // how do we fail to build an Exchange for ABTS?? printk("ABTS exchange build failed -status %Xh, x_ID %Xh\n", ulStatus, x_ID); } } else // abort without ABTS -- just complete exchange/Cmnd to Linux { // printk(" *Terminating x_ID %Xh on %Xh* ", // x_ID, Exchanges->fcExchange[x_ID].status); cpqfcTSCompleteExchange( cpqfcHBAdata->PciDev, fcChip, x_ID); } } // end of ABTS case break; case BLS_ABTS_ACC: // need to ACCept one ABTS // (NOTE! this code not updated for Linux yet..) printk(" *ABTS_ACC* "); // 1. Freeze TL fcChip->FreezeTachyon( fcChip, 2); // both ERQ and FCP assists memcpy( // copy the incoming ABTS frame &fchs, fcLQ->Qitem[QconsumerNdx].ulBuff, // incoming fchs sizeof( fchs)); // 3. OK, Tachyon is frozen so we can invalidate SEST entry // (if necessary) // Status FC2_TIMEOUT means we are originating the abort, while // TARGET_ABORT means we are ACCepting an abort ExchangeID = fchs.ox_rx_id & 0x7FFF; // RX_ID for exchange // printk("ABTS ACC for Target ExchangeID %Xh\n", ExchangeID); // sanity check on received ExchangeID if( Exchanges->fcExchange[ ExchangeID].status == TARGET_ABORT ) { // clear bit 31 (VALid), to invalidate & take control from TL // printk("Invalidating SEST exchange %Xh\n", ExchangeID); fcChip->SEST->u[ ExchangeID].IWE.Hdr_Len &= 0x7FFFFFFF; } // 4. Resume all Tachlite functions (for other open Exchanges) // as quickly as possible to allow other exchanges to other ports // to resume. Freezing Tachyon for too long may royally screw // up everything! fcChip->UnFreezeTachyon( fcChip, 2); // both ERQ and FCP assists // Note there is no confirmation that the chip is "unfrozen". Also, // if the Link is down when unfreeze is called, it has no effect. // Chip will unfreeze when the Link is back up. // 5. Now send out Abort ACC reply for this exchange Exchanges->fcExchange[ ExchangeID].type = BLS_ABTS_ACC; fchs.s_id = Exchanges->fcExchange[ ExchangeID].fchs.d_id; ulStatus = cpqfcTSBuildExchange( cpqfcHBAdata, BLS_ABTS_ACC, &fchs, NULL, // no data (no scatter/gather list) &ExchangeID );// fcController->fcExchanges index, -1 if failed if( !ulStatus ) // Exchange setup? { ulStatus = cpqfcTSStartExchange( cpqfcHBAdata, ExchangeID ); if( !ulStatus ) { // submitted to Tach's Outbound Que (ERQ PI incremented) // waited for completion for ELS type (Login frames issued // synchronously) } else // check reason for Exchange not being started - we might // want to Queue and start later, or fail with error { } } break; case BLS_ABTS_RJT: // need to ReJecT one ABTS; reject implies the // exchange doesn't exist in the TARGET context. // ExchangeID has to come from LinkService space. printk(" *ABTS_RJT* "); ulStatus = cpqfcTSBuildExchange( cpqfcHBAdata, BLS_ABTS_RJT, (TachFCHDR_GCMND*) fcLQ->Qitem[QconsumerNdx].ulBuff, // incoming fchs NULL, // no data (no scatter/gather list) &ExchangeID );// fcController->fcExchanges index, -1 if failed if( !ulStatus ) // Exchange setup OK? { ulStatus = cpqfcTSStartExchange( cpqfcHBAdata, ExchangeID ); // If it fails, we aren't required to retry. } if( ulStatus ) { printk("Failed to send BLS_RJT for ABTS, X_ID %Xh\n", ExchangeID); } else { printk("Sent BLS_RJT for ABTS, X_ID %Xh\n", ExchangeID); } break; default: break; } // end switch //doNothing: // done with this item - now set the NEXT index if( QconsumerNdx+1 >= FC_LINKQ_DEPTH ) // rollover test { fcLQ->consumer = 0; } else { fcLQ->consumer++; } PCI_TRACEO( fcLQ->Qitem[QconsumerNdx].Type, 0x94) LEAVE("WorkTask"); return; } // When Tachyon reports link down, bad al_pa, or Link Service (e.g. Login) // commands come in, post to the LinkQ so that action can be taken outside the // interrupt handler. // This circular Q works like Tachyon's que - the producer points to the next // (unused) entry. Called by Interrupt handler, WorkerThread, Timer // sputlinkq void cpqfcTSPutLinkQue( CPQFCHBA *cpqfcHBAdata, int Type, void *QueContent) { PTACHYON fcChip = &cpqfcHBAdata->fcChip; // FC_EXCHANGES *Exchanges = fcChip->Exchanges; PFC_LINK_QUE fcLQ = cpqfcHBAdata->fcLQ; ULONG ndx; ENTER("cpqfcTSPutLinkQ"); ndx = fcLQ->producer; ndx += 1; // test for Que full if( ndx >= FC_LINKQ_DEPTH ) // rollover test ndx = 0; if( ndx == fcLQ->consumer ) // QUE full test { // QUE was full! lost LK command (fatal to logic) fcChip->fcStats.lnkQueFull++; printk("*LinkQ Full!*"); TriggerHBA( fcChip->Registers.ReMapMemBase, 1); /* { int i; printk("LinkQ PI %d, CI %d\n", fcLQ->producer, fcLQ->consumer); for( i=0; i< FC_LINKQ_DEPTH; ) { printk(" [%d]%Xh ", i, fcLQ->Qitem[i].Type); if( (++i %8) == 0) printk("\n"); } } */ printk( "cpqfcTS: WARNING!! PutLinkQue - FULL!\n"); // we're hung } else // QUE next element { // Prevent certain multiple (back-to-back) requests. // This is important in that we don't want to issue multiple // ABTS for the same Exchange, or do multiple FM inits, etc. // We can never be sure of the timing of events reported to // us by Tach's IMQ, which can depend on system/bus speeds, // FC physical link circumstances, etc. if( (fcLQ->producer != fcLQ->consumer) && (Type == FMINIT) ) { LONG lastNdx; // compute previous producer index if( fcLQ->producer) lastNdx = fcLQ->producer- 1; else lastNdx = FC_LINKQ_DEPTH-1; if( fcLQ->Qitem[lastNdx].Type == FMINIT) { // printk(" *skip FMINIT Q post* "); // goto DoneWithPutQ; } } // OK, add the Q'd item... fcLQ->Qitem[fcLQ->producer].Type = Type; memcpy( fcLQ->Qitem[fcLQ->producer].ulBuff, QueContent, sizeof(fcLQ->Qitem[fcLQ->producer].ulBuff)); fcLQ->producer = ndx; // increment Que producer // set semaphore to wake up Kernel (worker) thread // up( cpqfcHBAdata->fcQueReady ); } //DoneWithPutQ: LEAVE("cpqfcTSPutLinkQ"); } // reset device ext FC link Q void cpqfcTSLinkQReset( CPQFCHBA *cpqfcHBAdata) { PFC_LINK_QUE fcLQ = cpqfcHBAdata->fcLQ; fcLQ->producer = 0; fcLQ->consumer = 0; } // When Tachyon gets an unassisted FCP-SCSI frame, post here so // an arbitrary context thread (e.g. IOCTL loopback test function) // can process it. // (NOTE: Not revised for Linux) // This Q works like Tachyon's que - the producer points to the next // (unused) entry. void cpqfcTSPutScsiQue( CPQFCHBA *cpqfcHBAdata, int Type, void *QueContent) { // CPQFCHBA *cpqfcHBAdata = (CPQFCHBA *)HostAdapter->hostdata; // PTACHYON fcChip = &cpqfcHBAdata->fcChip; // ULONG ndx; // ULONG *pExchangeID; // LONG ExchangeID; /* KeAcquireSpinLockAtDpcLevel( &pDevExt->fcScsiQueLock); ndx = pDevExt->fcScsiQue.producer + 1; // test for Que full if( ndx >= FC_SCSIQ_DEPTH ) // rollover test ndx = 0; if( ndx == pDevExt->fcScsiQue.consumer ) // QUE full test { // QUE was full! lost LK command (fatal to logic) fcChip->fcStats.ScsiQueFull++; #ifdef DBG printk( "fcPutScsiQue - FULL!\n"); #endif } else // QUE next element { pDevExt->fcScsiQue.Qitem[pDevExt->fcScsiQue.producer].Type = Type; if( Type == FCP_RSP ) { // this TL inbound message type means that a TL SEST exchange has // copied an FCP response frame into a buffer pointed to by the SEST // entry. That buffer is allocated in the SEST structure at ->RspHDR. // Copy the RspHDR for use by the Que handler. pExchangeID = (ULONG *)QueContent; memcpy( pDevExt->fcScsiQue.Qitem[pDevExt->fcScsiQue.producer].ulBuff, &fcChip->SEST->RspHDR[ *pExchangeID ], sizeof(pDevExt->fcScsiQue.Qitem[0].ulBuff)); // (any element for size) } else { memcpy( pDevExt->fcScsiQue.Qitem[pDevExt->fcScsiQue.producer].ulBuff, QueContent, sizeof(pDevExt->fcScsiQue.Qitem[pDevExt->fcScsiQue.producer].ulBuff)); } pDevExt->fcScsiQue.producer = ndx; // increment Que KeSetEvent( &pDevExt->TYIBscsi, // signal any waiting thread 0, // no priority boost FALSE ); // no waiting later for this event } KeReleaseSpinLockFromDpcLevel( &pDevExt->fcScsiQueLock); */ } static void ProcessELS_Request( CPQFCHBA*,TachFCHDR_GCMND*); static void ProcessELS_Reply( CPQFCHBA*,TachFCHDR_GCMND*); static void ProcessFCS_Reply( CPQFCHBA*,TachFCHDR_GCMND*); void cpqfcTSImplicitLogout( CPQFCHBA* cpqfcHBAdata, PFC_LOGGEDIN_PORT pFcPort) { PTACHYON fcChip = &cpqfcHBAdata->fcChip; if( pFcPort->port_id != 0xFFFC01 ) // don't care about Fabric { fcChip->fcStats.logouts++; printk("cpqfcTS: Implicit logout of WWN %08X%08X, port_id %06X\n", (ULONG)pFcPort->u.liWWN, (ULONG)(pFcPort->u.liWWN >>32), pFcPort->port_id); // Terminate I/O with this (Linux) Scsi target cpqfcTSTerminateExchange( cpqfcHBAdata, &pFcPort->ScsiNexus, DEVICE_REMOVED); } // Do an "implicit logout" - we can't really Logout the device // (i.e. with LOGOut Request) because of port_id confusion // (i.e. the Other port has no port_id). // A new login for that WWN will have to re-write port_id (0 invalid) pFcPort->port_id = 0; // invalid! pFcPort->pdisc = FALSE; pFcPort->prli = FALSE; pFcPort->plogi = FALSE; pFcPort->flogi = FALSE; pFcPort->LOGO_timer = 0; pFcPort->device_blocked = TRUE; // block Scsi Requests pFcPort->ScsiNexus.VolumeSetAddressing=0; } // On FC-AL, there is a chance that a previously known device can // be quietly removed (e.g. with non-managed hub), // while a NEW device (with different WWN) took the same alpa or // even 24-bit port_id. This chance is unlikely but we must always // check for it. static void TestDuplicatePortId( CPQFCHBA* cpqfcHBAdata, PFC_LOGGEDIN_PORT pLoggedInPort) { PTACHYON fcChip = &cpqfcHBAdata->fcChip; // set "other port" at beginning of fcPorts list PFC_LOGGEDIN_PORT pOtherPortWithPortId = fcChip->fcPorts.pNextPort; while( pOtherPortWithPortId ) { if( (pOtherPortWithPortId->port_id == pLoggedInPort->port_id) && (pOtherPortWithPortId != pLoggedInPort) ) { // trouble! (Implicitly) Log the other guy out printk(" *port_id %Xh is duplicated!* ", pOtherPortWithPortId->port_id); cpqfcTSImplicitLogout( cpqfcHBAdata, pOtherPortWithPortId); } pOtherPortWithPortId = pOtherPortWithPortId->pNextPort; } } // Dynamic Memory Allocation for newly discovered FC Ports. // For simplicity, maintain fcPorts structs for ALL // for discovered devices, including those we never do I/O with // (e.g. Fabric addresses) static PFC_LOGGEDIN_PORT CreateFcPort( CPQFCHBA* cpqfcHBAdata, PFC_LOGGEDIN_PORT pLastLoggedInPort, TachFCHDR_GCMND* fchs, LOGIN_PAYLOAD* plogi) { PTACHYON fcChip = &cpqfcHBAdata->fcChip; PFC_LOGGEDIN_PORT pNextLoggedInPort = NULL; int i; printk("cpqfcTS: New FC port %06Xh WWN: ", fchs->s_id); for( i=3; i>=0; i--) // copy the LOGIN port's WWN printk("%02X", plogi->port_name[i]); for( i=7; i>3; i--) // copy the LOGIN port's WWN printk("%02X", plogi->port_name[i]); // allocate mem for new port // (these are small and rare allocations...) pNextLoggedInPort = kmalloc( sizeof( FC_LOGGEDIN_PORT), GFP_ATOMIC ); // allocation succeeded? Fill out NEW PORT if( pNextLoggedInPort ) { // clear out any garbage (sometimes exists) memset( pNextLoggedInPort, 0, sizeof( FC_LOGGEDIN_PORT)); // If we login to a Fabric, we don't want to treat it // as a SCSI device... if( (fchs->s_id & 0xFFF000) != 0xFFF000) { int i; // create a unique "virtual" SCSI Nexus (for now, just a // new target ID) -- we will update channel/target on REPORT_LUNS // special case for very first SCSI target... if( cpqfcHBAdata->HostAdapter->max_id == 0) { pNextLoggedInPort->ScsiNexus.target = 0; fcChip->fcPorts.ScsiNexus.target = -1; // don't use "stub" } else { pNextLoggedInPort->ScsiNexus.target = cpqfcHBAdata->HostAdapter->max_id; } // initialize the lun[] Nexus struct for lun masking for( i=0; i< CPQFCTS_MAX_LUN; i++) pNextLoggedInPort->ScsiNexus.lun[i] = 0xFF; // init to NOT USED pNextLoggedInPort->ScsiNexus.channel = 0; // cpqfcTS has 1 FC port printk(" SCSI Chan/Trgt %d/%d", pNextLoggedInPort->ScsiNexus.channel, pNextLoggedInPort->ScsiNexus.target); // tell Scsi layers about the new target... cpqfcHBAdata->HostAdapter->max_id++; // printk("HostAdapter->max_id = %d\n", // cpqfcHBAdata->HostAdapter->max_id); } else { // device is NOT SCSI (in case of Fabric) pNextLoggedInPort->ScsiNexus.target = -1; // invalid } // create forward link to new port pLastLoggedInPort->pNextPort = pNextLoggedInPort; printk("\n"); } return pNextLoggedInPort; // NULL on allocation failure } // end NEW PORT (WWN) logic // For certain cases, we want to terminate exchanges without // sending ABTS to the device. Examples include when an FC // device changed it's port_id after Loop re-init, or when // the device sent us a logout. In the case of changed port_id, // we want to complete the command and return SOFT_ERROR to // force a re-try. In the case of LOGOut, we might return // BAD_TARGET if the device is really gone. // Since we must ensure that Tachyon is not operating on the // exchange, we have to freeze the chip // sterminateex void cpqfcTSTerminateExchange( CPQFCHBA* cpqfcHBAdata, SCSI_NEXUS *ScsiNexus, int TerminateStatus) { PTACHYON fcChip = &cpqfcHBAdata->fcChip; FC_EXCHANGES *Exchanges = fcChip->Exchanges; ULONG x_ID; if( ScsiNexus ) { // printk("TerminateExchange: ScsiNexus chan/target %d/%d\n", // ScsiNexus->channel, ScsiNexus->target); } for( x_ID = 0; x_ID < TACH_SEST_LEN; x_ID++) { if( Exchanges->fcExchange[x_ID].type ) // in use? { if( ScsiNexus == NULL ) // our HBA changed - term. all { Exchanges->fcExchange[x_ID].status = TerminateStatus; cpqfcTSPutLinkQue( cpqfcHBAdata, BLS_ABTS, &x_ID ); } else { // If a device, according to WWN, has been removed, it's // port_id may be used by another working device, so we // have to terminate by SCSI target, NOT port_id. if( Exchanges->fcExchange[x_ID].Cmnd) // Cmnd in progress? { if( (Exchanges->fcExchange[x_ID].Cmnd->device->id == ScsiNexus->target) && (Exchanges->fcExchange[x_ID].Cmnd->device->channel == ScsiNexus->channel)) { Exchanges->fcExchange[x_ID].status = TerminateStatus; cpqfcTSPutLinkQue( cpqfcHBAdata, BLS_ABTS, &x_ID ); // timed-out } } // (in case we ever need it...) // all SEST structures have a remote node ID at SEST DWORD 2 // if( (fcChip->SEST->u[ x_ID ].TWE.Remote_Node_ID >> 8) // == port_id) } } } } static void ProcessELS_Request( CPQFCHBA* cpqfcHBAdata, TachFCHDR_GCMND* fchs) { PTACHYON fcChip = &cpqfcHBAdata->fcChip; // FC_EXCHANGES *Exchanges = fcChip->Exchanges; // ULONG ox_id = (fchs->ox_rx_id >>16); PFC_LOGGEDIN_PORT pLoggedInPort=NULL, pLastLoggedInPort; BOOLEAN NeedReject = FALSE; ULONG ls_reject_code = 0; // default don'n know?? // Check the incoming frame for a supported ELS type switch( fchs->pl[0] & 0xFFFF) { case 0x0050: // PDISC? // Payload for PLOGI and PDISC is identical (request & reply) if( !verify_PLOGI( fcChip, fchs, &ls_reject_code) ) // valid payload? { LOGIN_PAYLOAD logi; // FC-PH Port Login // PDISC payload OK. If critical login fields // (e.g. WWN) matches last login for this port_id, // we may resume any prior exchanges // with the other port BigEndianSwap( (UCHAR*)&fchs->pl[0], (UCHAR*)&logi, sizeof(logi)); pLoggedInPort = fcFindLoggedInPort( fcChip, NULL, // don't search Scsi Nexus 0, // don't search linked list for port_id &logi.port_name[0], // search linked list for WWN &pLastLoggedInPort); // must return non-NULL; when a port_id // is not found, this pointer marks the // end of the singly linked list if( pLoggedInPort != NULL) // WWN found (prior login OK) { if( (fchs->s_id & 0xFFFFFF) == pLoggedInPort->port_id) { // Yes. We were expecting PDISC? if( pLoggedInPort->pdisc ) { // Yes; set fields accordingly. (PDISC, not Originator) SetLoginFields( pLoggedInPort, fchs, TRUE, FALSE); // send 'ACC' reply cpqfcTSPutLinkQue( cpqfcHBAdata, ELS_PLOGI_ACC, // (PDISC same as PLOGI ACC) fchs ); // OK to resume I/O... } else { printk("Not expecting PDISC (pdisc=FALSE)\n"); NeedReject = TRUE; // set reject reason code ls_reject_code = LS_RJT_REASON( PROTOCOL_ERROR, INITIATOR_CTL_ERROR); } } else { if( pLoggedInPort->port_id != 0) { printk("PDISC PortID change: old %Xh, new %Xh\n", pLoggedInPort->port_id, fchs->s_id &0xFFFFFF); } NeedReject = TRUE; // set reject reason code ls_reject_code = LS_RJT_REASON( PROTOCOL_ERROR, INITIATOR_CTL_ERROR); } } else { printk("PDISC Request from unknown WWN\n"); NeedReject = TRUE; // set reject reason code ls_reject_code = LS_RJT_REASON( LOGICAL_ERROR, INVALID_PORT_NAME); } } else // Payload unacceptable { printk("payload unacceptable\n"); NeedReject = TRUE; // reject code already set } if( NeedReject) { ULONG port_id; // The PDISC failed. Set login struct flags accordingly, // terminate any I/O to this port, and Q a PLOGI if( pLoggedInPort ) { pLoggedInPort->pdisc = FALSE; pLoggedInPort->prli = FALSE; pLoggedInPort->plogi = FALSE; cpqfcTSTerminateExchange( cpqfcHBAdata, &pLoggedInPort->ScsiNexus, PORTID_CHANGED); port_id = pLoggedInPort->port_id; } else { port_id = fchs->s_id &0xFFFFFF; } fchs->reserved = ls_reject_code; // borrow this (unused) field cpqfcTSPutLinkQue( cpqfcHBAdata, ELS_RJT, fchs ); } break; case 0x0003: // PLOGI? // Payload for PLOGI and PDISC is identical (request & reply) if( !verify_PLOGI( fcChip, fchs, &ls_reject_code) ) // valid payload? { LOGIN_PAYLOAD logi; // FC-PH Port Login BOOLEAN NeedReject = FALSE; // PDISC payload OK. If critical login fields // (e.g. WWN) matches last login for this port_id, // we may resume any prior exchanges // with the other port BigEndianSwap( (UCHAR*)&fchs->pl[0], (UCHAR*)&logi, sizeof(logi)); pLoggedInPort = fcFindLoggedInPort( fcChip, NULL, // don't search Scsi Nexus 0, // don't search linked list for port_id &logi.port_name[0], // search linked list for WWN &pLastLoggedInPort); // must return non-NULL; when a port_id // is not found, this pointer marks the // end of the singly linked list if( pLoggedInPort == NULL) // WWN not found -New Port { pLoggedInPort = CreateFcPort( cpqfcHBAdata, pLastLoggedInPort, fchs, &logi); if( pLoggedInPort == NULL ) { printk(" cpqfcTS: New port allocation failed - lost FC device!\n"); // Now Q a LOGOut Request, since we won't be talking to that device NeedReject = TRUE; // set reject reason code ls_reject_code = LS_RJT_REASON( LOGICAL_ERROR, NO_LOGIN_RESOURCES); } } if( !NeedReject ) { // OK - we have valid fcPort ptr; set fields accordingly. // (not PDISC, not Originator) SetLoginFields( pLoggedInPort, fchs, FALSE, FALSE); // send 'ACC' reply cpqfcTSPutLinkQue( cpqfcHBAdata, ELS_PLOGI_ACC, // (PDISC same as PLOGI ACC) fchs ); } } else // Payload unacceptable { printk("payload unacceptable\n"); NeedReject = TRUE; // reject code already set } if( NeedReject) { // The PDISC failed. Set login struct flags accordingly, // terminate any I/O to this port, and Q a PLOGI pLoggedInPort->pdisc = FALSE; pLoggedInPort->prli = FALSE; pLoggedInPort->plogi = FALSE; fchs->reserved = ls_reject_code; // borrow this (unused) field // send 'RJT' reply cpqfcTSPutLinkQue( cpqfcHBAdata, ELS_RJT, fchs ); } // terminate any exchanges with this device... if( pLoggedInPort ) { cpqfcTSTerminateExchange( cpqfcHBAdata, &pLoggedInPort->ScsiNexus, PORTID_CHANGED); } break; case 0x1020: // PRLI? { BOOLEAN NeedReject = TRUE; pLoggedInPort = fcFindLoggedInPort( fcChip, NULL, // don't search Scsi Nexus (fchs->s_id & 0xFFFFFF), // search linked list for port_id NULL, // DON'T search linked list for WWN NULL); // don't care if( pLoggedInPort == NULL ) { // huh? printk(" Unexpected PRLI Request -not logged in!\n"); // set reject reason code ls_reject_code = LS_RJT_REASON( PROTOCOL_ERROR, INITIATOR_CTL_ERROR); // Q a LOGOut here? } else { // verify the PRLI ACC payload if( !verify_PRLI( fchs, &ls_reject_code) ) { // PRLI Reply is acceptable; were we expecting it? if( pLoggedInPort->plogi ) { // yes, we expected the PRLI ACC (not PDISC; not Originator) SetLoginFields( pLoggedInPort, fchs, FALSE, FALSE); // Q an ACCept Reply cpqfcTSPutLinkQue( cpqfcHBAdata, ELS_PRLI_ACC, fchs ); NeedReject = FALSE; } else { // huh? printk(" (unexpected) PRLI REQEST with plogi FALSE\n"); // set reject reason code ls_reject_code = LS_RJT_REASON( PROTOCOL_ERROR, INITIATOR_CTL_ERROR); // Q a LOGOut here? } } else { printk(" PRLI REQUEST payload failed verify\n"); // (reject code set by "verify") // Q a LOGOut here? } } if( NeedReject ) { // Q a ReJecT Reply with reason code fchs->reserved = ls_reject_code; cpqfcTSPutLinkQue( cpqfcHBAdata, ELS_RJT, // Q Type fchs ); } } break; case 0x0005: // LOGOut? { // was this LOGOUT because we sent a ELS_PDISC to an FC device // with changed (or new) port_id, or does the port refuse // to communicate to us? // We maintain a logout counter - if we get 3 consecutive LOGOuts, // give up! LOGOUT_PAYLOAD logo; BOOLEAN GiveUpOnDevice = FALSE; ULONG ls_reject_code = 0; BigEndianSwap( (UCHAR*)&fchs->pl[0], (UCHAR*)&logo, sizeof(logo)); pLoggedInPort = fcFindLoggedInPort( fcChip, NULL, // don't search Scsi Nexus 0, // don't search linked list for port_id &logo.port_name[0], // search linked list for WWN NULL); // don't care about end of list if( pLoggedInPort ) // found the device? { // Q an ACC reply cpqfcTSPutLinkQue( cpqfcHBAdata, ELS_LOGO_ACC, // Q Type fchs ); // device to respond to // set login struct fields (LOGO_counter increment) SetLoginFields( pLoggedInPort, fchs, FALSE, FALSE); // are we an Initiator? if( fcChip->Options.initiator) { // we're an Initiator, so check if we should // try (another?) login // Fabrics routinely log out from us after // getting device info - don't try to log them // back in. if( (fchs->s_id & 0xFFF000) == 0xFFF000 ) { ; // do nothing } else if( pLoggedInPort->LOGO_counter <= 3) { // try (another) login (PLOGI request) cpqfcTSPutLinkQue( cpqfcHBAdata, ELS_PLOGI, // Q Type fchs ); // Terminate I/O with "retry" potential cpqfcTSTerminateExchange( cpqfcHBAdata, &pLoggedInPort->ScsiNexus, PORTID_CHANGED); } else { printk(" Got 3 LOGOuts - terminating comm. with port_id %Xh\n", fchs->s_id &&0xFFFFFF); GiveUpOnDevice = TRUE; } } else { GiveUpOnDevice = TRUE; } if( GiveUpOnDevice == TRUE ) { cpqfcTSTerminateExchange( cpqfcHBAdata, &pLoggedInPort->ScsiNexus, DEVICE_REMOVED); } } else // we don't know this WWN! { // Q a ReJecT Reply with reason code fchs->reserved = ls_reject_code; cpqfcTSPutLinkQue( cpqfcHBAdata, ELS_RJT, // Q Type fchs ); } } break; // FABRIC only case case 0x0461: // ELS RSCN (Registered State Change Notification)? { int Ports; int i; __u32 Buff; // Typically, one or more devices have been added to or dropped // from the Fabric. // The format of this frame is defined in FC-FLA (Rev 2.7, Aug 1997) // The first 32-bit word has a 2-byte Payload Length, which // includes the 4 bytes of the first word. Consequently, // this PL len must never be less than 4, must be a multiple of 4, // and has a specified max value 256. // (Endianess!) Ports = ((fchs->pl[0] >>24) - 4) / 4; Ports = Ports > 63 ? 63 : Ports; printk(" RSCN ports: %d\n", Ports); if( Ports <= 0 ) // huh? { // ReJecT the command fchs->reserved = LS_RJT_REASON( UNABLE_TO_PERFORM, 0); cpqfcTSPutLinkQue( cpqfcHBAdata, ELS_RJT, // Q Type fchs ); break; } else // Accept the command { cpqfcTSPutLinkQue( cpqfcHBAdata, ELS_ACC, // Q Type fchs ); } // Check the "address format" to determine action. // We have 3 cases: // 0 = Port Address; 24-bit address of affected device // 1 = Area Address; MS 16 bits valid // 2 = Domain Address; MS 8 bits valid for( i=0; i<Ports; i++) { BigEndianSwap( (UCHAR*)&fchs->pl[i+1],(UCHAR*)&Buff, 4); switch( Buff & 0xFF000000) { case 0: // Port Address? case 0x01000000: // Area Domain? case 0x02000000: // Domain Address // For example, "port_id" 0x201300 // OK, let's try a Name Service Request (Query) fchs->s_id = 0xFFFFFC; // Name Server Address cpqfcTSPutLinkQue( cpqfcHBAdata, FCS_NSR, fchs); break; default: // huh? new value on version change? break; } } } break; default: // don't support this request (yet) // set reject reason code fchs->reserved = LS_RJT_REASON( UNABLE_TO_PERFORM, REQUEST_NOT_SUPPORTED); cpqfcTSPutLinkQue( cpqfcHBAdata, ELS_RJT, // Q Type fchs ); break; } } static void ProcessELS_Reply( CPQFCHBA* cpqfcHBAdata, TachFCHDR_GCMND* fchs) { PTACHYON fcChip = &cpqfcHBAdata->fcChip; FC_EXCHANGES *Exchanges = fcChip->Exchanges; ULONG ox_id = (fchs->ox_rx_id >>16); ULONG ls_reject_code; PFC_LOGGEDIN_PORT pLoggedInPort, pLastLoggedInPort; // If this is a valid reply, then we MUST have sent a request. // Verify that we can find a valid request OX_ID corresponding to // this reply if( Exchanges->fcExchange[(fchs->ox_rx_id >>16)].type == 0) { printk(" *Discarding ACC/RJT frame, xID %04X/%04X* ", ox_id, fchs->ox_rx_id & 0xffff); goto Quit; // exit this routine } // Is the reply a RJT (reject)? if( (fchs->pl[0] & 0xFFFFL) == 0x01) // Reject reply? { // ****** REJECT REPLY ******** switch( Exchanges->fcExchange[ox_id].type ) { case ELS_FDISC: // we sent out Fabric Discovery case ELS_FLOGI: // we sent out FLOGI printk("RJT received on Fabric Login from %Xh, reason %Xh\n", fchs->s_id, fchs->pl[1]); break; default: break; } goto Done; } // OK, we have an ACCept... // What's the ACC type? (according to what we sent) switch( Exchanges->fcExchange[ox_id].type ) { case ELS_PLOGI: // we sent out PLOGI if( !verify_PLOGI( fcChip, fchs, &ls_reject_code) ) { LOGIN_PAYLOAD logi; // FC-PH Port Login // login ACC payload acceptable; search for WWN in our list // of fcPorts BigEndianSwap( (UCHAR*)&fchs->pl[0], (UCHAR*)&logi, sizeof(logi)); pLoggedInPort = fcFindLoggedInPort( fcChip, NULL, // don't search Scsi Nexus 0, // don't search linked list for port_id &logi.port_name[0], // search linked list for WWN &pLastLoggedInPort); // must return non-NULL; when a port_id // is not found, this pointer marks the // end of the singly linked list if( pLoggedInPort == NULL) // WWN not found - new port { pLoggedInPort = CreateFcPort( cpqfcHBAdata, pLastLoggedInPort, fchs, &logi); if( pLoggedInPort == NULL ) { printk(" cpqfcTS: New port allocation failed - lost FC device!\n"); // Now Q a LOGOut Request, since we won't be talking to that device goto Done; // exit with error! dropped login frame } } else // WWN was already known. Ensure that any open // exchanges for this WWN are terminated. // NOTE: It's possible that a device can change its // 24-bit port_id after a Link init or Fabric change // (e.g. LIP or Fabric RSCN). In that case, the old // 24-bit port_id may be duplicated, or no longer exist. { cpqfcTSTerminateExchange( cpqfcHBAdata, &pLoggedInPort->ScsiNexus, PORTID_CHANGED); } // We have an fcPort struct - set fields accordingly // not PDISC, originator SetLoginFields( pLoggedInPort, fchs, FALSE, TRUE); // We just set a "port_id"; is it duplicated? TestDuplicatePortId( cpqfcHBAdata, pLoggedInPort); // For Fabric operation, we issued PLOGI to 0xFFFFFC // so we can send SCR (State Change Registration) // Check for this special case... if( fchs->s_id == 0xFFFFFC ) { // PLOGI ACC was a Fabric response... issue SCR fchs->s_id = 0xFFFFFD; // address for SCR cpqfcTSPutLinkQue( cpqfcHBAdata, ELS_SCR, fchs); } else { // Now we need a PRLI to enable FCP-SCSI operation // set flags and Q up a ELS_PRLI cpqfcTSPutLinkQue( cpqfcHBAdata, ELS_PRLI, fchs); } } else { // login payload unacceptable - reason in ls_reject_code // Q up a Logout Request printk("Login Payload unacceptable\n"); } break; // PDISC logic very similar to PLOGI, except we never want // to allocate mem for "new" port, and we set flags differently // (might combine later with PLOGI logic for efficiency) case ELS_PDISC: // we sent out PDISC if( !verify_PLOGI( fcChip, fchs, &ls_reject_code) ) { LOGIN_PAYLOAD logi; // FC-PH Port Login BOOLEAN NeedLogin = FALSE; // login payload acceptable; search for WWN in our list // of (previously seen) fcPorts BigEndianSwap( (UCHAR*)&fchs->pl[0], (UCHAR*)&logi, sizeof(logi)); pLoggedInPort = fcFindLoggedInPort( fcChip, NULL, // don't search Scsi Nexus 0, // don't search linked list for port_id &logi.port_name[0], // search linked list for WWN &pLastLoggedInPort); // must return non-NULL; when a port_id // is not found, this pointer marks the // end of the singly linked list if( pLoggedInPort != NULL) // WWN found? { // WWN has same port_id as last login? (Of course, a properly // working FC device should NEVER ACCept a PDISC if it's // port_id changed, but check just in case...) if( (fchs->s_id & 0xFFFFFF) == pLoggedInPort->port_id) { // Yes. We were expecting PDISC? if( pLoggedInPort->pdisc ) { int i; // PDISC expected -- set fields. (PDISC, Originator) SetLoginFields( pLoggedInPort, fchs, TRUE, TRUE); // We are ready to resume FCP-SCSI to this device... // Do we need to start anything that was Queued? for( i=0; i< TACH_SEST_LEN; i++) { // see if any exchange for this PDISC'd port was queued if( ((fchs->s_id &0xFFFFFF) == (Exchanges->fcExchange[i].fchs.d_id & 0xFFFFFF)) && (Exchanges->fcExchange[i].status & EXCHANGE_QUEUED)) { fchs->reserved = i; // copy ExchangeID // printk(" *Q x_ID %Xh after PDISC* ",i); cpqfcTSPutLinkQue( cpqfcHBAdata, EXCHANGE_QUEUED, fchs ); } } // Complete commands Q'd while we were waiting for Login UnblockScsiDevice( cpqfcHBAdata->HostAdapter, pLoggedInPort); } else { printk("Not expecting PDISC (pdisc=FALSE)\n"); NeedLogin = TRUE; } } else { printk("PDISC PortID change: old %Xh, new %Xh\n", pLoggedInPort->port_id, fchs->s_id &0xFFFFFF); NeedLogin = TRUE; } } else { printk("PDISC ACC from unknown WWN\n"); NeedLogin = TRUE; } if( NeedLogin) { // The PDISC failed. Set login struct flags accordingly, // terminate any I/O to this port, and Q a PLOGI if( pLoggedInPort ) // FC device previously known? { cpqfcTSPutLinkQue( cpqfcHBAdata, ELS_LOGO, // Q Type fchs ); // has port_id to send to // There are a variety of error scenarios which can result // in PDISC failure, so as a catchall, add the check for // duplicate port_id. TestDuplicatePortId( cpqfcHBAdata, pLoggedInPort); // TriggerHBA( fcChip->Registers.ReMapMemBase, 0); pLoggedInPort->pdisc = FALSE; pLoggedInPort->prli = FALSE; pLoggedInPort->plogi = FALSE; cpqfcTSTerminateExchange( cpqfcHBAdata, &pLoggedInPort->ScsiNexus, PORTID_CHANGED); } cpqfcTSPutLinkQue( cpqfcHBAdata, ELS_PLOGI, fchs ); } } else { // login payload unacceptable - reason in ls_reject_code // Q up a Logout Request printk("ERROR: Login Payload unacceptable!\n"); } break; case ELS_PRLI: // we sent out PRLI pLoggedInPort = fcFindLoggedInPort( fcChip, NULL, // don't search Scsi Nexus (fchs->s_id & 0xFFFFFF), // search linked list for port_id NULL, // DON'T search linked list for WWN NULL); // don't care if( pLoggedInPort == NULL ) { // huh? printk(" Unexpected PRLI ACCept frame!\n"); // Q a LOGOut here? goto Done; } // verify the PRLI ACC payload if( !verify_PRLI( fchs, &ls_reject_code) ) { // PRLI Reply is acceptable; were we expecting it? if( pLoggedInPort->plogi ) { // yes, we expected the PRLI ACC (not PDISC; Originator) SetLoginFields( pLoggedInPort, fchs, FALSE, TRUE); // OK, let's send a REPORT_LUNS command to determine // whether VSA or PDA FCP-LUN addressing is used. cpqfcTSPutLinkQue( cpqfcHBAdata, SCSI_REPORT_LUNS, fchs ); // It's possible that a device we were talking to changed // port_id, and has logged back in. This function ensures // that I/O will resume. UnblockScsiDevice( cpqfcHBAdata->HostAdapter, pLoggedInPort); } else { // huh? printk(" (unexpected) PRLI ACCept with plogi FALSE\n"); // Q a LOGOut here? goto Done; } } else { printk(" PRLI ACCept payload failed verify\n"); // Q a LOGOut here? } break; case ELS_FLOGI: // we sent out FLOGI (Fabric Login) // update the upper 16 bits of our port_id in Tachyon // the switch adds those upper 16 bits when responding // to us (i.e. we are the destination_id) fcChip->Registers.my_al_pa = (fchs->d_id & 0xFFFFFF); writel( fcChip->Registers.my_al_pa, fcChip->Registers.ReMapMemBase + TL_MEM_TACH_My_ID); // now send out a PLOGI to the well known port_id 0xFFFFFC fchs->s_id = 0xFFFFFC; cpqfcTSPutLinkQue( cpqfcHBAdata, ELS_PLOGI, fchs); break; case ELS_FDISC: // we sent out FDISC (Fabric Discovery (Login)) printk( " ELS_FDISC success "); break; case ELS_SCR: // we sent out State Change Registration // now we can issue Name Service Request to find any // Fabric-connected devices we might want to login to. fchs->s_id = 0xFFFFFC; // Name Server Address cpqfcTSPutLinkQue( cpqfcHBAdata, FCS_NSR, fchs); break; default: printk(" *Discarding unknown ACC frame, xID %04X/%04X* ", ox_id, fchs->ox_rx_id & 0xffff); break; } Done: // Regardless of whether the Reply is valid or not, the // the exchange is done - complete cpqfcTSCompleteExchange(cpqfcHBAdata->PciDev, fcChip, (fchs->ox_rx_id >>16)); Quit: return; } // **************** Fibre Channel Services ************** // This is where we process the Directory (Name) Service Reply // to know which devices are on the Fabric static void ProcessFCS_Reply( CPQFCHBA* cpqfcHBAdata, TachFCHDR_GCMND* fchs) { PTACHYON fcChip = &cpqfcHBAdata->fcChip; FC_EXCHANGES *Exchanges = fcChip->Exchanges; ULONG ox_id = (fchs->ox_rx_id >>16); // ULONG ls_reject_code; // PFC_LOGGEDIN_PORT pLoggedInPort, pLastLoggedInPort; // If this is a valid reply, then we MUST have sent a request. // Verify that we can find a valid request OX_ID corresponding to // this reply if( Exchanges->fcExchange[(fchs->ox_rx_id >>16)].type == 0) { printk(" *Discarding Reply frame, xID %04X/%04X* ", ox_id, fchs->ox_rx_id & 0xffff); goto Quit; // exit this routine } // OK, we were expecting it. Now check to see if it's a // "Name Service" Reply, and if so force a re-validation of // Fabric device logins (i.e. Start the login timeout and // send PDISC or PLOGI) // (Endianess Byte Swap?) if( fchs->pl[1] == 0x02FC ) // Name Service { // got a new (or NULL) list of Fabric attach devices... // Invalidate current logins PFC_LOGGEDIN_PORT pLoggedInPort = &fcChip->fcPorts; while( pLoggedInPort ) // for all ports which are expecting // PDISC after the next LIP, set the // logoutTimer { if( (pLoggedInPort->port_id & 0xFFFF00) // Fabric device? && (pLoggedInPort->port_id != 0xFFFFFC) ) // NOT the F_Port { pLoggedInPort->LOGO_timer = 6; // what's the Fabric timeout?? // suspend any I/O in progress until // PDISC received... pLoggedInPort->prli = FALSE; // block FCP-SCSI commands } pLoggedInPort = pLoggedInPort->pNextPort; } if( fchs->pl[2] == 0x0280) // ACCept? { // Send PLOGI or PDISC to these Fabric devices SendLogins( cpqfcHBAdata, &fchs->pl[4] ); } // As of this writing, the only reason to reject is because NO // devices are left on the Fabric. We already started // "logged out" timers; if the device(s) don't come // back, we'll do the implicit logout in the heart beat // timer routine else // ReJecT { // this just means no Fabric device is visible at this instant } } // Regardless of whether the Reply is valid or not, the // the exchange is done - complete cpqfcTSCompleteExchange(cpqfcHBAdata->PciDev, fcChip, (fchs->ox_rx_id >>16)); Quit: return; } static void AnalyzeIncomingFrame( CPQFCHBA *cpqfcHBAdata, ULONG QNdx ) { PTACHYON fcChip = &cpqfcHBAdata->fcChip; FC_EXCHANGES *Exchanges = fcChip->Exchanges; PFC_LINK_QUE fcLQ = cpqfcHBAdata->fcLQ; TachFCHDR_GCMND* fchs = (TachFCHDR_GCMND*)fcLQ->Qitem[QNdx].ulBuff; // ULONG ls_reject_code; // reason for rejecting login LONG ExchangeID; // FC_LOGGEDIN_PORT *pLoggedInPort; BOOLEAN AbortAccept; ENTER("AnalyzeIncomingFrame"); switch( fcLQ->Qitem[QNdx].Type) // FCP or Unknown { case SFQ_UNKNOWN: // unknown frame (e.g. LIP position frame, NOP, etc.) // ********* FC-4 Device Data/ Fibre Channel Service ************* if( ((fchs->d_id &0xF0000000) == 0) // R_CTL (upper nibble) 0x0? && (fchs->f_ctl & 0x20000000) ) // TYPE 20h is Fibre Channel Service { // ************** FCS Reply ********************** if( (fchs->d_id & 0xff000000L) == 0x03000000L) // (31:23 R_CTL) { ProcessFCS_Reply( cpqfcHBAdata, fchs ); } // end of FCS logic } // *********** Extended Link Service ************** else if( fchs->d_id & 0x20000000 // R_CTL 0x2? && (fchs->f_ctl & 0x01000000) ) // TYPE = 1 { // these frames are either a response to // something we sent (0x23) or "unsolicited" // frames (0x22). // **************Extended Link REPLY ********************** // R_CTL Solicited Control Reply if( (fchs->d_id & 0xff000000L) == 0x23000000L) // (31:23 R_CTL) { ProcessELS_Reply( cpqfcHBAdata, fchs ); } // end of "R_CTL Solicited Control Reply" // **************Extended Link REQUEST ********************** // (unsolicited commands from another port or task...) // R_CTL Ext Link REQUEST else if( (fchs->d_id & 0xff000000L) == 0x22000000L && (fchs->ox_rx_id != 0xFFFFFFFFL) ) // (ignore LIP frame) { ProcessELS_Request( cpqfcHBAdata, fchs ); } // ************** LILP ********************** else if( (fchs->d_id & 0xff000000L) == 0x22000000L && (fchs->ox_rx_id == 0xFFFFFFFFL)) // (e.g., LIP frames) { // SANMark specifies that when available, we must use // the LILP frame to determine which ALPAs to send Port Discovery // to... if( fchs->pl[0] == 0x0711L) // ELS_PLOGI? { // UCHAR *ptr = (UCHAR*)&fchs->pl[1]; // printk(" %d ALPAs found\n", *ptr); memcpy( fcChip->LILPmap, &fchs->pl[1], 32*4); // 32 DWORDs fcChip->Options.LILPin = 1; // our LILPmap is valid! // now post to make Port Discovery happen... cpqfcTSPutLinkQue( cpqfcHBAdata, LINKACTIVE, fchs); } } } // ***************** BASIC LINK SERVICE ***************** else if( fchs->d_id & 0x80000000 // R_CTL: && // Basic Link Service Request !(fchs->f_ctl & 0xFF000000) ) // type=0 for BLS { // Check for ABTS (Abort Sequence) if( (fchs->d_id & 0x8F000000) == 0x81000000) { // look for OX_ID, S_ID pair that matches in our // fcExchanges table; if found, reply with ACCept and complete // the exchange // Per PLDA, an ABTS is sent by an initiator; therefore // assume that if we have an exhange open to the port who // sent ABTS, it will be the d_id of what we sent. for( ExchangeID = 0, AbortAccept=FALSE; ExchangeID < TACH_SEST_LEN; ExchangeID++) { // Valid "target" exchange 24-bit port_id matches? // NOTE: For the case of handling Intiator AND Target // functions on the same chip, we can have TWO Exchanges // with the same OX_ID -- OX_ID/FFFF for the CMND, and // OX_ID/RX_ID for the XRDY or DATA frame(s). Ideally, // we would like to support ABTS from Initiators or Targets, // but it's not clear that can be supported on Tachyon for // all cases (requires more investigation). if( (Exchanges->fcExchange[ ExchangeID].type == SCSI_TWE || Exchanges->fcExchange[ ExchangeID].type == SCSI_TRE) && ((Exchanges->fcExchange[ ExchangeID].fchs.d_id & 0xFFFFFF) == (fchs->s_id & 0xFFFFFF)) ) { // target xchnge port_id matches -- how about OX_ID? if( (Exchanges->fcExchange[ ExchangeID].fchs.ox_rx_id &0xFFFF0000) == (fchs->ox_rx_id & 0xFFFF0000) ) // yes! post ACCept response; will be completed by fcStart { Exchanges->fcExchange[ ExchangeID].status = TARGET_ABORT; // copy (add) rx_id field for simplified ACCept reply fchs->ox_rx_id = Exchanges->fcExchange[ ExchangeID].fchs.ox_rx_id; cpqfcTSPutLinkQue( cpqfcHBAdata, BLS_ABTS_ACC, // Q Type fchs ); // void QueContent AbortAccept = TRUE; printk("ACCepting ABTS for x_ID %8.8Xh, SEST pair %8.8Xh\n", fchs->ox_rx_id, Exchanges->fcExchange[ ExchangeID].fchs.ox_rx_id); break; // ABTS can affect only ONE exchange -exit loop } } } // end of FOR loop if( !AbortAccept ) // can't ACCept ABTS - send Reject { printk("ReJecTing: can't find ExchangeID %8.8Xh for ABTS command\n", fchs->ox_rx_id); if( Exchanges->fcExchange[ ExchangeID].type && !(fcChip->SEST->u[ ExchangeID].IWE.Hdr_Len & 0x80000000)) { cpqfcTSCompleteExchange( cpqfcHBAdata->PciDev, fcChip, ExchangeID); } else { printk("Unexpected ABTS ReJecT! SEST[%X] Dword 0: %Xh\n", ExchangeID, fcChip->SEST->u[ ExchangeID].IWE.Hdr_Len); } } } // Check for BLS {ABTS? (Abort Sequence)} ACCept else if( (fchs->d_id & 0x8F000000) == 0x84000000) { // target has responded with ACC for our ABTS; // complete the indicated exchange with ABORTED status // Make no checks for correct RX_ID, since // all we need to conform ABTS ACC is the OX_ID. // Verify that the d_id matches! ExchangeID = (fchs->ox_rx_id >> 16) & 0x7FFF; // x_id from ACC // printk("ABTS ACC x_ID 0x%04X 0x%04X, status %Xh\n", // fchs->ox_rx_id >> 16, fchs->ox_rx_id & 0xffff, // Exchanges->fcExchange[ExchangeID].status); if( ExchangeID < TACH_SEST_LEN ) // x_ID makes sense { // Does "target" exchange 24-bit port_id match? // (See "NOTE" above for handling Intiator AND Target in // the same device driver) // First, if this is a target response, then we originated // (initiated) it with BLS_ABTS: if( (Exchanges->fcExchange[ ExchangeID].type == BLS_ABTS) && // Second, does the source of this ACC match the destination // of who we originally sent it to? ((Exchanges->fcExchange[ ExchangeID].fchs.d_id & 0xFFFFFF) == (fchs->s_id & 0xFFFFFF)) ) { cpqfcTSCompleteExchange( cpqfcHBAdata->PciDev, fcChip, ExchangeID ); } } } // Check for BLS {ABTS? (Abort Sequence)} ReJecT else if( (fchs->d_id & 0x8F000000) == 0x85000000) { // target has responded with RJT for our ABTS; // complete the indicated exchange with ABORTED status // Make no checks for correct RX_ID, since // all we need to conform ABTS ACC is the OX_ID. // Verify that the d_id matches! ExchangeID = (fchs->ox_rx_id >> 16) & 0x7FFF; // x_id from ACC // printk("BLS_ABTS RJT on Exchange 0x%04X 0x%04X\n", // fchs->ox_rx_id >> 16, fchs->ox_rx_id & 0xffff); if( ExchangeID < TACH_SEST_LEN ) // x_ID makes sense { // Does "target" exchange 24-bit port_id match? // (See "NOTE" above for handling Intiator AND Target in // the same device driver) // First, if this is a target response, then we originated // (initiated) it with BLS_ABTS: if( (Exchanges->fcExchange[ ExchangeID].type == BLS_ABTS) && // Second, does the source of this ACC match the destination // of who we originally sent it to? ((Exchanges->fcExchange[ ExchangeID].fchs.d_id & 0xFFFFFF) == (fchs->s_id & 0xFFFFFF)) ) { // YES! NOTE: There is a bug in CPQ's RA-4000 box // where the "reason code" isn't returned in the payload // For now, simply presume the reject is because the target // already completed the exchange... // printk("complete x_ID %Xh on ABTS RJT\n", ExchangeID); cpqfcTSCompleteExchange( cpqfcHBAdata->PciDev, fcChip, ExchangeID ); } } } // end of ABTS check } // end of Basic Link Service Request break; default: printk("AnalyzeIncomingFrame: unknown type: %Xh(%d)\n", fcLQ->Qitem[QNdx].Type, fcLQ->Qitem[QNdx].Type); break; } } // Function for Port Discovery necessary after every FC // initialization (e.g. LIP). // Also may be called if from Fabric Name Service logic. static void SendLogins( CPQFCHBA *cpqfcHBAdata, __u32 *FabricPortIds ) { PTACHYON fcChip = &cpqfcHBAdata->fcChip; FC_EXCHANGES *Exchanges = fcChip->Exchanges; ULONG ulStatus=0; TachFCHDR_GCMND fchs; // copy fields for transmission int i; ULONG loginType; LONG ExchangeID; PFC_LOGGEDIN_PORT pLoggedInPort; __u32 PortIds[ number_of_al_pa]; int NumberOfPorts=0; // We're going to presume (for now) that our limit of Fabric devices // is the same as the number of alpa on a private loop (126 devices). // (Of course this could be changed to support however many we have // memory for). memset( &PortIds[0], 0, sizeof(PortIds)); // First, check if this login is for our own Link Initialization // (e.g. LIP on FC-AL), or if we have knowledge of Fabric devices // from a switch. If we are logging into Fabric devices, we'll // have a non-NULL FabricPortId pointer if( FabricPortIds != NULL) // may need logins { int LastPort=FALSE; i = 0; while( !LastPort) { // port IDs From NSR payload; byte swap needed? BigEndianSwap( (UCHAR*)FabricPortIds, (UCHAR*)&PortIds[i], 4); // printk("FPortId[%d] %Xh ", i, PortIds[i]); if( PortIds[i] & 0x80000000) LastPort = TRUE; PortIds[i] &= 0xFFFFFF; // get 24-bit port_id // some non-Fabric devices (like the Crossroads Fibre/Scsi bridge) // erroneously use ALPA 0. if( PortIds[i] ) // need non-zero port_id... i++; if( i >= number_of_al_pa ) // (in)sanity check break; FabricPortIds++; // next... } NumberOfPorts = i; // printk("NumberOf Fabric ports %d", NumberOfPorts); } else // need to send logins on our "local" link { // are we a loop port? If so, check for reception of LILP frame, // and if received use it (SANMark requirement) if( fcChip->Options.LILPin ) { int j=0; // sanity check on number of ALPAs from LILP frame... // For format of LILP frame, see FC-AL specs or // "Fibre Channel Bench Reference", J. Stai, 1995 (ISBN 1-879936-17-8) // First byte is number of ALPAs i = fcChip->LILPmap[0] >= (32*4) ? 32*4 : fcChip->LILPmap[0]; NumberOfPorts = i; // printk(" LILP alpa count %d ", i); while( i > 0) { PortIds[j] = fcChip->LILPmap[1+ j]; j++; i--; } } else // have to send login to everybody { int j=0; i = number_of_al_pa; NumberOfPorts = i; while( i > 0) { PortIds[j] = valid_al_pa[j]; // all legal ALPAs j++; i--; } } } // Now we have a copy of the port_ids (and how many)... for( i = 0; i < NumberOfPorts; i++) { // 24-bit FC Port ID fchs.s_id = PortIds[i]; // note: only 8-bits used for ALPA // don't log into ourselves (Linux Scsi disk scan will stop on // no TARGET support error on us, and quit trying for rest of devices) if( (fchs.s_id & 0xFF ) == (fcChip->Registers.my_al_pa & 0xFF) ) continue; // fabric login needed? if( (fchs.s_id == 0) || (fcChip->Options.fabric == 1) ) { fcChip->Options.flogi = 1; // fabric needs longer for login // Do we need FLOGI or FDISC? pLoggedInPort = fcFindLoggedInPort( fcChip, NULL, // don't search SCSI Nexus 0xFFFFFC, // search linked list for Fabric port_id NULL, // don't search WWN NULL); // (don't care about end of list) if( pLoggedInPort ) // If found, we have prior experience with // this port -- check whether PDISC is needed { if( pLoggedInPort->flogi ) { // does the switch support FDISC?? (FLOGI for now...) loginType = ELS_FLOGI; // prior FLOGI still valid } else loginType = ELS_FLOGI; // expired FLOGI } else // first FLOGI? loginType = ELS_FLOGI; fchs.s_id = 0xFFFFFE; // well known F_Port address // Fabrics are not required to support FDISC, and // it's not clear if that helps us anyway, since // we'll want a Name Service Request to re-verify // visible devices... // Consequently, we always want our upper 16 bit // port_id to be zero (we'll be rejected if we // use our prior port_id if we've been plugged into // a different switch port). // Trick Tachyon to send to ALPA 0 (see TL/TS UG, pg 87) // If our ALPA is 55h for instance, we want the FC frame // s_id to be 0x000055, while Tach's my_al_pa register // must be 0x000155, to force an OPN at ALPA 0 // (the Fabric port) fcChip->Registers.my_al_pa &= 0xFF; // only use ALPA for FLOGI writel( fcChip->Registers.my_al_pa | 0x0100, fcChip->Registers.ReMapMemBase + TL_MEM_TACH_My_ID); } else // not FLOGI... { // should we send PLOGI or PDISC? Check if any prior port_id // (e.g. alpa) completed a PLOGI/PRLI exchange by checking // the pdisc flag. pLoggedInPort = fcFindLoggedInPort( fcChip, NULL, // don't search SCSI Nexus fchs.s_id, // search linked list for al_pa NULL, // don't search WWN NULL); // (don't care about end of list) if( pLoggedInPort ) // If found, we have prior experience with // this port -- check whether PDISC is needed { if( pLoggedInPort->pdisc ) { loginType = ELS_PDISC; // prior PLOGI and PRLI maybe still valid } else loginType = ELS_PLOGI; // prior knowledge, but can't use PDISC } else // never talked to this port_id before loginType = ELS_PLOGI; // prior knowledge, but can't use PDISC } ulStatus = cpqfcTSBuildExchange( cpqfcHBAdata, loginType, // e.g. PLOGI &fchs, // no incoming frame (we are originator) NULL, // no data (no scatter/gather list) &ExchangeID );// fcController->fcExchanges index, -1 if failed if( !ulStatus ) // Exchange setup OK? { ulStatus = cpqfcTSStartExchange( cpqfcHBAdata, ExchangeID ); if( !ulStatus ) { // submitted to Tach's Outbound Que (ERQ PI incremented) // waited for completion for ELS type (Login frames issued // synchronously) if( loginType == ELS_PDISC ) { // now, we really shouldn't Revalidate SEST exchanges until // we get an ACC reply from our target and verify that // the target address/WWN is unchanged. However, when a fast // target gets the PDISC, they can send SEST Exchange data // before we even get around to processing the PDISC ACC. // Consequently, we lose the I/O. // To avoid this, go ahead and Revalidate when the PDISC goes // out, anticipating that the ACC will be truly acceptable // (this happens 99.9999....% of the time). // If we revalidate a SEST write, and write data goes to a // target that is NOT the one we originated the WRITE to, // that target is required (FCP-SCSI specs, etc) to discard // our WRITE data. // Re-validate SEST entries (Tachyon hardware assists) RevalidateSEST( cpqfcHBAdata->HostAdapter, pLoggedInPort); //TriggerHBA( fcChip->Registers.ReMapMemBase, 1); } } else // give up immediately on error { #ifdef LOGIN_DBG printk("SendLogins: fcStartExchange failed: %Xh\n", ulStatus ); #endif break; } if( fcChip->Registers.FMstatus.value & 0x080 ) // LDn during Port Disc. { ulStatus = LNKDWN_OSLS; #ifdef LOGIN_DBG printk("SendLogins: PortDisc aborted (LDn) @alpa %Xh\n", fchs.s_id); #endif break; } // Check the exchange for bad status (i.e. FrameTimeOut), // and complete on bad status (most likely due to BAD_ALPA) // on LDn, DPC function may already complete (ABORT) a started // exchange, so check type first (type = 0 on complete). if( Exchanges->fcExchange[ExchangeID].status ) { #ifdef LOGIN_DBG printk("completing x_ID %X on status %Xh\n", ExchangeID, Exchanges->fcExchange[ExchangeID].status); #endif cpqfcTSCompleteExchange( cpqfcHBAdata->PciDev, fcChip, ExchangeID); } } else // Xchange setup failed... { #ifdef LOGIN_DBG printk("FC: cpqfcTSBuildExchange failed: %Xh\n", ulStatus ); #endif break; } } if( !ulStatus ) { // set the event signifying that all ALPAs were sent out. #ifdef LOGIN_DBG printk("SendLogins: PortDiscDone\n"); #endif cpqfcHBAdata->PortDiscDone = 1; // TL/TS UG, pg. 184 // 0x0065 = 100ms for RT_TOV // 0x01f5 = 500ms for ED_TOV fcChip->Registers.ed_tov.value = 0x006501f5L; writel( fcChip->Registers.ed_tov.value, (fcChip->Registers.ed_tov.address)); // set the LP_TOV back to ED_TOV (i.e. 500 ms) writel( 0x00000010, fcChip->Registers.ReMapMemBase +TL_MEM_FM_TIMEOUT2); } else { printk("SendLogins: failed at xchng %Xh, alpa %Xh, status %Xh\n", ExchangeID, fchs.s_id, ulStatus); } LEAVE("SendLogins"); } // for REPORT_LUNS documentation, see "In-Depth Exploration of Scsi", // D. Deming, 1994, pg 7-19 (ISBN 1-879936-08-9) static void ScsiReportLunsDone(Scsi_Cmnd *Cmnd) { struct Scsi_Host *HostAdapter = Cmnd->device->host; CPQFCHBA *cpqfcHBAdata = (CPQFCHBA *)HostAdapter->hostdata; PTACHYON fcChip = &cpqfcHBAdata->fcChip; FC_EXCHANGES *Exchanges = fcChip->Exchanges; PFC_LOGGEDIN_PORT pLoggedInPort; int LunListLen=0; int i; ULONG x_ID = 0xFFFFFFFF; UCHAR *ucBuff = Cmnd->request_buffer; // printk("cpqfcTS: ReportLunsDone \n"); // first, we need to find the Exchange for this command, // so we can find the fcPort struct to make the indicated // changes. for( i=0; i< TACH_SEST_LEN; i++) { if( Exchanges->fcExchange[i].type // exchange defined? && (Exchanges->fcExchange[i].Cmnd == Cmnd) ) // matches? { x_ID = i; // found exchange! break; } } if( x_ID == 0xFFFFFFFF) { // printk("cpqfcTS: ReportLuns failed - no FC Exchange\n"); goto Done; // Report Luns FC Exchange gone; // exchange probably Terminated by Implicit logout } // search linked list for the port_id we sent INQUIRY to pLoggedInPort = fcFindLoggedInPort( fcChip, NULL, // DON'T search Scsi Nexus (we will set it) Exchanges->fcExchange[ x_ID].fchs.d_id & 0xFFFFFF, NULL, // DON'T search linked list for FC WWN NULL); // DON'T care about end of list if( !pLoggedInPort ) { // printk("cpqfcTS: ReportLuns failed - device gone\n"); goto Done; // error! can't find logged in Port } LunListLen = ucBuff[3]; LunListLen += ucBuff[2]>>8; if( !LunListLen ) // failed { // generically speaking, a soft error means we should retry... if( (Cmnd->result >> 16) == DID_SOFT_ERROR ) { if( ((Cmnd->sense_buffer[2] & 0xF) == 0x6) && (Cmnd->sense_buffer[12] == 0x29) ) // Sense Code "reset" { TachFCHDR_GCMND *fchs = &Exchanges->fcExchange[ x_ID].fchs; // did we fail because of "check condition, device reset?" // e.g. the device was reset (i.e., at every power up) // retry the Report Luns // who are we sending it to? // we know this because we have a copy of the command // frame from the original Report Lun command - // switch the d_id/s_id fields, because the Exchange Build // context is "reply to source". fchs->s_id = fchs->d_id; // (temporarily re-use the struct) cpqfcTSPutLinkQue( cpqfcHBAdata, SCSI_REPORT_LUNS, fchs ); } } else // probably, the device doesn't support Report Luns pLoggedInPort->ScsiNexus.VolumeSetAddressing = 0; } else // we have LUN info - check VSA mode { // for now, assume all LUNs will have same addr mode // for VSA, payload byte 8 will be 0x40; otherwise, 0 pLoggedInPort->ScsiNexus.VolumeSetAddressing = ucBuff[8]; // Since we got a Report Luns answer, set lun masking flag pLoggedInPort->ScsiNexus.LunMasking = 1; if( LunListLen > 8*CPQFCTS_MAX_LUN) // We expect CPQFCTS_MAX_LUN max LunListLen = 8*CPQFCTS_MAX_LUN; /* printk("Device WWN %08X%08X Reports Luns @: ", (ULONG)(pLoggedInPort->u.liWWN &0xFFFFFFFF), (ULONG)(pLoggedInPort->u.liWWN>>32)); for( i=8; i<LunListLen+8; i+=8) { printk("%02X%02X ", ucBuff[i], ucBuff[i+1] ); } printk("\n"); */ // Since the device was kind enough to tell us where the // LUNs are, lets ensure they are contiguous for Linux's // SCSI driver scan, which expects them to start at 0. // Since Linux only supports 8 LUNs, only copy the first // eight from the report luns command // e.g., the Compaq RA4x00 f/w Rev 2.54 and above may report // LUNs 4001, 4004, etc., because other LUNs are masked from // this HBA (owned by someone else). We'll make those appear as // LUN 0, 1... to Linux { int j; int AppendLunList = 0; // Walk through the LUN list. The 'j' array number is // Linux's lun #, while the value of .lun[j] is the target's // lun #. // Once we build a LUN list, it's possible for a known device // to go offline while volumes (LUNs) are added. Later, // the device will do another PLOGI ... Report Luns command, // and we must not alter the existing Linux Lun map. // (This will be very rare). for( j=0; j < CPQFCTS_MAX_LUN; j++) { if( pLoggedInPort->ScsiNexus.lun[j] != 0xFF ) { AppendLunList = 1; break; } } if( AppendLunList ) { int k; int FreeLunIndex; // printk("cpqfcTS: AppendLunList\n"); // If we get a new Report Luns, we cannot change // any existing LUN mapping! (Only additive entry) // For all LUNs in ReportLun list // if RL lun != ScsiNexus lun // if RL lun present in ScsiNexus lun[], continue // else find ScsiNexus lun[]==FF and add, continue for( i=8, j=0; i<LunListLen+8 && j< CPQFCTS_MAX_LUN; i+=8, j++) { if( pLoggedInPort->ScsiNexus.lun[j] != ucBuff[i+1] ) { // something changed from the last Report Luns printk(" cpqfcTS: Report Lun change!\n"); for( k=0, FreeLunIndex=CPQFCTS_MAX_LUN; k < CPQFCTS_MAX_LUN; k++) { if( pLoggedInPort->ScsiNexus.lun[k] == 0xFF) { FreeLunIndex = k; break; } if( pLoggedInPort->ScsiNexus.lun[k] == ucBuff[i+1] ) break; // we already masked this lun } if( k >= CPQFCTS_MAX_LUN ) { printk(" no room for new LUN %d\n", ucBuff[i+1]); } else if( k == FreeLunIndex ) // need to add LUN { pLoggedInPort->ScsiNexus.lun[k] = ucBuff[i+1]; // printk("add [%d]->%02d\n", k, pLoggedInPort->ScsiNexus.lun[k]); } else { // lun already known } break; } } // print out the new list... for( j=0; j< CPQFCTS_MAX_LUN; j++) { if( pLoggedInPort->ScsiNexus.lun[j] == 0xFF) break; // done // printk("[%d]->%02d ", j, pLoggedInPort->ScsiNexus.lun[j]); } } else { // printk("Linux SCSI LUNs[] -> Device LUNs: "); // first time - this is easy for( i=8, j=0; i<LunListLen+8 && j< CPQFCTS_MAX_LUN; i+=8, j++) { pLoggedInPort->ScsiNexus.lun[j] = ucBuff[i+1]; // printk("[%d]->%02d ", j, pLoggedInPort->ScsiNexus.lun[j]); } // printk("\n"); } } } Done: ; } extern int is_private_data_of_cpqfc(CPQFCHBA *hba, void * pointer); extern void cpqfc_free_private_data(CPQFCHBA *hba, cpqfc_passthru_private_t *data); static void call_scsi_done(Scsi_Cmnd *Cmnd) { CPQFCHBA *hba; hba = (CPQFCHBA *) Cmnd->device->host->hostdata; // Was this command a cpqfc passthru ioctl ? if (Cmnd->sc_request != NULL && Cmnd->device->host != NULL && Cmnd->device->host->hostdata != NULL && is_private_data_of_cpqfc((CPQFCHBA *) Cmnd->device->host->hostdata, Cmnd->sc_request->upper_private_data)) { cpqfc_free_private_data(hba, Cmnd->sc_request->upper_private_data); Cmnd->sc_request->upper_private_data = NULL; Cmnd->result &= 0xff00ffff; Cmnd->result |= (DID_PASSTHROUGH << 16); // prevents retry } if (Cmnd->scsi_done != NULL) (*Cmnd->scsi_done)(Cmnd); } // After successfully getting a "Process Login" (PRLI) from an // FC port, we want to Discover the LUNs so that we know the // addressing type (e.g., FCP-SCSI Volume Set Address, Peripheral // Unit Device), and whether SSP (Selective Storage Presentation or // Lun Masking) has made the LUN numbers non-zero based or // non-contiguous. To remain backward compatible with the SCSI-2 // driver model, which expects a contiguous LUNs starting at 0, // will use the ReportLuns info to map from "device" to "Linux" // LUNs. static void IssueReportLunsCommand( CPQFCHBA* cpqfcHBAdata, TachFCHDR_GCMND* fchs) { PTACHYON fcChip = &cpqfcHBAdata->fcChip; PFC_LOGGEDIN_PORT pLoggedInPort; struct scsi_cmnd *Cmnd = NULL; struct scsi_device *ScsiDev = NULL; LONG x_ID; ULONG ulStatus; UCHAR *ucBuff; if( !cpqfcHBAdata->PortDiscDone) // cleared by LDn { printk("Discard Q'd ReportLun command\n"); goto Done; } // find the device (from port_id) we're talking to pLoggedInPort = fcFindLoggedInPort( fcChip, NULL, // DON'T search Scsi Nexus fchs->s_id & 0xFFFFFF, NULL, // DON'T search linked list for FC WWN NULL); // DON'T care about end of list if( pLoggedInPort ) // we'd BETTER find it! { if( !(pLoggedInPort->fcp_info & TARGET_FUNCTION) ) goto Done; // forget it - FC device not a "target" ScsiDev = scsi_get_host_dev (cpqfcHBAdata->HostAdapter); if (!ScsiDev) goto Done; Cmnd = scsi_get_command (ScsiDev, GFP_KERNEL); if (!Cmnd) goto Done; ucBuff = pLoggedInPort->ReportLunsPayload; memset( ucBuff, 0, REPORT_LUNS_PL); Cmnd->scsi_done = ScsiReportLunsDone; Cmnd->request_buffer = pLoggedInPort->ReportLunsPayload; Cmnd->request_bufflen = REPORT_LUNS_PL; Cmnd->cmnd[0] = 0xA0; Cmnd->cmnd[8] = REPORT_LUNS_PL >> 8; Cmnd->cmnd[9] = (UCHAR)REPORT_LUNS_PL; Cmnd->cmd_len = 12; Cmnd->device->channel = pLoggedInPort->ScsiNexus.channel; Cmnd->device->id = pLoggedInPort->ScsiNexus.target; ulStatus = cpqfcTSBuildExchange( cpqfcHBAdata, SCSI_IRE, fchs, Cmnd, // buffer for Report Lun data &x_ID );// fcController->fcExchanges index, -1 if failed if( !ulStatus ) // Exchange setup? { ulStatus = cpqfcTSStartExchange( cpqfcHBAdata, x_ID ); if( !ulStatus ) { // submitted to Tach's Outbound Que (ERQ PI incremented) // waited for completion for ELS type (Login frames issued // synchronously) } else // check reason for Exchange not being started - we might // want to Queue and start later, or fail with error { } } else // Xchange setup failed... printk(" cpqfcTSBuildExchange failed: %Xh\n", ulStatus ); } else // like, we just got a PRLI ACC, and now the port is gone? { printk(" can't send ReportLuns - no login for port_id %Xh\n", fchs->s_id & 0xFFFFFF); } Done: if (Cmnd) scsi_put_command (Cmnd); if (ScsiDev) scsi_free_host_dev (ScsiDev); } static void CompleteBoardLockCmnd( CPQFCHBA *cpqfcHBAdata) { int i; for( i = CPQFCTS_REQ_QUEUE_LEN-1; i>= 0; i--) { if( cpqfcHBAdata->BoardLockCmnd[i] != NULL ) { Scsi_Cmnd *Cmnd = cpqfcHBAdata->BoardLockCmnd[i]; cpqfcHBAdata->BoardLockCmnd[i] = NULL; Cmnd->result = (DID_SOFT_ERROR << 16); // ask for retry // printk(" BoardLockCmnd[%d] %p Complete, chnl/target/lun %d/%d/%d\n", // i,Cmnd, Cmnd->channel, Cmnd->target, Cmnd->lun); call_scsi_done(Cmnd); } } } // runs every 1 second for FC exchange timeouts and implicit FC device logouts void cpqfcTSheartbeat( unsigned long ptr ) { CPQFCHBA *cpqfcHBAdata = (CPQFCHBA *)ptr; PTACHYON fcChip = &cpqfcHBAdata->fcChip; FC_EXCHANGES *Exchanges = fcChip->Exchanges; PFC_LOGGEDIN_PORT pLoggedInPort = &fcChip->fcPorts; ULONG i; unsigned long flags; DECLARE_MUTEX_LOCKED(BoardLock); PCI_TRACE( 0xA8) if( cpqfcHBAdata->BoardLock) // Worker Task Running? goto Skip; // STOP _que function spin_lock_irqsave( cpqfcHBAdata->HostAdapter->host_lock, flags); PCI_TRACE( 0xA8) cpqfcHBAdata->BoardLock = &BoardLock; // stop Linux SCSI command queuing // release the IO lock (and re-enable interrupts) spin_unlock_irqrestore( cpqfcHBAdata->HostAdapter->host_lock, flags); // Ensure no contention from _quecommand or Worker process CPQ_SPINLOCK_HBA( cpqfcHBAdata) PCI_TRACE( 0xA8) disable_irq( cpqfcHBAdata->HostAdapter->irq); // our IRQ // Complete the "bad target" commands (normally only used during // initialization, since we aren't supposed to call "scsi_done" // inside the queuecommand() function). (this is overly contorted, // scsi_done can be safely called from queuecommand for // this bad target case. May want to simplify this later) for( i=0; i< CPQFCTS_MAX_TARGET_ID; i++) { if( cpqfcHBAdata->BadTargetCmnd[i] ) { Scsi_Cmnd *Cmnd = cpqfcHBAdata->BadTargetCmnd[i]; cpqfcHBAdata->BadTargetCmnd[i] = NULL; Cmnd->result = (DID_BAD_TARGET << 16); call_scsi_done(Cmnd); } else break; } // logged in ports -- re-login check (ports required to verify login with // PDISC after LIP within 2 secs) // prevent contention while( pLoggedInPort ) // for all ports which are expecting // PDISC after the next LIP, check to see if // time is up! { // Important: we only detect "timeout" condition on TRANSITION // from non-zero to zero if( pLoggedInPort->LOGO_timer ) // time-out "armed"? { if( !(--pLoggedInPort->LOGO_timer) ) // DEC from 1 to 0? { // LOGOUT time! Per PLDA, PDISC hasn't complete in 2 secs, so // issue LOGO request and destroy all I/O with other FC port(s). /* printk(" ~cpqfcTS heartbeat: LOGOut!~ "); printk("Linux SCSI Chanl/Target %d/%d (port_id %06Xh) WWN %08X%08X\n", pLoggedInPort->ScsiNexus.channel, pLoggedInPort->ScsiNexus.target, pLoggedInPort->port_id, (ULONG)(pLoggedInPort->u.liWWN &0xFFFFFFFF), (ULONG)(pLoggedInPort->u.liWWN>>32)); */ cpqfcTSImplicitLogout( cpqfcHBAdata, pLoggedInPort); } // else simply decremented - maybe next time... } pLoggedInPort = pLoggedInPort->pNextPort; } // ************ FC EXCHANGE TIMEOUT CHECK ************** for( i=0; i< TACH_MAX_XID; i++) { if( Exchanges->fcExchange[i].type ) // exchange defined? { if( !Exchanges->fcExchange[i].timeOut ) // time expired { // Set Exchange timeout status Exchanges->fcExchange[i].status |= FC2_TIMEOUT; if( i >= TACH_SEST_LEN ) // Link Service Exchange { cpqfcTSCompleteExchange( cpqfcHBAdata->PciDev, fcChip, i); // Don't "abort" LinkService } else // SEST Exchange TO -- may post ABTS to Worker Thread Que { // (Make sure we don't keep timing it out; let other functions // complete it or set the timeOut as needed) Exchanges->fcExchange[i].timeOut = 30000; // seconds default if( Exchanges->fcExchange[i].type & (BLS_ABTS | BLS_ABTS_ACC ) ) { // For BLS_ABTS*, an upper level might still have // an outstanding command waiting for low-level completion. // Also, in the case of a WRITE, we MUST get confirmation // of either ABTS ACC or RJT before re-using the Exchange. // It's possible that the RAID cache algorithm can hang // if we fail to complete a WRITE to a LBA, when a READ // comes later to that same LBA. Therefore, we must // ensure that the target verifies receipt of ABTS for // the exchange printk("~TO Q'd ABTS (x_ID %Xh)~ ", i); // TriggerHBA( fcChip->Registers.ReMapMemBase); // On timeout of a ABTS exchange, check to // see if the FC device has a current valid login. // If so, restart it. pLoggedInPort = fcFindLoggedInPort( fcChip, Exchanges->fcExchange[i].Cmnd, // find Scsi Nexus 0, // DON'T search linked list for FC port id NULL, // DON'T search linked list for FC WWN NULL); // DON'T care about end of list // device exists? if( pLoggedInPort ) // device exists? { if( pLoggedInPort->prli ) // logged in for FCP-SCSI? { // attempt to restart the ABTS printk(" ~restarting ABTS~ "); cpqfcTSStartExchange( cpqfcHBAdata, i ); } } } else // not an ABTS { // We expect the WorkerThread to change the xchng type to // abort and set appropriate timeout. cpqfcTSPutLinkQue( cpqfcHBAdata, BLS_ABTS, &i ); // timed-out } } } else // time not expired... { // decrement timeout: 1 or more seconds left --Exchanges->fcExchange[i].timeOut; } } } enable_irq( cpqfcHBAdata->HostAdapter->irq); CPQ_SPINUNLOCK_HBA( cpqfcHBAdata) cpqfcHBAdata->BoardLock = NULL; // Linux SCSI commands may be queued // Now, complete any Cmnd we Q'd up while BoardLock was held CompleteBoardLockCmnd( cpqfcHBAdata); // restart the timer to run again (1 sec later) Skip: mod_timer( &cpqfcHBAdata->cpqfcTStimer, jiffies + HZ); PCI_TRACEO( i, 0xA8) return; } // put valid FC-AL physical address in spec order static const UCHAR valid_al_pa[]={ 0xef, 0xe8, 0xe4, 0xe2, 0xe1, 0xE0, 0xDC, 0xDA, 0xD9, 0xD6, 0xD5, 0xD4, 0xD3, 0xD2, 0xD1, 0xCe, 0xCd, 0xCc, 0xCb, 0xCa, 0xC9, 0xC7, 0xC6, 0xC5, 0xC3, 0xBc, 0xBa, 0xB9, 0xB6, 0xB5, 0xB4, 0xB3, 0xB2, 0xB1, 0xae, 0xad, 0xAc, 0xAb, 0xAa, 0xA9, 0xA7, 0xA6, 0xA5, 0xA3, 0x9f, 0x9e, 0x9d, 0x9b, 0x98, 0x97, 0x90, 0x8f, 0x88, 0x84, 0x82, 0x81, 0x80, 0x7c, 0x7a, 0x79, 0x76, 0x75, 0x74, 0x73, 0x72, 0x71, 0x6e, 0x6d, 0x6c, 0x6b, 0x6a, 0x69, 0x67, 0x66, 0x65, 0x63, 0x5c, 0x5a, 0x59, 0x56, 0x55, 0x54, 0x53, 0x52, 0x51, 0x4e, 0x4d, 0x4c, 0x4b, 0x4a, 0x49, 0x47, 0x46, 0x45, 0x43, 0x3c, 0x3a, 0x39, 0x36, 0x35, 0x34, 0x33, 0x32, 0x31, 0x2e, 0x2d, 0x2c, 0x2b, 0x2a, 0x29, 0x27, 0x26, 0x25, 0x23, 0x1f, 0x1E, 0x1d, 0x1b, 0x18, 0x17, 0x10, 0x0f, 8, 4, 2, 1 }; // ALPA 0 (Fabric) is special case const int number_of_al_pa = (sizeof(valid_al_pa) ); // this function looks up an al_pa from the table of valid al_pa's // we decrement from the last decimal loop ID, because soft al_pa // (our typical case) are assigned with highest priority (and high al_pa) // first. See "In-Depth FC-AL", R. Kembel pg. 38 // INPUTS: // al_pa - 24 bit port identifier (8 bit al_pa on private loop) // RETURN: // Loop ID - serves are index to array of logged in ports // -1 - invalid al_pa (not all 8 bit values are legal) #if (0) static int GetLoopID( ULONG al_pa ) { int i; for( i = number_of_al_pa -1; i >= 0; i--) // dec. { if( valid_al_pa[i] == (UCHAR)al_pa ) // take lowest 8 bits return i; // success - found valid al_pa; return decimal LoopID } return -1; // failed - not found } #endif extern cpqfc_passthru_private_t *cpqfc_private(Scsi_Request *sr); // Search the singly (forward) linked list "fcPorts" looking for // either the SCSI target (if != -1), port_id (if not NULL), // or WWN (if not null), in that specific order. // If we find a SCSI nexus (from Cmnd arg), set the SCp.phase // field according to VSA or PDU // RETURNS: // Ptr to logged in port struct if found // (NULL if not found) // pLastLoggedInPort - ptr to last struct (for adding new ones) // PFC_LOGGEDIN_PORT fcFindLoggedInPort( PTACHYON fcChip, Scsi_Cmnd *Cmnd, // search linked list for Scsi Nexus (channel/target/lun) ULONG port_id, // search linked list for al_pa, or UCHAR wwn[8], // search linked list for WWN, or... PFC_LOGGEDIN_PORT *pLastLoggedInPort ) { PFC_LOGGEDIN_PORT pLoggedInPort = &fcChip->fcPorts; BOOLEAN target_id_valid=FALSE; BOOLEAN port_id_valid=FALSE; BOOLEAN wwn_valid=FALSE; int i; if( Cmnd != NULL ) target_id_valid = TRUE; else if( port_id ) // note! 24-bit NULL address is illegal port_id_valid = TRUE; else { if( wwn ) // non-null arg? (OK to pass NULL when not searching WWN) { for( i=0; i<8; i++) // valid WWN passed? NULL WWN invalid { if( wwn[i] != 0 ) wwn_valid = TRUE; // any non-zero byte makes (presumably) valid } } } // check other options ... // In case multiple search options are given, we use a priority // scheme: // While valid pLoggedIn Ptr // If port_id is valid // if port_id matches, return Ptr // If wwn is valid // if wwn matches, return Ptr // Next Ptr in list // // Return NULL (not found) while( pLoggedInPort ) // NULL marks end of list (1st ptr always valid) { if( pLastLoggedInPort ) // caller's pointer valid? *pLastLoggedInPort = pLoggedInPort; // end of linked list if( target_id_valid ) { // check Linux Scsi Cmnd for channel/target Nexus match // (all luns are accessed through matching "pLoggedInPort") if( (pLoggedInPort->ScsiNexus.target == Cmnd->device->id) && (pLoggedInPort->ScsiNexus.channel == Cmnd->device->channel)) { // For "passthru" modes, the IOCTL caller is responsible // for setting the FCP-LUN addressing if (Cmnd->sc_request != NULL && Cmnd->device->host != NULL && Cmnd->device->host->hostdata != NULL && is_private_data_of_cpqfc((CPQFCHBA *) Cmnd->device->host->hostdata, Cmnd->sc_request->upper_private_data)) { /* This is a passthru... */ cpqfc_passthru_private_t *pd; pd = Cmnd->sc_request->upper_private_data; Cmnd->SCp.phase = pd->bus; // Cmnd->SCp.have_data_in = pd->pdrive; Cmnd->SCp.have_data_in = Cmnd->device->lun; } else { /* This is not a passthru... */ // set the FCP-LUN addressing type Cmnd->SCp.phase = pLoggedInPort->ScsiNexus.VolumeSetAddressing; // set the Device Type we got from the snooped INQUIRY string Cmnd->SCp.Message = pLoggedInPort->ScsiNexus.InqDeviceType; // handle LUN masking; if not "default" (illegal) lun value, // the use it. These lun values are set by a successful // Report Luns command if( pLoggedInPort->ScsiNexus.LunMasking == 1) { if (Cmnd->device->lun > sizeof(pLoggedInPort->ScsiNexus.lun)) return NULL; // we KNOW all the valid LUNs... 0xFF is invalid! Cmnd->SCp.have_data_in = pLoggedInPort->ScsiNexus.lun[Cmnd->device->lun]; if (pLoggedInPort->ScsiNexus.lun[Cmnd->device->lun] == 0xFF) return NULL; // printk("xlating lun %d to 0x%02x\n", Cmnd->lun, // pLoggedInPort->ScsiNexus.lun[Cmnd->lun]); } else Cmnd->SCp.have_data_in = Cmnd->device->lun; // Linux & target luns match } break; // found it! } } if( port_id_valid ) // look for alpa first { if( pLoggedInPort->port_id == port_id ) break; // found it! } if( wwn_valid ) // look for wwn second { if( !memcmp( &pLoggedInPort->u.ucWWN[0], &wwn[0], 8)) { // all 8 bytes of WWN match break; // found it! } } pLoggedInPort = pLoggedInPort->pNextPort; // try next port } return pLoggedInPort; } // // We need to examine the SEST table and re-validate // any open Exchanges for this LoggedInPort // To make Tachyon pay attention, Freeze FCP assists, // set VAL bits, Unfreeze FCP assists static void RevalidateSEST( struct Scsi_Host *HostAdapter, PFC_LOGGEDIN_PORT pLoggedInPort) { CPQFCHBA *cpqfcHBAdata = (CPQFCHBA *)HostAdapter->hostdata; PTACHYON fcChip = &cpqfcHBAdata->fcChip; FC_EXCHANGES *Exchanges = fcChip->Exchanges; ULONG x_ID; BOOLEAN TachFroze = FALSE; // re-validate any SEST exchanges that are permitted // to survive the link down (e.g., good PDISC performed) for( x_ID = 0; x_ID < TACH_SEST_LEN; x_ID++) { // If the SEST entry port_id matches the pLoggedInPort, // we need to re-validate if( (Exchanges->fcExchange[ x_ID].type == SCSI_IRE) || (Exchanges->fcExchange[ x_ID].type == SCSI_IWE)) { if( (Exchanges->fcExchange[ x_ID].fchs.d_id & 0xFFFFFF) // (24-bit port ID) == pLoggedInPort->port_id) { // printk(" re-val xID %Xh ", x_ID); if( !TachFroze ) // freeze if not already frozen TachFroze |= FreezeTach( cpqfcHBAdata); fcChip->SEST->u[ x_ID].IWE.Hdr_Len |= 0x80000000; // set VAL bit } } } if( TachFroze) { fcChip->UnFreezeTachyon( fcChip, 2); // both ERQ and FCP assists } } // Complete an Linux Cmnds that we Queued because // our FC link was down (cause immediate retry) static void UnblockScsiDevice( struct Scsi_Host *HostAdapter, PFC_LOGGEDIN_PORT pLoggedInPort) { CPQFCHBA *cpqfcHBAdata = (CPQFCHBA *)HostAdapter->hostdata; Scsi_Cmnd* *SCptr = &cpqfcHBAdata->LinkDnCmnd[0]; Scsi_Cmnd *Cmnd; int indx; // if the device was previously "blocked", make sure // we unblock it so Linux SCSI will resume pLoggedInPort->device_blocked = FALSE; // clear our flag // check the Link Down command ptr buffer; // we can complete now causing immediate retry for( indx=0; indx < CPQFCTS_REQ_QUEUE_LEN; indx++, SCptr++) { if( *SCptr != NULL ) // scsi command to complete? { #ifdef DUMMYCMND_DBG printk("complete Cmnd %p in LinkDnCmnd[%d]\n", *SCptr,indx); #endif Cmnd = *SCptr; // Are there any Q'd commands for this target? if( (Cmnd->device->id == pLoggedInPort->ScsiNexus.target) && (Cmnd->device->channel == pLoggedInPort->ScsiNexus.channel) ) { Cmnd->result = (DID_SOFT_ERROR <<16); // force retry if( Cmnd->scsi_done == NULL) { printk("LinkDnCmnd scsi_done ptr null, port_id %Xh\n", pLoggedInPort->port_id); } else call_scsi_done(Cmnd); *SCptr = NULL; // free this slot for next use } } } } //#define WWN_DBG 1 static void SetLoginFields( PFC_LOGGEDIN_PORT pLoggedInPort, TachFCHDR_GCMND* fchs, BOOLEAN PDisc, BOOLEAN Originator) { LOGIN_PAYLOAD logi; // FC-PH Port Login PRLI_REQUEST prli; // copy for BIG ENDIAN switch int i; #ifdef WWN_DBG ULONG ulBuff; #endif BigEndianSwap( (UCHAR*)&fchs->pl[0], (UCHAR*)&logi, sizeof(logi)); pLoggedInPort->Originator = Originator; pLoggedInPort->port_id = fchs->s_id & 0xFFFFFF; switch( fchs->pl[0] & 0xffff ) { case 0x00000002: // PLOGI or PDISC ACCept? if( PDisc ) // PDISC accept goto PDISC_case; case 0x00000003: // ELS_PLOGI or ELS_PLOGI_ACC // Login BB_credit typically 0 for Tachyons pLoggedInPort->BB_credit = logi.cmn_services.bb_credit; // e.g. 128, 256, 1024, 2048 per FC-PH spec // We have to use this when setting up SEST Writes, // since that determines frame size we send. pLoggedInPort->rx_data_size = logi.class3.rx_data_size; pLoggedInPort->plogi = TRUE; pLoggedInPort->pdisc = FALSE; pLoggedInPort->prli = FALSE; // ELS_PLOGI resets pLoggedInPort->flogi = FALSE; // ELS_PLOGI resets pLoggedInPort->logo = FALSE; // ELS_PLOGI resets pLoggedInPort->LOGO_counter = 0;// ELS_PLOGI resets pLoggedInPort->LOGO_timer = 0;// ELS_PLOGI resets // was this PLOGI to a Fabric? if( pLoggedInPort->port_id == 0xFFFFFC ) // well know address pLoggedInPort->flogi = TRUE; for( i=0; i<8; i++) // copy the LOGIN port's WWN pLoggedInPort->u.ucWWN[i] = logi.port_name[i]; #ifdef WWN_DBG ulBuff = (ULONG)pLoggedInPort->u.liWWN; if( pLoggedInPort->Originator) printk("o"); else printk("r"); printk("PLOGI port_id %Xh, WWN %08X", pLoggedInPort->port_id, ulBuff); ulBuff = (ULONG)(pLoggedInPort->u.liWWN >> 32); printk("%08Xh fcPort %p\n", ulBuff, pLoggedInPort); #endif break; case 0x00000005: // ELS_LOGO (logout) pLoggedInPort->plogi = FALSE; pLoggedInPort->pdisc = FALSE; pLoggedInPort->prli = FALSE; // ELS_PLOGI resets pLoggedInPort->flogi = FALSE; // ELS_PLOGI resets pLoggedInPort->logo = TRUE; // ELS_PLOGI resets pLoggedInPort->LOGO_counter++; // ELS_PLOGI resets pLoggedInPort->LOGO_timer = 0; #ifdef WWN_DBG ulBuff = (ULONG)pLoggedInPort->u.liWWN; if( pLoggedInPort->Originator) printk("o"); else printk("r"); printk("LOGO port_id %Xh, WWN %08X", pLoggedInPort->port_id, ulBuff); ulBuff = (ULONG)(pLoggedInPort->u.liWWN >> 32); printk("%08Xh\n", ulBuff); #endif break; PDISC_case: case 0x00000050: // ELS_PDISC or ELS_PDISC_ACC pLoggedInPort->LOGO_timer = 0; // stop the time-out pLoggedInPort->prli = TRUE; // ready to accept FCP-SCSI I/O #ifdef WWN_DBG ulBuff = (ULONG)pLoggedInPort->u.liWWN; if( pLoggedInPort->Originator) printk("o"); else printk("r"); printk("PDISC port_id %Xh, WWN %08X", pLoggedInPort->port_id, ulBuff); ulBuff = (ULONG)(pLoggedInPort->u.liWWN >> 32); printk("%08Xh\n", ulBuff); #endif break; case 0x1020L: // PRLI? case 0x1002L: // PRLI ACCept? BigEndianSwap( (UCHAR*)&fchs->pl[0], (UCHAR*)&prli, sizeof(prli)); pLoggedInPort->fcp_info = prli.fcp_info; // target/initiator flags pLoggedInPort->prli = TRUE; // PLOGI resets, PDISC doesn't pLoggedInPort->pdisc = TRUE; // expect to send (or receive) PDISC // next time pLoggedInPort->LOGO_timer = 0; // will be set next LinkDown #ifdef WWN_DBG ulBuff = (ULONG)pLoggedInPort->u.liWWN; if( pLoggedInPort->Originator) printk("o"); else printk("r"); printk("PRLI port_id %Xh, WWN %08X", pLoggedInPort->port_id, ulBuff); ulBuff = (ULONG)(pLoggedInPort->u.liWWN >> 32); printk("%08Xh\n", ulBuff); #endif break; } return; } static void BuildLinkServicePayload( PTACHYON fcChip, ULONG type, void* payload) { LOGIN_PAYLOAD *plogi; // FC-PH Port Login LOGIN_PAYLOAD PlogiPayload; // copy for BIG ENDIAN switch PRLI_REQUEST *prli; // FCP-SCSI Process Login PRLI_REQUEST PrliPayload; // copy for BIG ENDIAN switch LOGOUT_PAYLOAD *logo; LOGOUT_PAYLOAD LogoutPayload; // PRLO_REQUEST *prlo; // PRLO_REQUEST PrloPayload; REJECT_MESSAGE rjt, *prjt; memset( &PlogiPayload, 0, sizeof( PlogiPayload)); plogi = &PlogiPayload; // load into stack buffer, // then BIG-ENDIAN switch a copy to caller switch( type ) // payload type can be ELS_PLOGI, ELS_PRLI, ADISC, ... { case ELS_FDISC: case ELS_FLOGI: case ELS_PLOGI_ACC: // FC-PH PORT Login Accept case ELS_PLOGI: // FC-PH PORT Login case ELS_PDISC: // FC-PH2 Port Discovery - same payload as ELS_PLOGI plogi->login_cmd = LS_PLOGI; if( type == ELS_PDISC) plogi->login_cmd = LS_PDISC; else if( type == ELS_PLOGI_ACC ) plogi->login_cmd = LS_ACC; plogi->cmn_services.bb_credit = 0x00; plogi->cmn_services.lowest_ver = fcChip->lowest_FCPH_ver; plogi->cmn_services.highest_ver = fcChip->highest_FCPH_ver; plogi->cmn_services.bb_rx_size = TACHLITE_TS_RX_SIZE; plogi->cmn_services.common_features = CONTINUOSLY_INCREASING | RANDOM_RELATIVE_OFFSET; // fill in with World Wide Name based Port Name - 8 UCHARs // get from Tach registers WWN hi & lo LoadWWN( fcChip, plogi->port_name, 0); // fill in with World Wide Name based Node/Fabric Name - 8 UCHARs // get from Tach registers WWN hi & lo LoadWWN( fcChip, plogi->node_name, 1); // For Seagate Drives. // plogi->cmn_services.common_features |= 0x800; plogi->cmn_services.rel_offset = 0xFE; plogi->cmn_services.concurrent_seq = 1; plogi->class1.service_options = 0x00; plogi->class2.service_options = 0x00; plogi->class3.service_options = CLASS_VALID; plogi->class3.initiator_control = 0x00; plogi->class3.rx_data_size = MAX_RX_PAYLOAD; plogi->class3.recipient_control = ERROR_DISCARD | ONE_CATEGORY_SEQUENCE; plogi->class3.concurrent_sequences = 1; plogi->class3.open_sequences = 1; plogi->vendor_id[0] = 'C'; plogi->vendor_id[1] = 'Q'; plogi->vendor_version[0] = 'C'; plogi->vendor_version[1] = 'Q'; plogi->vendor_version[2] = ' '; plogi->vendor_version[3] = '0'; plogi->vendor_version[4] = '0'; plogi->vendor_version[5] = '0'; // FLOGI specific fields... (see FC-FLA, Rev 2.7, Aug 1999, sec 5.1) if( (type == ELS_FLOGI) || (type == ELS_FDISC) ) { if( type == ELS_FLOGI ) plogi->login_cmd = LS_FLOGI; else plogi->login_cmd = LS_FDISC; plogi->cmn_services.lowest_ver = 0x20; plogi->cmn_services.common_features = 0x0800; plogi->cmn_services.rel_offset = 0; plogi->cmn_services.concurrent_seq = 0; plogi->class3.service_options = 0x8800; plogi->class3.rx_data_size = 0; plogi->class3.recipient_control = 0; plogi->class3.concurrent_sequences = 0; plogi->class3.open_sequences = 0; } // copy back to caller's buff, w/ BIG ENDIAN swap BigEndianSwap( (UCHAR*)&PlogiPayload, payload, sizeof(PlogiPayload)); break; case ELS_ACC: // generic Extended Link Service ACCept plogi->login_cmd = LS_ACC; // copy back to caller's buff, w/ BIG ENDIAN swap BigEndianSwap( (UCHAR*)&PlogiPayload, payload, 4); break; case ELS_SCR: // Fabric State Change Registration { SCR_PL scr; // state change registration memset( &scr, 0, sizeof(scr)); scr.command = LS_SCR; // 0x62000000 // see FC-FLA, Rev 2.7, Table A.22 (pg 82) scr.function = 3; // 1 = Events detected by Fabric // 2 = N_Port detected registration // 3 = Full registration // copy back to caller's buff, w/ BIG ENDIAN swap BigEndianSwap( (UCHAR*)&scr, payload, sizeof(SCR_PL)); } break; case FCS_NSR: // Fabric Name Service Request { NSR_PL nsr; // Name Server Req. payload memset( &nsr, 0, sizeof(NSR_PL)); // see Brocade Fabric Programming Guide, // Rev 1.3, pg 4-44 nsr.CT_Rev = 0x01000000; nsr.FCS_Type = 0xFC020000; nsr.Command_code = 0x01710000; nsr.FCP = 8; // copy back to caller's buff, w/ BIG ENDIAN swap BigEndianSwap( (UCHAR*)&nsr, payload, sizeof(NSR_PL)); } break; case ELS_LOGO: // FC-PH PORT LogOut logo = &LogoutPayload; // load into stack buffer, // then BIG-ENDIAN switch a copy to caller logo->cmd = LS_LOGO; // load the 3 UCHARs of the node name // (if private loop, upper two UCHARs 0) logo->reserved = 0; logo->n_port_identifier[0] = (UCHAR)(fcChip->Registers.my_al_pa); logo->n_port_identifier[1] = (UCHAR)(fcChip->Registers.my_al_pa>>8); logo->n_port_identifier[2] = (UCHAR)(fcChip->Registers.my_al_pa>>16); // fill in with World Wide Name based Port Name - 8 UCHARs // get from Tach registers WWN hi & lo LoadWWN( fcChip, logo->port_name, 0); BigEndianSwap( (UCHAR*)&LogoutPayload, payload, sizeof(LogoutPayload) ); // 16 UCHAR struct break; case ELS_LOGO_ACC: // Logout Accept (FH-PH pg 149, table 74) logo = &LogoutPayload; // load into stack buffer, // then BIG-ENDIAN switch a copy to caller logo->cmd = LS_ACC; BigEndianSwap( (UCHAR*)&LogoutPayload, payload, 4 ); // 4 UCHAR cmnd break; case ELS_RJT: // ELS_RJT link service reject (FH-PH pg 155) prjt = (REJECT_MESSAGE*)payload; // pick up passed data rjt.command_code = ELS_RJT; // reverse fields, because of Swap that follows... rjt.vendor = prjt->reserved; // vendor specific rjt.explain = prjt->reason; // rjt.reason = prjt->explain; // rjt.reserved = prjt->vendor; // // BIG-ENDIAN switch a copy to caller BigEndianSwap( (UCHAR*)&rjt, payload, 8 ); // 8 UCHAR cmnd break; case ELS_PRLI_ACC: // Process Login ACCept case ELS_PRLI: // Process Login case ELS_PRLO: // Process Logout memset( &PrliPayload, 0, sizeof( PrliPayload)); prli = &PrliPayload; // load into stack buffer, if( type == ELS_PRLI ) prli->cmd = 0x20; // Login else if( type == ELS_PRLO ) prli->cmd = 0x21; // Logout else if( type == ELS_PRLI_ACC ) { prli->cmd = 0x02; // Login ACCept prli->valid = REQUEST_EXECUTED; } prli->valid |= SCSI_FCP | ESTABLISH_PAIR; prli->fcp_info = READ_XFER_RDY; prli->page_length = 0x10; prli->payload_length = 20; // Can be initiator AND target if( fcChip->Options.initiator ) prli->fcp_info |= INITIATOR_FUNCTION; if( fcChip->Options.target ) prli->fcp_info |= TARGET_FUNCTION; BigEndianSwap( (UCHAR*)&PrliPayload, payload, prli->payload_length); break; default: // no can do - programming error printk(" BuildLinkServicePayload unknown!\n"); break; } } // loads 8 UCHARs for PORT name or NODE name base on // controller's WWN. void LoadWWN( PTACHYON fcChip, UCHAR* dest, UCHAR type) { UCHAR* bPtr, i; switch( type ) { case 0: // Port_Name bPtr = (UCHAR*)&fcChip->Registers.wwn_hi; for( i =0; i<4; i++) dest[i] = *bPtr++; bPtr = (UCHAR*)&fcChip->Registers.wwn_lo; for( i =4; i<8; i++) dest[i] = *bPtr++; break; case 1: // Node/Fabric _Name bPtr = (UCHAR*)&fcChip->Registers.wwn_hi; for( i =0; i<4; i++) dest[i] = *bPtr++; bPtr = (UCHAR*)&fcChip->Registers.wwn_lo; for( i =4; i<8; i++) dest[i] = *bPtr++; break; } } // We check the Port Login payload for required values. Note that // ELS_PLOGI and ELS_PDISC (Port DISCover) use the same payload. int verify_PLOGI( PTACHYON fcChip, TachFCHDR_GCMND* fchs, ULONG* reject_explain) { LOGIN_PAYLOAD login; // source, dest, len (should be mult. of 4) BigEndianSwap( (UCHAR*)&fchs->pl[0], (UCHAR*)&login, sizeof(login)); // check FC version // if other port's highest supported version // is less than our lowest, and // if other port's lowest if( login.cmn_services.highest_ver < fcChip->lowest_FCPH_ver || login.cmn_services.lowest_ver > fcChip->highest_FCPH_ver ) { *reject_explain = LS_RJT_REASON( LOGICAL_ERROR, OPTIONS_ERROR); return LOGICAL_ERROR; } // Receive Data Field Size must be >=128 // per FC-PH if (login.cmn_services.bb_rx_size < 128) { *reject_explain = LS_RJT_REASON( LOGICAL_ERROR, DATA_FIELD_SIZE_ERROR); return LOGICAL_ERROR; } // Only check Class 3 params if( login.class3.service_options & CLASS_VALID) { if (login.class3.rx_data_size < 128) { *reject_explain = LS_RJT_REASON( LOGICAL_ERROR, INVALID_CSP); return LOGICAL_ERROR; } if( login.class3.initiator_control & XID_REQUIRED) { *reject_explain = LS_RJT_REASON( LOGICAL_ERROR, INITIATOR_CTL_ERROR); return LOGICAL_ERROR; } } return 0; // success } int verify_PRLI( TachFCHDR_GCMND* fchs, ULONG* reject_explain) { PRLI_REQUEST prli; // buffer for BIG ENDIAN // source, dest, len (should be mult. of 4) BigEndianSwap( (UCHAR*)&fchs->pl[0], (UCHAR*)&prli, sizeof(prli)); if( prli.fcp_info == 0 ) // i.e., not target or initiator? { *reject_explain = LS_RJT_REASON( LOGICAL_ERROR, OPTIONS_ERROR); return LOGICAL_ERROR; } return 0; // success } // SWAP UCHARs as required by Fibre Channel (i.e. BIG ENDIAN) // INPUTS: // source - ptr to LITTLE ENDIAN ULONGS // cnt - number of UCHARs to switch (should be mult. of ULONG) // OUTPUTS: // dest - ptr to BIG ENDIAN copy // RETURN: // none // void BigEndianSwap( UCHAR *source, UCHAR *dest, USHORT cnt) { int i,j; source+=3; // start at MSB of 1st ULONG for( j=0; j < cnt; j+=4, source+=4, dest+=4) // every ULONG { for( i=0; i<4; i++) // every UCHAR in ULONG *(dest+i) = *(source-i); } } // Build FC Exchanges............ static void buildFCPstatus( PTACHYON fcChip, ULONG ExchangeID); static LONG FindFreeExchange( PTACHYON fcChip, ULONG type ); static ULONG build_SEST_sgList( struct pci_dev *pcidev, ULONG *SESTalPairStart, Scsi_Cmnd *Cmnd, ULONG *sgPairs, PSGPAGES *sgPages_head // link list of TL Ext. S/G pages from O/S Pool ); static int build_FCP_payload( Scsi_Cmnd *Cmnd, UCHAR* payload, ULONG type, ULONG fcp_dl ); /* IRB ERQ __________________ | | / | Req_A_SFS_Len | ____________________ |----------| / | Req_A_SFS_Addr |------->| Reserved | | IRB | / | Req_A_D_ID | | SOF EOF TimeStamp | |-----------/ | Req_A_SEST_Index |-+ | R_CTL | D_ID | | IRB | | Req_B... | | | CS_CTL| S_ID | |-----------\ | | | | TYPE | F_CTL | | IRB | \ | | | | SEQ_ID | SEQ_CNT | |----------- \ | | +-->+--| OX_ID | RX_ID | | | \ |__________________| | | RO | | | pl (payload/cmnd) | | | ..... | | |___________________| | | +-------------------------------------------+ | | | e.g. IWE | SEST __________________ for FCP_DATA | | | / | | Hdr_Len | ____________________ | |----------| / | Hdr_Addr_Addr |------->| Reserved | | | [0] | / |Remote_ID| RSP_Len| | SOF EOF TimeStamp | | |-----------/ | RSP_Addr |---+ | R_CTL | D_ID | +-> [1] | | | Buff_Off | | | CS_CTL| S_ID | |-----------\ |BuffIndex| Link | | | TYPE | F_CTL | | [2] | \ | Rsvd | RX_ID | | | SEQ_ID | SEQ_CNT | |----------- \ | Data_Len | | | OX_ID | RX_ID | | ... | \ | Exp_RO | | | RO | |----------| | Exp_Byte_Cnt | | |___________________| | SEST_LEN | +--| Len | | |__________| | | Address | | | | ... | | for FCP_RSP | |__________________| | ____________________ | +----| Reserved | | | SOF EOF TimeStamp | | | R_CTL | D_ID | | | CS_CTL| S_ID | +--- local or extended | .... | scatter/gather lists defining upper-layer data (e.g. from user's App) */ // All TachLite commands must start with a SFS (Single Frame Sequence) // command. In the simplest case (a NOP Basic Link command), // only one frame header and ERQ entry is required. The most complex // case is the SCSI assisted command, which requires an ERQ entry, // SEST entry, and several frame headers and data buffers all // logically linked together. // Inputs: // cpqfcHBAdata - controller struct // type - PLOGI, SCSI_IWE, etc. // InFCHS - Incoming Tachlite FCHS which prompted this exchange // (only s_id set if we are originating) // Data - PVOID to data struct consistent with "type" // fcExchangeIndex - pointer to OX/RD ID value of built exchange // Return: // fcExchangeIndex - OX/RD ID value if successful // 0 - success // INVALID_ARGS - NULL/ invalid passed args // BAD_ALPA - Bad source al_pa address // LNKDWN_OSLS - Link Down (according to this controller) // OUTQUE_FULL - Outbound Que full // DRIVERQ_FULL - controller's Exchange array full // SEST_FULL - SEST table full // // Remarks: // Psuedo code: // Check for NULL pointers / bad args // Build outgoing FCHS - the header/payload struct // Build IRB (for ERQ entry) // if SCSI command, build SEST entry (e.g. IWE, TRE,...) // return success //sbuildex ULONG cpqfcTSBuildExchange( CPQFCHBA *cpqfcHBAdata, ULONG type, // e.g. PLOGI TachFCHDR_GCMND* InFCHS, // incoming FCHS void *Data, // the CDB, scatter/gather, etc. LONG *fcExchangeIndex ) // points to allocated exchange, { PTACHYON fcChip = &cpqfcHBAdata->fcChip; FC_EXCHANGES *Exchanges = fcChip->Exchanges; ULONG ulStatus = 0; // assume OK USHORT ox_ID, rx_ID=0xFFFF; ULONG SfsLen=0L; TachLiteIRB* pIRB; IRBflags IRB_flags; UCHAR *pIRB_flags = (UCHAR*)&IRB_flags; TachFCHDR_GCMND* CMDfchs; TachFCHDR* dataHDR; // 32 byte HEADER ONLY FCP-DATA buffer TachFCHDR_RSP* rspHDR; // 32 byte header + RSP payload Scsi_Cmnd *Cmnd = (Scsi_Cmnd*)Data; // Linux Scsi CDB, S/G, ... TachLiteIWE* pIWE; TachLiteIRE* pIRE; TachLiteTWE* pTWE; TachLiteTRE* pTRE; ULONG fcp_dl; // total byte length of DATA transferred ULONG fl; // frame length (FC frame size, 128, 256, 512, 1024) ULONG sgPairs; // number of valid scatter/gather pairs int FCP_SCSI_command; BA_ACC_PAYLOAD *ba_acc; BA_RJT_PAYLOAD *ba_rjt; // check passed ARGS if( !fcChip->ERQ ) // NULL ptr means uninitialized Tachlite chip return INVALID_ARGS; if( type == SCSI_IRE || type == SCSI_TRE || type == SCSI_IWE || type == SCSI_TWE) FCP_SCSI_command = 1; else FCP_SCSI_command = 0; // for commands that pass payload data (e.g. SCSI write) // examine command struct - verify that the // length of s/g buffers is adequate for total payload // length (end of list is NULL address) if( FCP_SCSI_command ) { if( Data ) // must have data descriptor (S/G list -- at least // one address with at least 1 byte of data) { // something to do (later)? } else return INVALID_ARGS; // invalid DATA ptr } // we can build an Exchange for later Queuing (on the TL chip) // if an empty slot is available in the DevExt for this controller // look for available Exchange slot... if( type != FCP_RESPONSE && type != BLS_ABTS && type != BLS_ABTS_ACC ) // already have Exchange slot! *fcExchangeIndex = FindFreeExchange( fcChip, type ); if( *fcExchangeIndex != -1 ) // Exchange is available? { // assign tmp ptr (shorthand) CMDfchs = &Exchanges->fcExchange[ *fcExchangeIndex].fchs; if( Cmnd != NULL ) // (necessary for ABTS cases) { Exchanges->fcExchange[ *fcExchangeIndex].Cmnd = Cmnd; // Linux Scsi Exchanges->fcExchange[ *fcExchangeIndex].pLoggedInPort = fcFindLoggedInPort( fcChip, Exchanges->fcExchange[ *fcExchangeIndex].Cmnd, // find Scsi Nexus 0, // DON'T search linked list for FC port id NULL, // DON'T search linked list for FC WWN NULL); // DON'T care about end of list } // Build the command frame header (& data) according // to command type // fields common for all SFS frame types CMDfchs->reserved = 0L; // must clear CMDfchs->sof_eof = 0x75000000L; // SOFi3:EOFn no UAM; LCr=0, no TS // get the destination port_id from incoming FCHS // (initialized before calling if we're Originator) // Frame goes to port it was from - the source_id CMDfchs->d_id = InFCHS->s_id &0xFFFFFF; // destination (add R_CTL later) CMDfchs->s_id = fcChip->Registers.my_al_pa; // CS_CTL = 0 // now enter command-specific fields switch( type ) { case BLS_NOP: // FC defined basic link service command NO-OP // ensure unique X_IDs! (use tracking function) *pIRB_flags = 0; // clear IRB flags IRB_flags.SFA = 1; // send SFS (not SEST index) SfsLen = *pIRB_flags; SfsLen <<= 24; // shift flags to MSB SfsLen += 32L; // add len to LSB (header only - no payload) // TYPE[31-24] 00 Basic Link Service // f_ctl[23:0] exchg originator, 1st seq, xfer S.I. CMDfchs->d_id |= 0x80000000L; // R_CTL = 80 for NOP (Basic Link Ser.) CMDfchs->f_ctl = 0x00310000L; // xchng originator, 1st seq,.... CMDfchs->seq_cnt = 0x0L; CMDfchs->ox_rx_id = 0xFFFF; // RX_ID for now; OX_ID on start CMDfchs->ro = 0x0L; // relative offset (n/a) CMDfchs->pl[0] = 0xaabbccddL; // words 8-15 frame data payload (n/a) Exchanges->fcExchange[ *fcExchangeIndex].timeOut = 1; // seconds // (NOP should complete ~instantly) break; case BLS_ABTS_ACC: // Abort Sequence ACCept *pIRB_flags = 0; // clear IRB flags IRB_flags.SFA = 1; // send SFS (not SEST index) SfsLen = *pIRB_flags; SfsLen <<= 24; // shift flags to MSB SfsLen += 32 + 12; // add len to LSB (header + 3 DWORD payload) CMDfchs->d_id |= 0x84000000L; // R_CTL = 84 for BASIC ACCept // TYPE[31-24] 00 Basic Link Service // f_ctl[23:0] exchg originator, not 1st seq, xfer S.I. CMDfchs->f_ctl = 0x00910000L; // xchnge responder, last seq, xfer SI // CMDfchs->seq_id & count might be set from DataHdr? CMDfchs->ro = 0x0L; // relative offset (n/a) Exchanges->fcExchange[ *fcExchangeIndex].timeOut = 5; // seconds // (Timeout in case of weird error) // now set the ACCept payload... ba_acc = (BA_ACC_PAYLOAD*)&CMDfchs->pl[0]; memset( ba_acc, 0, sizeof( BA_ACC_PAYLOAD)); // Since PLDA requires (only) entire Exchange aborts, we don't need // to worry about what the last sequence was. // We expect that a "target" task is accepting the abort, so we // can use the OX/RX ID pair ba_acc->ox_rx_id = CMDfchs->ox_rx_id; // source, dest, #bytes BigEndianSwap((UCHAR *)&CMDfchs->ox_rx_id, (UCHAR *)&ba_acc->ox_rx_id, 4); ba_acc->low_seq_cnt = 0; ba_acc->high_seq_cnt = 0xFFFF; break; case BLS_ABTS_RJT: // Abort Sequence ACCept *pIRB_flags = 0; // clear IRB flags IRB_flags.SFA = 1; // send SFS (not SEST index) SfsLen = *pIRB_flags; SfsLen <<= 24; // shift flags to MSB SfsLen += 32 + 12; // add len to LSB (header + 3 DWORD payload) CMDfchs->d_id |= 0x85000000L; // R_CTL = 85 for BASIC ReJecT // f_ctl[23:0] exchg originator, not 1st seq, xfer S.I. // TYPE[31-24] 00 Basic Link Service CMDfchs->f_ctl = 0x00910000L; // xchnge responder, last seq, xfer SI // CMDfchs->seq_id & count might be set from DataHdr? CMDfchs->ro = 0x0L; // relative offset (n/a) Exchanges->fcExchange[ *fcExchangeIndex].timeOut = 5; // seconds // (Timeout in case of weird error) CMDfchs->ox_rx_id = InFCHS->ox_rx_id; // copy from sender! // now set the ReJecT payload... ba_rjt = (BA_RJT_PAYLOAD*)&CMDfchs->pl[0]; memset( ba_rjt, 0, sizeof( BA_RJT_PAYLOAD)); // We expect that a "target" task couldn't find the Exhange in the // array of active exchanges, so we use a new LinkService X_ID. // See Reject payload description in FC-PH (Rev 4.3), pg. 140 ba_rjt->reason_code = 0x09; // "unable to perform command request" ba_rjt->reason_explain = 0x03; // invalid OX/RX ID pair break; case BLS_ABTS: // FC defined basic link service command ABTS // Abort Sequence *pIRB_flags = 0; // clear IRB flags IRB_flags.SFA = 1; // send SFS (not SEST index) SfsLen = *pIRB_flags; SfsLen <<= 24; // shift flags to MSB SfsLen += 32L; // add len to LSB (header only - no payload) // TYPE[31-24] 00 Basic Link Service // f_ctl[23:0] exchg originator, not 1st seq, xfer S.I. CMDfchs->d_id |= 0x81000000L; // R_CTL = 81 for ABTS CMDfchs->f_ctl = 0x00110000L; // xchnge originator, last seq, xfer SI // CMDfchs->seq_id & count might be set from DataHdr? CMDfchs->ro = 0x0L; // relative offset (n/a) Exchanges->fcExchange[ *fcExchangeIndex].timeOut = 2; // seconds // (ABTS must timeout when responder is gone) break; case FCS_NSR: // Fabric Name Service Request Exchanges->fcExchange[ *fcExchangeIndex].reTries = 2; Exchanges->fcExchange[ *fcExchangeIndex].timeOut = 2; // seconds // OX_ID, linked to Driver Transaction ID // (fix-up at Queing time) CMDfchs->ox_rx_id = 0xFFFF; // RX_ID - Responder (target) to modify // OX_ID set at ERQueing time *pIRB_flags = 0; // clear IRB flags IRB_flags.SFA = 1; // send SFS (not SEST index) SfsLen = *pIRB_flags; SfsLen <<= 24; // shift flags to MSB SfsLen += (32L + sizeof(NSR_PL)); // add len (header & NSR payload) CMDfchs->d_id |= 0x02000000L; // R_CTL = 02 for - // Name Service Request: Unsolicited // TYPE[31-24] 01 Extended Link Service // f_ctl[23:0] exchg originator, 1st seq, xfer S.I. CMDfchs->f_ctl = 0x20210000L; // OX_ID will be fixed-up at Tachyon enqueing time CMDfchs->seq_cnt = 0; // seq ID, DF_ctl, seq cnt CMDfchs->ro = 0x0L; // relative offset (n/a) BuildLinkServicePayload( fcChip, type, &CMDfchs->pl[0]); break; case ELS_PLOGI: // FC-PH extended link service command Port Login // (May, 2000) // NOTE! This special case facilitates SANMark testing. The SANMark // test script for initialization-timeout.fcal.SANMark-1.fc // "eats" the OPN() primitive without issuing an R_RDY, causing // Tachyon to report LST (loop state timeout), which causes a // LIP. To avoid this, simply send out the frame (i.e. assuming a // buffer credit of 1) without waiting for R_RDY. Many FC devices // (other than Tachyon) have been doing this for years. We don't // ever want to do this for non-Link Service frames unless the // other device really did report non-zero login BB credit (i.e. // in the PLOGI ACCept frame). // CMDfchs->sof_eof |= 0x00000400L; // LCr=1 case ELS_FDISC: // Fabric Discovery (Login) case ELS_FLOGI: // Fabric Login case ELS_SCR: // Fabric State Change Registration case ELS_LOGO: // FC-PH extended link service command Port Logout case ELS_PDISC: // FC-PH extended link service cmnd Port Discovery case ELS_PRLI: // FC-PH extended link service cmnd Process Login Exchanges->fcExchange[ *fcExchangeIndex].reTries = 2; Exchanges->fcExchange[ *fcExchangeIndex].timeOut = 2; // seconds // OX_ID, linked to Driver Transaction ID // (fix-up at Queing time) CMDfchs->ox_rx_id = 0xFFFF; // RX_ID - Responder (target) to modify // OX_ID set at ERQueing time *pIRB_flags = 0; // clear IRB flags IRB_flags.SFA = 1; // send SFS (not SEST index) SfsLen = *pIRB_flags; SfsLen <<= 24; // shift flags to MSB if( type == ELS_LOGO ) SfsLen += (32L + 16L); // add len (header & PLOGI payload) else if( type == ELS_PRLI ) SfsLen += (32L + 20L); // add len (header & PRLI payload) else if( type == ELS_SCR ) SfsLen += (32L + sizeof(SCR_PL)); // add len (header & SCR payload) else SfsLen += (32L + 116L); // add len (header & PLOGI payload) CMDfchs->d_id |= 0x22000000L; // R_CTL = 22 for - // Extended Link_Data: Unsolicited Control // TYPE[31-24] 01 Extended Link Service // f_ctl[23:0] exchg originator, 1st seq, xfer S.I. CMDfchs->f_ctl = 0x01210000L; // OX_ID will be fixed-up at Tachyon enqueing time CMDfchs->seq_cnt = 0; // seq ID, DF_ctl, seq cnt CMDfchs->ro = 0x0L; // relative offset (n/a) BuildLinkServicePayload( fcChip, type, &CMDfchs->pl[0]); break; case ELS_LOGO_ACC: // FC-PH extended link service logout accept case ELS_RJT: // extended link service reject (add reason) case ELS_ACC: // ext. link service generic accept case ELS_PLOGI_ACC:// ext. link service login accept (PLOGI or PDISC) case ELS_PRLI_ACC: // ext. link service process login accept Exchanges->fcExchange[ *fcExchangeIndex].timeOut = 1; // assume done // ensure unique X_IDs! (use tracking function) // OX_ID from initiator cmd ox_ID = (USHORT)(InFCHS->ox_rx_id >> 16); rx_ID = 0xFFFF; // RX_ID, linked to Driver Exchange ID *pIRB_flags = 0; // clear IRB flags IRB_flags.SFA = 1; // send SFS (not SEST index) SfsLen = *pIRB_flags; SfsLen <<= 24; // shift flags to MSB if( type == ELS_RJT ) { SfsLen += (32L + 8L); // add len (header + payload) // ELS_RJT reason codes (utilize unused "reserved" field) CMDfchs->pl[0] = 1; CMDfchs->pl[1] = InFCHS->reserved; } else if( (type == ELS_LOGO_ACC) || (type == ELS_ACC) ) SfsLen += (32L + 4L); // add len (header + payload) else if( type == ELS_PLOGI_ACC ) SfsLen += (32L + 116L); // add len (header + payload) else if( type == ELS_PRLI_ACC ) SfsLen += (32L + 20L); // add len (header + payload) CMDfchs->d_id |= 0x23000000L; // R_CTL = 23 for - // Extended Link_Data: Control Reply // TYPE[31-24] 01 Extended Link Service // f_ctl[23:0] exchg responder, last seq, e_s, tsi CMDfchs->f_ctl = 0x01990000L; CMDfchs->seq_cnt = 0x0L; CMDfchs->ox_rx_id = 0L; // clear CMDfchs->ox_rx_id = ox_ID; // load upper 16 bits CMDfchs->ox_rx_id <<= 16; // shift them CMDfchs->ro = 0x0L; // relative offset (n/a) BuildLinkServicePayload( fcChip, type, &CMDfchs->pl[0]); break; // Fibre Channel SCSI 'originator' sequences... // (originator means 'initiator' in FCP-SCSI) case SCSI_IWE: // TachLite Initiator Write Entry { PFC_LOGGEDIN_PORT pLoggedInPort = Exchanges->fcExchange[ *fcExchangeIndex].pLoggedInPort; Exchanges->fcExchange[ *fcExchangeIndex].reTries = 1; Exchanges->fcExchange[ *fcExchangeIndex].timeOut = 7; // FC2 timeout // first, build FCP_CMND // unique X_ID fix-ups in StartExchange *pIRB_flags = 0; // clear IRB flags IRB_flags.SFA = 1; // send SFS FCP-CMND (not SEST index) // NOTE: unlike FC LinkService login frames, normal // SCSI commands are sent without outgoing verification IRB_flags.DCM = 1; // Disable completion message for Cmnd frame SfsLen = *pIRB_flags; SfsLen <<= 24; // shift flags to MSB SfsLen += 64L; // add len to LSB (header & CMND payload) CMDfchs->d_id |= (0x06000000L); // R_CTL = 6 for command // TYPE[31-24] 8 for FCP SCSI // f_ctl[23:0] exchg originator, 1st seq, xfer S.I. // valid RO CMDfchs->f_ctl = 0x08210008L; CMDfchs->seq_cnt = 0x0L; CMDfchs->ox_rx_id = 0L; // clear for now (-or- in later) CMDfchs->ro = 0x0L; // relative offset (n/a) // now, fill out FCP-DATA header // (use buffer inside SEST object) dataHDR = &fcChip->SEST->DataHDR[ *fcExchangeIndex ]; dataHDR->reserved = 0L; // must clear dataHDR->sof_eof = 0x75002000L; // SOFi3:EOFn no UAM; no CLS, noLCr, no TS dataHDR->d_id = (InFCHS->s_id | 0x01000000L); // R_CTL= FCP_DATA dataHDR->s_id = fcChip->Registers.my_al_pa; // CS_CTL = 0 // TYPE[31-24] 8 for FCP SCSI // f_ctl[23:0] xfer S.I.| valid RO dataHDR->f_ctl = 0x08010008L; dataHDR->seq_cnt = 0x02000000L; // sequence ID: df_ctl : seqence count dataHDR->ox_rx_id = 0L; // clear; fix-up dataHDR fields later dataHDR->ro = 0x0L; // relative offset (n/a) // Now setup the SEST entry pIWE = &fcChip->SEST->u[ *fcExchangeIndex ].IWE; // fill out the IWE: // VALid entry:Dir outbound:DCM:enable CM:enal INT: FC frame len pIWE->Hdr_Len = 0x8e000020L; // data frame Len always 32 bytes // from login parameters with other port, what's the largest frame // we can send? if( pLoggedInPort == NULL) { ulStatus = INVALID_ARGS; // failed! give up break; } if( pLoggedInPort->rx_data_size >= 2048) fl = 0x00020000; // 2048 code (only support 1024!) else if( pLoggedInPort->rx_data_size >= 1024) fl = 0x00020000; // 1024 code else if( pLoggedInPort->rx_data_size >= 512) fl = 0x00010000; // 512 code else fl = 0; // 128 bytes -- should never happen pIWE->Hdr_Len |= fl; // add xmit FC frame len for data phase pIWE->Hdr_Addr = fcChip->SEST->base + ((unsigned long)&fcChip->SEST->DataHDR[*fcExchangeIndex] - (unsigned long)fcChip->SEST); pIWE->RSP_Len = sizeof(TachFCHDR_RSP) ; // hdr+data (recv'd RSP frame) pIWE->RSP_Len |= (InFCHS->s_id << 8); // MS 24 bits Remote_ID memset( &fcChip->SEST->RspHDR[ *fcExchangeIndex].pl, 0, sizeof( FCP_STATUS_RESPONSE) ); // clear out previous status pIWE->RSP_Addr = fcChip->SEST->base + ((unsigned long)&fcChip->SEST->RspHDR[*fcExchangeIndex] - (unsigned long)fcChip->SEST); // Do we need local or extended gather list? // depends on size - we can handle 3 len/addr pairs // locally. fcp_dl = build_SEST_sgList( cpqfcHBAdata->PciDev, &pIWE->GLen1, Cmnd, // S/G list &sgPairs, // return # of pairs in S/G list (from "Data" descriptor) &fcChip->SEST->sgPages[ *fcExchangeIndex ]);// (for Freeing later) if( !fcp_dl ) // error building S/G list? { ulStatus = MEMPOOL_FAIL; break; // give up } // Now that we know total data length in // the passed S/G buffer, set FCP CMND frame build_FCP_payload( Cmnd, (UCHAR*)&CMDfchs->pl[0], type, fcp_dl ); if( sgPairs > 3 ) // need extended s/g list pIWE->Buff_Off = 0x78000000L; // extended data | (no offset) else // local data pointers (in SEST) pIWE->Buff_Off = 0xf8000000L; // local data | (no offset) // ULONG 5 pIWE->Link = 0x0000ffffL; // Buff_Index | Link pIWE->RX_ID = 0x0L; // DWord 6: RX_ID set by target XFER_RDY // DWord 7 pIWE->Data_Len = 0L; // TL enters rcv'd XFER_RDY BURST_LEN pIWE->Exp_RO = 0L; // DWord 8 // DWord 9 pIWE->Exp_Byte_Cnt = fcp_dl; // sum of gather buffers } break; case SCSI_IRE: // TachLite Initiator Read Entry if( Cmnd->timeout != 0) { // printk("Cmnd->timeout %d\n", Cmnd->timeout); // per Linux Scsi Exchanges->fcExchange[ *fcExchangeIndex].timeOut = Cmnd->timeout; } else // use our best guess, based on FC & device { if( Cmnd->SCp.Message == 1 ) // Tape device? (from INQUIRY) { // turn off our timeouts (for now...) Exchanges->fcExchange[ *fcExchangeIndex].timeOut = 0xFFFFFFFF; } else { Exchanges->fcExchange[ *fcExchangeIndex].reTries = 1; Exchanges->fcExchange[ *fcExchangeIndex].timeOut = 7; // per SCSI req. } } // first, build FCP_CMND *pIRB_flags = 0; // clear IRB flags IRB_flags.SFA = 1; // send SFS FCP-CMND (not SEST index) // NOTE: unlike FC LinkService login frames, // normal SCSI commands are sent "open loop" IRB_flags.DCM = 1; // Disable completion message for Cmnd frame SfsLen = *pIRB_flags; SfsLen <<= 24; // shift flags to MSB SfsLen += 64L; // add len to LSB (header & CMND payload) CMDfchs->d_id |= (0x06000000L); // R_CTL = 6 for command // TYPE[31-24] 8 for FCP SCSI // f_ctl[23:0] exchg originator, 1st seq, xfer S.I. // valid RO CMDfchs->f_ctl = 0x08210008L; CMDfchs->seq_cnt = 0x0L; // x_ID & data direction bit set later CMDfchs->ox_rx_id = 0xFFFF; // clear CMDfchs->ro = 0x0L; // relative offset (n/a) // Now setup the SEST entry pIRE = &fcChip->SEST->u[ *fcExchangeIndex ].IRE; // fill out the IRE: // VALid entry:Dir outbound:enable CM:enal INT: pIRE->Seq_Accum = 0xCE000000L; // VAL,DIR inbound,DCM| INI,DAT,RSP pIRE->reserved = 0L; pIRE->RSP_Len = sizeof(TachFCHDR_RSP) ; // hdr+data (recv'd RSP frame) pIRE->RSP_Len |= (InFCHS->s_id << 8); // MS 24 bits Remote_ID pIRE->RSP_Addr = fcChip->SEST->base + ((unsigned long)&fcChip->SEST->RspHDR[*fcExchangeIndex] - (unsigned long)fcChip->SEST); // Do we need local or extended gather list? // depends on size - we can handle 3 len/addr pairs // locally. fcp_dl = build_SEST_sgList( cpqfcHBAdata->PciDev, &pIRE->SLen1, Cmnd, // SCSI command Data desc. with S/G list &sgPairs, // return # of pairs in S/G list (from "Data" descriptor) &fcChip->SEST->sgPages[ *fcExchangeIndex ]);// (for Freeing later) if( !fcp_dl ) // error building S/G list? { // It is permissible to have a ZERO LENGTH Read command. // If there is the case, simply set fcp_dl (and Exp_Byte_Cnt) // to 0 and continue. if( Cmnd->request_bufflen == 0 ) { fcp_dl = 0; // no FC DATA frames expected } else { ulStatus = MEMPOOL_FAIL; break; // give up } } // now that we know the S/G length, build CMND payload build_FCP_payload( Cmnd, (UCHAR*)&CMDfchs->pl[0], type, fcp_dl ); if( sgPairs > 3 ) // need extended s/g list pIRE->Buff_Off = 0x00000000; // DWord 4: extended s/g list, no offset else pIRE->Buff_Off = 0x80000000; // local data, no offset pIRE->Buff_Index = 0x0L; // DWord 5: Buff_Index | Reserved pIRE->Exp_RO = 0x0L; // DWord 6: Expected Rel. Offset pIRE->Byte_Count = 0; // DWord 7: filled in by TL on err pIRE->reserved_ = 0; // DWord 8: reserved // NOTE: 0 length READ is OK. pIRE->Exp_Byte_Cnt = fcp_dl;// DWord 9: sum of scatter buffers break; // Fibre Channel SCSI 'responder' sequences... // (originator means 'target' in FCP-SCSI) case SCSI_TWE: // TachLite Target Write Entry Exchanges->fcExchange[ *fcExchangeIndex].timeOut = 10; // per SCSI req. // first, build FCP_CMND *pIRB_flags = 0; // clear IRB flags IRB_flags.SFA = 1; // send SFS (XFER_RDY) SfsLen = *pIRB_flags; SfsLen <<= 24; // shift flags to MSB SfsLen += (32L + 12L);// add SFS len (header & XFER_RDY payload) CMDfchs->d_id |= (0x05000000L); // R_CTL = 5 for XFER_RDY // TYPE[31-24] 8 for FCP SCSI // f_ctl[23:0] exchg responder, 1st seq, xfer S.I. // valid RO CMDfchs->f_ctl = 0x08810008L; CMDfchs->seq_cnt = 0x01000000; // sequence ID: df_ctl: sequence count // use originator (other port's) OX_ID CMDfchs->ox_rx_id = InFCHS->ox_rx_id; // we want upper 16 bits CMDfchs->ro = 0x0L; // relative offset (n/a) // now, fill out FCP-RSP header // (use buffer inside SEST object) rspHDR = &fcChip->SEST->RspHDR[ *fcExchangeIndex ]; rspHDR->reserved = 0L; // must clear rspHDR->sof_eof = 0x75000000L; // SOFi3:EOFn no UAM; no CLS, noLCr, no TS rspHDR->d_id = (InFCHS->s_id | 0x07000000L); // R_CTL= FCP_RSP rspHDR->s_id = fcChip->Registers.my_al_pa; // CS_CTL = 0 // TYPE[31-24] 8 for FCP SCSI // f_ctl[23:0] responder|last seq| xfer S.I. rspHDR->f_ctl = 0x08910000L; rspHDR->seq_cnt = 0x03000000; // sequence ID rspHDR->ox_rx_id = InFCHS->ox_rx_id; // gives us OX_ID rspHDR->ro = 0x0L; // relative offset (n/a) // Now setup the SEST entry pTWE = &fcChip->SEST->u[ *fcExchangeIndex ].TWE; // fill out the TWE: // VALid entry:Dir outbound:enable CM:enal INT: pTWE->Seq_Accum = 0xC4000000L; // upper word flags pTWE->reserved = 0L; pTWE->Remote_Node_ID = 0L; // no more auto RSP frame! (TL/TS change) pTWE->Remote_Node_ID |= (InFCHS->s_id << 8); // MS 24 bits Remote_ID // Do we need local or extended gather list? // depends on size - we can handle 3 len/addr pairs // locally. fcp_dl = build_SEST_sgList( cpqfcHBAdata->PciDev, &pTWE->SLen1, Cmnd, // S/G list &sgPairs, // return # of pairs in S/G list (from "Data" descriptor) &fcChip->SEST->sgPages[ *fcExchangeIndex ]);// (for Freeing later) if( !fcp_dl ) // error building S/G list? { ulStatus = MEMPOOL_FAIL; break; // give up } // now that we know the S/G length, build CMND payload build_FCP_payload( Cmnd, (UCHAR*)&CMDfchs->pl[0], type, fcp_dl ); if( sgPairs > 3 ) // need extended s/g list pTWE->Buff_Off = 0x00000000; // extended s/g list, no offset else pTWE->Buff_Off = 0x80000000; // local data, no offset pTWE->Buff_Index = 0; // Buff_Index | Link pTWE->Exp_RO = 0; pTWE->Byte_Count = 0; // filled in by TL on err pTWE->reserved_ = 0; pTWE->Exp_Byte_Cnt = fcp_dl;// sum of scatter buffers break; case SCSI_TRE: // TachLite Target Read Entry // It doesn't make much sense for us to "time-out" a READ, // but we'll use it for design consistency and internal error recovery. Exchanges->fcExchange[ *fcExchangeIndex].timeOut = 10; // per SCSI req. // I/O request block settings... *pIRB_flags = 0; // clear IRB flags // check PRLI (process login) info // to see if Initiator Requires XFER_RDY // if not, don't send one! // { PRLI check...} IRB_flags.SFA = 0; // don't send XFER_RDY - start data SfsLen = *pIRB_flags; SfsLen <<= 24; // shift flags to MSB SfsLen += (32L + 12L);// add SFS len (header & XFER_RDY payload) // now, fill out FCP-DATA header // (use buffer inside SEST object) dataHDR = &fcChip->SEST->DataHDR[ *fcExchangeIndex ]; dataHDR->reserved = 0L; // must clear dataHDR->sof_eof = 0x75000000L; // SOFi3:EOFn no UAM; no CLS,noLCr,no TS dataHDR->d_id = (InFCHS->s_id | 0x01000000L); // R_CTL= FCP_DATA dataHDR->s_id = fcChip->Registers.my_al_pa; // CS_CTL = 0 // TYPE[31-24] 8 for FCP SCSI // f_ctl[23:0] exchg responder, not 1st seq, xfer S.I. // valid RO dataHDR->f_ctl = 0x08810008L; dataHDR->seq_cnt = 0x01000000; // sequence ID (no XRDY) dataHDR->ox_rx_id = InFCHS->ox_rx_id & 0xFFFF0000; // we want upper 16 bits dataHDR->ro = 0x0L; // relative offset (n/a) // now, fill out FCP-RSP header // (use buffer inside SEST object) rspHDR = &fcChip->SEST->RspHDR[ *fcExchangeIndex ]; rspHDR->reserved = 0L; // must clear rspHDR->sof_eof = 0x75000000L; // SOFi3:EOFn no UAM; no CLS, noLCr, no TS rspHDR->d_id = (InFCHS->s_id | 0x07000000L); // R_CTL= FCP_RSP rspHDR->s_id = fcChip->Registers.my_al_pa; // CS_CTL = 0 // TYPE[31-24] 8 for FCP SCSI // f_ctl[23:0] responder|last seq| xfer S.I. rspHDR->f_ctl = 0x08910000L; rspHDR->seq_cnt = 0x02000000; // sequence ID: df_ctl: sequence count rspHDR->ro = 0x0L; // relative offset (n/a) // Now setup the SEST entry pTRE = &fcChip->SEST->u[ *fcExchangeIndex ].TRE; // VALid entry:Dir outbound:enable CM:enal INT: pTRE->Hdr_Len = 0x86010020L; // data frame Len always 32 bytes pTRE->Hdr_Addr = // bus address of dataHDR; fcChip->SEST->base + ((unsigned long)&fcChip->SEST->DataHDR[ *fcExchangeIndex ] - (unsigned long)fcChip->SEST); pTRE->RSP_Len = 64L; // hdr+data (TL assisted RSP frame) pTRE->RSP_Len |= (InFCHS->s_id << 8); // MS 24 bits Remote_ID pTRE->RSP_Addr = // bus address of rspHDR fcChip->SEST->base + ((unsigned long)&fcChip->SEST->RspHDR[ *fcExchangeIndex ] - (unsigned long)fcChip->SEST); // Do we need local or extended gather list? // depends on size - we can handle 3 len/addr pairs // locally. fcp_dl = build_SEST_sgList( cpqfcHBAdata->PciDev, &pTRE->GLen1, Cmnd, // S/G list &sgPairs, // return # of pairs in S/G list (from "Data" descriptor) &fcChip->SEST->sgPages[ *fcExchangeIndex ]);// (for Freeing later) if( !fcp_dl ) // error building S/G list? { ulStatus = MEMPOOL_FAIL; break; // give up } // no payload or command to build -- READ doesn't need XRDY if( sgPairs > 3 ) // need extended s/g list pTRE->Buff_Off = 0x78000000L; // extended data | (no offset) else // local data pointers (in SEST) pTRE->Buff_Off = 0xf8000000L; // local data | (no offset) // ULONG 5 pTRE->Buff_Index = 0L; // Buff_Index | reserved pTRE->reserved = 0x0L; // DWord 6 // DWord 7: NOTE: zero length will // hang TachLite! pTRE->Data_Len = fcp_dl; // e.g. sum of scatter buffers pTRE->reserved_ = 0L; // DWord 8 pTRE->reserved__ = 0L; // DWord 9 break; case FCP_RESPONSE: // Target response frame: this sequence uses an OX/RX ID // pair from a completed SEST exchange. We built most // of the response frame when we created the TWE/TRE. *pIRB_flags = 0; // clear IRB flags IRB_flags.SFA = 1; // send SFS (RSP) SfsLen = *pIRB_flags; SfsLen <<= 24; // shift flags to MSB SfsLen += sizeof(TachFCHDR_RSP);// add SFS len (header & RSP payload) Exchanges->fcExchange[ *fcExchangeIndex].type = FCP_RESPONSE; // change Exchange type to "response" phase // take advantage of prior knowledge of OX/RX_ID pair from // previous XFER outbound frame (still in fchs of exchange) fcChip->SEST->RspHDR[ *fcExchangeIndex ].ox_rx_id = CMDfchs->ox_rx_id; // Check the status of the DATA phase of the exchange so we can report // status to the initiator buildFCPstatus( fcChip, *fcExchangeIndex); // set RSP payload fields memcpy( CMDfchs, // re-use same XFER fchs for Response frame &fcChip->SEST->RspHDR[ *fcExchangeIndex ], sizeof( TachFCHDR_RSP )); break; default: printk("cpqfcTS: don't know how to build FC type: %Xh(%d)\n", type,type); break; } if( !ulStatus) // no errors above? { // FCHS is built; now build IRB // link the just built FCHS (the "command") to the IRB entry // for this Exchange. pIRB = &Exchanges->fcExchange[ *fcExchangeIndex].IRB; // len & flags according to command type above pIRB->Req_A_SFS_Len = SfsLen; // includes IRB flags & len pIRB->Req_A_SFS_Addr = // TL needs physical addr of frame to send fcChip->exch_dma_handle + (unsigned long)CMDfchs - (unsigned long)Exchanges; pIRB->Req_A_SFS_D_ID = CMDfchs->d_id << 8; // Dest_ID must be consistent! // Exchange is complete except for "fix-up" fields to be set // at Tachyon Queuing time: // IRB->Req_A_Trans_ID (OX_ID/ RX_ID): // for SEST entry, lower bits correspond to actual FC Exchange ID // fchs->OX_ID or RX_ID } else { #ifdef DBG printk( "FC Error: SEST build Pool Allocation failed\n"); #endif // return resources... cpqfcTSCompleteExchange( cpqfcHBAdata->PciDev, fcChip, *fcExchangeIndex); // SEST build failed } } else // no Exchanges available { ulStatus = SEST_FULL; printk( "FC Error: no fcExchanges available\n"); } return ulStatus; } // set RSP payload fields static void buildFCPstatus( PTACHYON fcChip, ULONG ExchangeID) { FC_EXCHANGES *Exchanges = fcChip->Exchanges; FC_EXCHANGE *pExchange = &Exchanges->fcExchange[ExchangeID]; // shorthand PFCP_STATUS_RESPONSE pFcpStatus; memset( &fcChip->SEST->RspHDR[ ExchangeID ].pl, 0, sizeof( FCP_STATUS_RESPONSE) ); if( pExchange->status ) // something wrong? { pFcpStatus = (PFCP_STATUS_RESPONSE) // cast RSP buffer for this xchng &fcChip->SEST->RspHDR[ ExchangeID ].pl; if( pExchange->status & COUNT_ERROR ) { // set FCP response len valid (so we can report count error) pFcpStatus->fcp_status |= FCP_RSP_LEN_VALID; pFcpStatus->fcp_rsp_len = 0x04000000; // 4 byte len (BIG Endian) pFcpStatus->fcp_rsp_info = FCP_DATA_LEN_NOT_BURST_LEN; // RSP_CODE } } } static dma_addr_t cpqfc_pci_map_sg_page( struct pci_dev *pcidev, ULONG *hw_paddr, // where to put phys addr for HW use void *sgp_vaddr, // the virtual address of the sg page dma_addr_t *umap_paddr, // where to put phys addr for unmap unsigned int *maplen, // where to store sg entry length int PairCount) // number of sg pairs used in the page. { unsigned long aligned_addr = (unsigned long) sgp_vaddr; *maplen = PairCount * 8; aligned_addr += TL_EXT_SG_PAGE_BYTELEN; aligned_addr &= ~(TL_EXT_SG_PAGE_BYTELEN -1); *umap_paddr = pci_map_single(pcidev, (void *) aligned_addr, *maplen, PCI_DMA_TODEVICE); *hw_paddr = (ULONG) *umap_paddr; # if BITS_PER_LONG > 32 if( *umap_paddr >>32 ) { printk("cqpfcTS:Tach SG DMA addr %p>32 bits\n", (void*)umap_paddr); return 0; } # endif return *umap_paddr; } static void cpqfc_undo_SEST_mappings(struct pci_dev *pcidev, unsigned long contigaddr, int len, int dir, struct scatterlist *sgl, int use_sg, PSGPAGES *sgPages_head, int allocated_pages) { PSGPAGES i, next; if (contigaddr != (unsigned long) NULL) pci_unmap_single(pcidev, contigaddr, len, dir); if (sgl != NULL) pci_unmap_sg(pcidev, sgl, use_sg, dir); for (i=*sgPages_head; i != NULL ;i = next) { pci_unmap_single(pcidev, i->busaddr, i->maplen, PCI_DMA_TODEVICE); i->busaddr = (dma_addr_t) NULL; i->maplen = 0L; next = i->next; kfree(i); } *sgPages_head = NULL; } // This routine builds scatter/gather lists into SEST entries // INPUTS: // SESTalPair - SEST address @DWordA "Local Buffer Length" // sgList - Scatter/Gather linked list of Len/Address data buffers // OUTPUT: // sgPairs - number of valid address/length pairs // Remarks: // The SEST data buffer pointers only depend on number of // length/ address pairs, NOT on the type (IWE, TRE,...) // Up to 3 pairs can be referenced in the SEST - more than 3 // require this Extended S/G list page. The page holds 4, 8, 16... // len/addr pairs, per Scatter/Gather List Page Length Reg. // TachLite allows pages to be linked to any depth. //#define DBG_SEST_SGLIST 1 // for printing out S/G pairs with Ext. pages static int ap_hi_water = TL_DANGER_SGPAGES; static ULONG build_SEST_sgList( struct pci_dev *pcidev, ULONG *SESTalPairStart, // the 3 len/address buffers in SEST Scsi_Cmnd *Cmnd, ULONG *sgPairs, PSGPAGES *sgPages_head) // link list of TL Ext. S/G pages from O/S Pool { ULONG i, AllocatedPages=0; // Tach Ext. S/G page allocations ULONG* alPair = SESTalPairStart; ULONG* ext_sg_page_phys_addr_place = NULL; int PairCount; unsigned long ulBuff, contigaddr; ULONG total_data_len=0; // (in bytes) ULONG bytes_to_go = Cmnd->request_bufflen; // total xfer (S/G sum) ULONG thisMappingLen; struct scatterlist *sgl = NULL; // S/G list (Linux format) int sg_count, totalsgs; dma_addr_t busaddr; unsigned long thislen, offset; PSGPAGES *sgpage = sgPages_head; PSGPAGES prev_page = NULL; # define WE_HAVE_SG_LIST (sgl != (unsigned long) NULL) contigaddr = (unsigned long) NULL; if( !Cmnd->use_sg ) // no S/G list? { if (bytes_to_go <= TL_MAX_SG_ELEM_LEN) { *sgPairs = 1; // use "local" S/G pair in SEST entry // (for now, ignore address bits above #31) *alPair++ = bytes_to_go; // bits 18-0, length if (bytes_to_go != 0) { contigaddr = ulBuff = pci_map_single(pcidev, Cmnd->request_buffer, Cmnd->request_bufflen, Cmnd->sc_data_direction); // printk("ms %p ", ulBuff); } else { // No data transfer, (e.g.: Test Unit Ready) // printk("btg=0 "); *sgPairs = 0; memset(alPair, 0, sizeof(*alPair)); return 0; } # if BITS_PER_LONG > 32 if( ulBuff >>32 ) { printk("FATAL! Tachyon DMA address %p " "exceeds 32 bits\n", (void*)ulBuff ); return 0; } # endif *alPair = (ULONG)ulBuff; return bytes_to_go; } else // We have a single large (too big) contiguous buffer. { // We will have to break it up. We'll use the scatter // gather code way below, but use contigaddr instead // of sg_dma_addr(). (this is a very rare case). unsigned long btg; contigaddr = pci_map_single(pcidev, Cmnd->request_buffer, Cmnd->request_bufflen, Cmnd->sc_data_direction); // printk("contigaddr = %p, len = %d\n", // (void *) contigaddr, bytes_to_go); totalsgs = 0; for (btg = bytes_to_go; btg > 0; ) { btg -= ( btg > TL_MAX_SG_ELEM_LEN ? TL_MAX_SG_ELEM_LEN : btg ); totalsgs++; } sgl = NULL; *sgPairs = totalsgs; } } else // we do have a scatter gather list { // [TBD - update for Linux to support > 32 bits addressing] // since the format for local & extended S/G lists is different, // check if S/G pairs exceeds 3. // *sgPairs = Cmnd->use_sg; Nope, that's wrong. sgl = (struct scatterlist*)Cmnd->request_buffer; sg_count = pci_map_sg(pcidev, sgl, Cmnd->use_sg, Cmnd->sc_data_direction); if( sg_count <= 3 ) { // we need to be careful here that no individual mapping // is too large, and if any is, that breaking it up // doesn't push us over 3 sgs, or, if it does, that we // handle that case. Tachyon can take 0x7FFFF bits for length, // but sg structure uses "unsigned int", on the face of it, // up to 0xFFFFFFFF or even more. int i; unsigned long thislen; totalsgs = 0; for (i=0;i<sg_count;i++) { thislen = sg_dma_len(&sgl[i]); while (thislen >= TL_MAX_SG_ELEM_LEN) { totalsgs++; thislen -= TL_MAX_SG_ELEM_LEN; } if (thislen > 0) totalsgs++; } *sgPairs = totalsgs; } else totalsgs = 999; // as a first estimate, definitely >3, // if (totalsgs != sg_count) // printk("totalsgs = %d, sgcount=%d\n",totalsgs,sg_count); } if( totalsgs <= 3 ) // can (must) use "local" SEST list { while( bytes_to_go) { offset = 0L; if ( WE_HAVE_SG_LIST ) thisMappingLen = sg_dma_len(sgl); else // or contiguous buffer? thisMappingLen = bytes_to_go; while (thisMappingLen > 0) { thislen = thisMappingLen > TL_MAX_SG_ELEM_LEN ? TL_MAX_SG_ELEM_LEN : thisMappingLen; bytes_to_go = bytes_to_go - thislen; // we have L/A pair; L = thislen, A = physicalAddress // load into SEST... total_data_len += thislen; *alPair = thislen; // bits 18-0, length alPair++; if ( WE_HAVE_SG_LIST ) ulBuff = sg_dma_address(sgl) + offset; else ulBuff = contigaddr + offset; offset += thislen; # if BITS_PER_LONG > 32 if( ulBuff >>32 ) { printk("cqpfcTS: 2Tach DMA address %p > 32 bits\n", (void*)ulBuff ); printk("%s = %p, offset = %ld\n", WE_HAVE_SG_LIST ? "ulBuff" : "contigaddr", WE_HAVE_SG_LIST ? (void *) ulBuff : (void *) contigaddr, offset); return 0; } # endif *alPair++ = (ULONG)ulBuff; // lower 32 bits (31-0) thisMappingLen -= thislen; } if ( WE_HAVE_SG_LIST ) ++sgl; // next S/G pair else if (bytes_to_go != 0) printk("BTG not zero!\n"); # ifdef DBG_SEST_SGLIST printk("L=%d ", thisMappingLen); printk("btg=%d ", bytes_to_go); # endif } // printk("i:%d\n", *sgPairs); } else // more than 3 pairs requires Extended S/G page (Pool Allocation) { // clear out SEST DWORDs (local S/G addr) C-F (A-B set in following logic) for( i=2; i<6; i++) alPair[i] = 0; PairCount = TL_EXT_SG_PAGE_COUNT; // forces initial page allocation totalsgs = 0; while( bytes_to_go ) { // Per SEST format, we can support 524287 byte lengths per // S/G pair. Typical user buffers are 4k, and very rarely // exceed 12k due to fragmentation of physical memory pages. // However, on certain O/S system (not "user") buffers (on platforms // with huge memories), it's possible to exceed this // length in a single S/G address/len mapping, so we have to handle // that. offset = 0L; if ( WE_HAVE_SG_LIST ) thisMappingLen = sg_dma_len(sgl); else thisMappingLen = bytes_to_go; while (thisMappingLen > 0) { thislen = thisMappingLen > TL_MAX_SG_ELEM_LEN ? TL_MAX_SG_ELEM_LEN : thisMappingLen; // printk("%d/%d/%d\n", thislen, thisMappingLen, bytes_to_go); // should we load into "this" extended S/G page, or allocate // new page? if( PairCount >= TL_EXT_SG_PAGE_COUNT ) { // Now, we have to map the previous page, (triggering buffer bounce) // The first time thru the loop, there won't be a previous page. if (prev_page != NULL) // is there a prev page? { // this code is normally kind of hard to trigger, // you have to use up more than 256 scatter gather // elements to get here. Cranking down TL_MAX_SG_ELEM_LEN // to an absurdly low value (128 bytes or so) to artificially // break i/o's into a zillion pieces is how I tested it. busaddr = cpqfc_pci_map_sg_page(pcidev, ext_sg_page_phys_addr_place, prev_page->page, &prev_page->busaddr, &prev_page->maplen, PairCount); } // Allocate the TL Extended S/G list page. We have // to allocate twice what we want to ensure required TL alignment // (Tachlite TL/TS User Man. Rev 6.0, p 168) // We store the original allocated PVOID so we can free later *sgpage = kmalloc( sizeof(SGPAGES), GFP_ATOMIC); if ( ! *sgpage ) { printk("cpqfc: Allocation failed @ %d S/G page allocations\n", AllocatedPages); total_data_len = 0; // failure!! Ext. S/G is All-or-none affair // unmap the previous mappings, if any. cpqfc_undo_SEST_mappings(pcidev, contigaddr, Cmnd->request_bufflen, Cmnd->sc_data_direction, sgl, Cmnd->use_sg, sgPages_head, AllocatedPages+1); // FIXME: testing shows that if we get here, // it's bad news. (this has been this way for a long // time though, AFAIK. Not that that excuses it.) return 0; // give up (and probably hang the system) } // clear out memory we just allocated memset( (*sgpage)->page,0,TL_EXT_SG_PAGE_BYTELEN*2); (*sgpage)->next = NULL; (*sgpage)->busaddr = (dma_addr_t) NULL; (*sgpage)->maplen = 0L; // align the memory - TL requires sizeof() Ext. S/G page alignment. // We doubled the actual required size so we could mask off LSBs // to get desired offset ulBuff = (unsigned long) (*sgpage)->page; ulBuff += TL_EXT_SG_PAGE_BYTELEN; ulBuff &= ~(TL_EXT_SG_PAGE_BYTELEN -1); // set pointer, in SEST if first Ext. S/G page, or in last pair // of linked Ext. S/G pages... (Only 32-bit PVOIDs, so just // load lower 32 bits) // NOTE: the Len field must be '0' if this is the first Ext. S/G // pointer in SEST, and not 0 otherwise (we know thislen != 0). *alPair = (alPair != SESTalPairStart) ? thislen : 0; # ifdef DBG_SEST_SGLIST printk("PairCount %d @%p even %Xh, ", PairCount, alPair, *alPair); # endif // Save the place where we need to store the physical // address of this scatter gather page which we get when we map it // (and mapping we can do only after we fill it in.) alPair++; // next DWORD, will contain phys addr of the ext page ext_sg_page_phys_addr_place = alPair; // Now, set alPair = the virtual addr of the (Extended) S/G page // which will accept the Len/ PhysicalAddress pairs alPair = (ULONG *) ulBuff; AllocatedPages++; if (AllocatedPages >= ap_hi_water) { // This message should rarely, if ever, come out. // Previously (cpqfc version <= 2.0.5) the driver would // just puke if more than 4 SG pages were used, and nobody // ever complained about that. This only comes out if // more than 8 pages are used. printk(KERN_WARNING "cpqfc: Possible danger. %d scatter gather pages used.\n" "cpqfc: detected seemingly extreme memory " "fragmentation or huge data transfers.\n", AllocatedPages); ap_hi_water = AllocatedPages+1; } PairCount = 1; // starting new Ext. S/G page prev_page = (*sgpage); // remember this page, for next time thru sgpage = &((*sgpage)->next); } // end of new TL Ext. S/G page allocation *alPair = thislen; // bits 18-0, length (range check above) # ifdef DBG_SEST_SGLIST printk("PairCount %d @%p, even %Xh, ", PairCount, alPair, *alPair); # endif alPair++; // next DWORD, physical address if ( WE_HAVE_SG_LIST ) ulBuff = sg_dma_address(sgl) + offset; else ulBuff = contigaddr + offset; offset += thislen; # if BITS_PER_LONG > 32 if( ulBuff >>32 ) { printk("cqpfcTS: 1Tach DMA address %p > 32 bits\n", (void*)ulBuff ); printk("%s = %p, offset = %ld\n", WE_HAVE_SG_LIST ? "ulBuff" : "contigaddr", WE_HAVE_SG_LIST ? (void *) ulBuff : (void *) contigaddr, offset); return 0; } # endif *alPair = (ULONG) ulBuff; // lower 32 bits (31-0) # ifdef DBG_SEST_SGLIST printk("odd %Xh\n", *alPair); # endif alPair++; // next DWORD, next address/length pair PairCount++; // next Length/Address pair // if (PairCount > pc_hi_water) // { // printk("pc hi = %d ", PairCount); // pc_hi_water = PairCount; // } bytes_to_go -= thislen; total_data_len += thislen; thisMappingLen -= thislen; totalsgs++; } // while (thisMappingLen > 0) if ( WE_HAVE_SG_LIST ) sgl++; // next S/G pair } // while (bytes_to_go) // printk("Totalsgs=%d\n", totalsgs); *sgPairs = totalsgs; // PCI map (and bounce) the last (and usually only) extended SG page busaddr = cpqfc_pci_map_sg_page(pcidev, ext_sg_page_phys_addr_place, prev_page->page, &prev_page->busaddr, &prev_page->maplen, PairCount); } return total_data_len; } // The Tachlite SEST table is referenced to OX_ID (or RX_ID). To optimize // performance and debuggability, we index the Exchange structure to FC X_ID // This enables us to build exchanges for later en-queing to Tachyon, // provided we have an open X_ID slot. At Tachyon queing time, we only // need an ERQ slot; then "fix-up" references in the // IRB, FCHS, etc. as needed. // RETURNS: // 0 if successful // non-zero on error //sstartex ULONG cpqfcTSStartExchange( CPQFCHBA *cpqfcHBAdata, LONG ExchangeID ) { PTACHYON fcChip = &cpqfcHBAdata->fcChip; FC_EXCHANGES *Exchanges = fcChip->Exchanges; FC_EXCHANGE *pExchange = &Exchanges->fcExchange[ ExchangeID ]; // shorthand USHORT producer, consumer; ULONG ulStatus=0; short int ErqIndex; BOOLEAN CompleteExchange = FALSE; // e.g. ACC replies are complete BOOLEAN SestType=FALSE; ULONG InboundData=0; // We will manipulate Tachlite chip registers here to successfully // start exchanges. // Check that link is not down -- we can't start an exchange on a // down link! if( fcChip->Registers.FMstatus.value & 0x80) // LPSM offline? { printk("fcStartExchange: PSM offline (%Xh), x_ID %Xh, type %Xh, port_id %Xh\n", fcChip->Registers.FMstatus.value & 0xFF, ExchangeID, pExchange->type, pExchange->fchs.d_id); if( ExchangeID >= TACH_SEST_LEN ) // Link Service Outbound frame? { // Our most popular LinkService commands are port discovery types // (PLOGI/ PDISC...), which are implicitly nullified by Link Down // events, so it makes no sense to Que them. However, ABTS should // be queued, since exchange sequences are likely destroyed by // Link Down events, and we want to notify other ports of broken // sequences by aborting the corresponding exchanges. if( pExchange->type != BLS_ABTS ) { ulStatus = LNKDWN_OSLS; goto Done; // don't Que most LinkServ exchanges on LINK DOWN } } printk("fcStartExchange: Que x_ID %Xh, type %Xh\n", ExchangeID, pExchange->type); pExchange->status |= EXCHANGE_QUEUED; ulStatus = EXCHANGE_QUEUED; goto Done; } // Make sure ERQ has available space. producer = (USHORT)fcChip->ERQ->producerIndex; // copies for logical arith. consumer = (USHORT)fcChip->ERQ->consumerIndex; producer++; // We are testing for full que by incrementing if( producer >= ERQ_LEN ) // rollover condition? producer = 0; if( consumer != producer ) // ERQ not full? { // ****************** Need Atomic access to chip registers!!******** // remember ERQ PI for copying IRB ErqIndex = (USHORT)fcChip->ERQ->producerIndex; fcChip->ERQ->producerIndex = producer; // this is written to Tachyon // we have an ERQ slot! If SCSI command, need SEST slot // otherwise we are done. // Note that Tachyon requires that bit 15 of the OX_ID or RX_ID be // set according to direction of data to/from Tachyon for SEST assists. // For consistency, enforce this rule for Link Service (non-SEST) // exchanges as well. // fix-up the X_ID field in IRB pExchange->IRB.Req_A_Trans_ID = ExchangeID & 0x7FFF; // 15-bit field // fix-up the X_ID field in fchs -- depends on Originator or Responder, // outgoing or incoming data? switch( pExchange->type ) { // ORIGINATOR types... we're setting our OX_ID and // defaulting the responder's RX_ID to 0xFFFF case SCSI_IRE: // Requirement: set MSB of x_ID for Incoming TL data // (see "Tachyon TL/TS User's Manual", Rev 6.0, Sept.'98, pg. 50) InboundData = 0x8000; case SCSI_IWE: SestType = TRUE; pExchange->fchs.ox_rx_id = (ExchangeID | InboundData); pExchange->fchs.ox_rx_id <<= 16; // MSW shift pExchange->fchs.ox_rx_id |= 0xffff; // add default RX_ID // now fix-up the Data HDR OX_ID (TL automatically does rx_id) // (not necessary for IRE -- data buffer unused) if( pExchange->type == SCSI_IWE) { fcChip->SEST->DataHDR[ ExchangeID ].ox_rx_id = pExchange->fchs.ox_rx_id; } break; case FCS_NSR: // ext. link service Name Service Request case ELS_SCR: // ext. link service State Change Registration case ELS_FDISC:// ext. link service login case ELS_FLOGI:// ext. link service login case ELS_LOGO: // FC-PH extended link service logout case BLS_NOP: // Basic link service No OPeration case ELS_PLOGI:// ext. link service login (PLOGI) case ELS_PDISC:// ext. link service login (PDISC) case ELS_PRLI: // ext. link service process login pExchange->fchs.ox_rx_id = ExchangeID; pExchange->fchs.ox_rx_id <<= 16; // MSW shift pExchange->fchs.ox_rx_id |= 0xffff; // and RX_ID break; // RESPONDER types... we must set our RX_ID while preserving // sender's OX_ID // outgoing (or no) data case ELS_RJT: // extended link service reject case ELS_LOGO_ACC: // FC-PH extended link service logout accept case ELS_ACC: // ext. generic link service accept case ELS_PLOGI_ACC:// ext. link service login accept (PLOGI or PDISC) case ELS_PRLI_ACC: // ext. link service process login accept CompleteExchange = TRUE; // Reply (ACC or RJT) is end of exchange pExchange->fchs.ox_rx_id |= (ExchangeID & 0xFFFF); break; // since we are a Responder, OX_ID should already be set by // cpqfcTSBuildExchange(). We need to -OR- in RX_ID case SCSI_TWE: SestType = TRUE; // Requirement: set MSB of x_ID for Incoming TL data // (see "Tachyon TL/TS User's Manual", Rev 6.0, Sept.'98, pg. 50) pExchange->fchs.ox_rx_id &= 0xFFFF0000; // clear RX_ID // Requirement: set MSB of RX_ID for Incoming TL data // (see "Tachyon TL/TS User's Manual", Rev 6.0, Sept.'98, pg. 50) pExchange->fchs.ox_rx_id |= (ExchangeID | 0x8000); break; case SCSI_TRE: SestType = TRUE; // there is no XRDY for SEST target read; the data // header needs to be updated. Also update the RSP // exchange IDs for the status frame, in case it is sent automatically fcChip->SEST->DataHDR[ ExchangeID ].ox_rx_id |= ExchangeID; fcChip->SEST->RspHDR[ ExchangeID ].ox_rx_id = fcChip->SEST->DataHDR[ ExchangeID ].ox_rx_id; // for easier FCP response logic (works for TWE and TRE), // copy exchange IDs. (Not needed if TRE 'RSP' bit set) pExchange->fchs.ox_rx_id = fcChip->SEST->DataHDR[ ExchangeID ].ox_rx_id; break; case FCP_RESPONSE: // using existing OX_ID/ RX_ID pair, // start SFS FCP-RESPONSE frame // OX/RX_ID should already be set! (See "fcBuild" above) CompleteExchange = TRUE; // RSP is end of FCP-SCSI exchange break; case BLS_ABTS_RJT: // uses new RX_ID, since SEST x_ID non-existent case BLS_ABTS_ACC: // using existing OX_ID/ RX_ID pair from SEST entry CompleteExchange = TRUE; // ACC or RJT marks end of FCP-SCSI exchange case BLS_ABTS: // using existing OX_ID/ RX_ID pair from SEST entry break; default: printk("Error on fcStartExchange: undefined type %Xh(%d)\n", pExchange->type, pExchange->type); return INVALID_ARGS; } // X_ID fields are entered -- copy IRB to Tachyon's ERQ memcpy( &fcChip->ERQ->QEntry[ ErqIndex ], // dest. &pExchange->IRB, 32); // fixed (hardware) length! PCI_TRACEO( ExchangeID, 0xA0) // ACTION! May generate INT and IMQ entry writel( fcChip->ERQ->producerIndex, fcChip->Registers.ERQproducerIndex.address); if( ExchangeID >= TACH_SEST_LEN ) // Link Service Outbound frame? { // wait for completion! (TDB -- timeout and chip reset) PCI_TRACEO( ExchangeID, 0xA4) enable_irq( cpqfcHBAdata->HostAdapter->irq); // only way to get Sem. down_interruptible( cpqfcHBAdata->TYOBcomplete); disable_irq( cpqfcHBAdata->HostAdapter->irq); PCI_TRACE( 0xA4) // On login exchanges, BAD_ALPA (non-existent port_id) results in // FTO (Frame Time Out) on the Outbound Completion message. // If we got an FTO status, complete the exchange (free up slot) if( CompleteExchange || // flag from Reply frames pExchange->status ) // typically, can get FRAME_TO { cpqfcTSCompleteExchange( cpqfcHBAdata->PciDev, fcChip, ExchangeID); } } else // SEST Exchange { ulStatus = 0; // ship & pray success (e.g. FCP-SCSI) if( CompleteExchange ) // by Type of exchange (e.g. end-of-xchng) { cpqfcTSCompleteExchange( cpqfcHBAdata->PciDev, fcChip, ExchangeID); } else pExchange->status &= ~EXCHANGE_QUEUED; // clear ExchangeQueued flag } } else // ERQ 'producer' = 'consumer' and QUE is full { ulStatus = OUTQUE_FULL; // Outbound (ERQ) Que full } Done: PCI_TRACE( 0xA0) return ulStatus; } // Scan fcController->fcExchanges array for a usuable index (a "free" // exchange). // Inputs: // fcChip - pointer to TachLite chip structure // Return: // index - exchange array element where exchange can be built // -1 - exchange array is full // REMARKS: // Although this is a (yuk!) linear search, we presume // that the system will complete exchanges about as quickly as // they are submitted. A full Exchange array (and hence, max linear // search time for free exchange slot) almost guarantees a Fibre problem // of some sort. // In the interest of making exchanges easier to debug, we want a LRU // (Least Recently Used) scheme. static LONG FindFreeExchange( PTACHYON fcChip, ULONG type ) { FC_EXCHANGES *Exchanges = fcChip->Exchanges; ULONG i; ULONG ulStatus=-1; // assume failure if( type == SCSI_IRE || type == SCSI_TRE || type == SCSI_IWE || type == SCSI_TWE) { // SCSI type - X_IDs should be from 0 to TACH_SEST_LEN-1 if( fcChip->fcSestExchangeLRU >= TACH_SEST_LEN) // rollover? fcChip->fcSestExchangeLRU = 0; i = fcChip->fcSestExchangeLRU; // typically it's already free! if( Exchanges->fcExchange[i].type == 0 ) // check for "free" element { ulStatus = 0; // success! } else { // YUK! we need to do a linear search for free element. // Fragmentation of the fcExchange array is due to excessively // long completions or timeouts. while( TRUE ) { if( ++i >= TACH_SEST_LEN ) // rollover check i = 0; // beginning of SEST X_IDs // printk( "looping for SCSI xchng ID: i=%d, type=%Xh\n", // i, Exchanges->fcExchange[i].type); if( Exchanges->fcExchange[i].type == 0 ) // "free"? { ulStatus = 0; // success! break; } if( i == fcChip->fcSestExchangeLRU ) // wrapped-around array? { printk( "SEST X_ID space full\n"); break; // failed - prevent inf. loop } } } fcChip->fcSestExchangeLRU = i + 1; // next! (rollover check next pass) } else // Link Service type - X_IDs should be from TACH_SEST_LEN // to TACH_MAX_XID { if( fcChip->fcLsExchangeLRU >= TACH_MAX_XID || // range check fcChip->fcLsExchangeLRU < TACH_SEST_LEN ) // (e.g. startup) fcChip->fcLsExchangeLRU = TACH_SEST_LEN; i = fcChip->fcLsExchangeLRU; // typically it's already free! if( Exchanges->fcExchange[i].type == 0 ) // check for "free" element { ulStatus = 0; // success! } else { // YUK! we need to do a linear search for free element // Fragmentation of the fcExchange array is due to excessively // long completions or timeouts. while( TRUE ) { if( ++i >= TACH_MAX_XID ) // rollover check i = TACH_SEST_LEN;// beginning of Link Service X_IDs // printk( "looping for xchng ID: i=%d, type=%Xh\n", // i, Exchanges->fcExchange[i].type); if( Exchanges->fcExchange[i].type == 0 ) // "free"? { ulStatus = 0; // success! break; } if( i == fcChip->fcLsExchangeLRU ) // wrapped-around array? { printk( "LinkService X_ID space full\n"); break; // failed - prevent inf. loop } } } fcChip->fcLsExchangeLRU = i + 1; // next! (rollover check next pass) } if( !ulStatus ) // success? Exchanges->fcExchange[i].type = type; // allocate it. else i = -1; // error - all exchanges "open" return i; } static void cpqfc_pci_unmap_extended_sg(struct pci_dev *pcidev, PTACHYON fcChip, ULONG x_ID) { // Unmaps the memory regions used to hold the scatter gather lists PSGPAGES i; // Were there any such regions needing unmapping? if (! USES_EXTENDED_SGLIST(fcChip->SEST, x_ID)) return; // No such regions, we're outta here. // for each extended scatter gather region needing unmapping... for (i=fcChip->SEST->sgPages[x_ID] ; i != NULL ; i = i->next) pci_unmap_single(pcidev, i->busaddr, i->maplen, PCI_DMA_TODEVICE); } // Called also from cpqfcTScontrol.o, so can't be static void cpqfc_pci_unmap(struct pci_dev *pcidev, Scsi_Cmnd *cmd, PTACHYON fcChip, ULONG x_ID) { // Undo the DMA mappings if (cmd->use_sg) { // Used scatter gather list for data buffer? cpqfc_pci_unmap_extended_sg(pcidev, fcChip, x_ID); pci_unmap_sg(pcidev, cmd->buffer, cmd->use_sg, cmd->sc_data_direction); // printk("umsg %d\n", cmd->use_sg); } else if (cmd->request_bufflen) { // printk("ums %p ", fcChip->SEST->u[ x_ID ].IWE.GAddr1); pci_unmap_single(pcidev, fcChip->SEST->u[ x_ID ].IWE.GAddr1, cmd->request_bufflen, cmd->sc_data_direction); } } // We call this routine to free an Exchange for any reason: // completed successfully, completed with error, aborted, etc. // returns FALSE if Exchange failed and "retry" is acceptable // returns TRUE if Exchange was successful, or retry is impossible // (e.g. port/device gone). //scompleteexchange void cpqfcTSCompleteExchange( struct pci_dev *pcidev, PTACHYON fcChip, ULONG x_ID) { FC_EXCHANGES *Exchanges = fcChip->Exchanges; int already_unmapped = 0; if( x_ID < TACH_SEST_LEN ) // SEST-based (or LinkServ for FCP exchange) { if( Exchanges->fcExchange[ x_ID ].Cmnd == NULL ) // what#@! { // TriggerHBA( fcChip->Registers.ReMapMemBase, 0); printk(" x_ID %Xh, type %Xh, NULL ptr!\n", x_ID, Exchanges->fcExchange[ x_ID ].type); goto CleanUpSestResources; // this path should be very rare. } // we have Linux Scsi Cmnd ptr..., now check our Exchange status // to decide how to complete this SEST FCP exchange if( Exchanges->fcExchange[ x_ID ].status ) // perhaps a Tach indicated problem, // or abnormal exchange completion { // set FCP Link statistics if( Exchanges->fcExchange[ x_ID ].status & FC2_TIMEOUT) fcChip->fcStats.timeouts++; if( Exchanges->fcExchange[ x_ID ].status & INITIATOR_ABORT) fcChip->fcStats.FC4aborted++; if( Exchanges->fcExchange[ x_ID ].status & COUNT_ERROR) fcChip->fcStats.CntErrors++; if( Exchanges->fcExchange[ x_ID ].status & LINKFAIL_TX) fcChip->fcStats.linkFailTX++; if( Exchanges->fcExchange[ x_ID ].status & LINKFAIL_RX) fcChip->fcStats.linkFailRX++; if( Exchanges->fcExchange[ x_ID ].status & OVERFLOW) fcChip->fcStats.CntErrors++; // First, see if the Scsi upper level initiated an ABORT on this // exchange... if( Exchanges->fcExchange[ x_ID ].status == INITIATOR_ABORT ) { printk(" DID_ABORT, x_ID %Xh, Cmnd %p ", x_ID, Exchanges->fcExchange[ x_ID ].Cmnd); goto CleanUpSestResources; // (we don't expect Linux _aborts) } // Did our driver timeout the Exchange, or did Tachyon indicate // a failure during transmission? Ask for retry with "SOFT_ERROR" else if( Exchanges->fcExchange[ x_ID ].status & FC2_TIMEOUT) { // printk("result DID_SOFT_ERROR, x_ID %Xh, Cmnd %p\n", // x_ID, Exchanges->fcExchange[ x_ID ].Cmnd); Exchanges->fcExchange[ x_ID ].Cmnd->result = (DID_SOFT_ERROR <<16); } // Did frame(s) for an open exchange arrive in the SFQ, // meaning the SEST was unable to process them? else if( Exchanges->fcExchange[ x_ID ].status & SFQ_FRAME) { // printk("result DID_SOFT_ERROR, x_ID %Xh, Cmnd %p\n", // x_ID, Exchanges->fcExchange[ x_ID ].Cmnd); Exchanges->fcExchange[ x_ID ].Cmnd->result = (DID_SOFT_ERROR <<16); } // Did our driver timeout the Exchange, or did Tachyon indicate // a failure during transmission? Ask for retry with "SOFT_ERROR" else if( (Exchanges->fcExchange[ x_ID ].status & LINKFAIL_TX) || (Exchanges->fcExchange[ x_ID ].status & PORTID_CHANGED) || (Exchanges->fcExchange[ x_ID ].status & FRAME_TO) || (Exchanges->fcExchange[ x_ID ].status & INV_ENTRY) || (Exchanges->fcExchange[ x_ID ].status & ABORTSEQ_NOTIFY) ) { // printk("result DID_SOFT_ERROR, x_ID %Xh, Cmnd %p\n", // x_ID, Exchanges->fcExchange[ x_ID ].Cmnd); Exchanges->fcExchange[ x_ID ].Cmnd->result = (DID_SOFT_ERROR <<16); } // e.g., a LOGOut happened, or device never logged back in. else if( Exchanges->fcExchange[ x_ID ].status & DEVICE_REMOVED) { // printk(" *LOGOut or timeout on login!* "); // trigger? // TriggerHBA( fcChip->Registers.ReMapMemBase, 0); Exchanges->fcExchange[ x_ID ].Cmnd->result = (DID_BAD_TARGET <<16); } // Did Tachyon indicate a CNT error? We need further analysis // to determine if the exchange is acceptable else if( Exchanges->fcExchange[ x_ID ].status == COUNT_ERROR) { UCHAR ScsiStatus; FCP_STATUS_RESPONSE *pFcpStatus = (PFCP_STATUS_RESPONSE)&fcChip->SEST->RspHDR[ x_ID ].pl; ScsiStatus = pFcpStatus->fcp_status >>24; // If the command is a SCSI Read/Write type, we don't tolerate // count errors of any kind; assume the count error is due to // a dropped frame and ask for retry... if(( (Exchanges->fcExchange[ x_ID ].Cmnd->cmnd[0] == 0x8) || (Exchanges->fcExchange[ x_ID ].Cmnd->cmnd[0] == 0x28) || (Exchanges->fcExchange[ x_ID ].Cmnd->cmnd[0] == 0xA) || (Exchanges->fcExchange[ x_ID ].Cmnd->cmnd[0] == 0x2A) ) && ScsiStatus == 0 ) { // ask for retry /* printk("COUNT_ERROR retry, x_ID %Xh, status %Xh, Cmnd %p\n", x_ID, Exchanges->fcExchange[ x_ID ].status, Exchanges->fcExchange[ x_ID ].Cmnd);*/ Exchanges->fcExchange[ x_ID ].Cmnd->result = (DID_SOFT_ERROR <<16); } else // need more analysis { cpqfcTSCheckandSnoopFCP(fcChip, x_ID); // (will set ->result) } } // default: NOTE! We don't ever want to get here. Getting here // implies something new is happening that we've never had a test // case for. Need code maintenance! Return "ERROR" else { unsigned int stat = Exchanges->fcExchange[ x_ID ].status; printk("DEFAULT result %Xh, x_ID %Xh, Cmnd %p", Exchanges->fcExchange[ x_ID ].status, x_ID, Exchanges->fcExchange[ x_ID ].Cmnd); if (stat & INVALID_ARGS) printk(" INVALID_ARGS "); if (stat & LNKDWN_OSLS) printk(" LNKDWN_OSLS "); if (stat & LNKDWN_LASER) printk(" LNKDWN_LASER "); if (stat & OUTQUE_FULL) printk(" OUTQUE_FULL "); if (stat & DRIVERQ_FULL) printk(" DRIVERQ_FULL "); if (stat & SEST_FULL) printk(" SEST_FULL "); if (stat & BAD_ALPA) printk(" BAD_ALPA "); if (stat & OVERFLOW) printk(" OVERFLOW "); if (stat & COUNT_ERROR) printk(" COUNT_ERROR "); if (stat & LINKFAIL_RX) printk(" LINKFAIL_RX "); if (stat & ABORTSEQ_NOTIFY) printk(" ABORTSEQ_NOTIFY "); if (stat & LINKFAIL_TX) printk(" LINKFAIL_TX "); if (stat & HOSTPROG_ERR) printk(" HOSTPROG_ERR "); if (stat & FRAME_TO) printk(" FRAME_TO "); if (stat & INV_ENTRY) printk(" INV_ENTRY "); if (stat & SESTPROG_ERR) printk(" SESTPROG_ERR "); if (stat & OUTBOUND_TIMEOUT) printk(" OUTBOUND_TIMEOUT "); if (stat & INITIATOR_ABORT) printk(" INITIATOR_ABORT "); if (stat & MEMPOOL_FAIL) printk(" MEMPOOL_FAIL "); if (stat & FC2_TIMEOUT) printk(" FC2_TIMEOUT "); if (stat & TARGET_ABORT) printk(" TARGET_ABORT "); if (stat & EXCHANGE_QUEUED) printk(" EXCHANGE_QUEUED "); if (stat & PORTID_CHANGED) printk(" PORTID_CHANGED "); if (stat & DEVICE_REMOVED) printk(" DEVICE_REMOVED "); if (stat & SFQ_FRAME) printk(" SFQ_FRAME "); printk("\n"); Exchanges->fcExchange[ x_ID ].Cmnd->result = (DID_ERROR <<16); } } else // definitely no Tach problem, but perhaps an FCP problem { // set FCP Link statistic fcChip->fcStats.ok++; cpqfcTSCheckandSnoopFCP( fcChip, x_ID); // (will set ->result) } cpqfc_pci_unmap(pcidev, Exchanges->fcExchange[x_ID].Cmnd, fcChip, x_ID); // undo DMA mappings. already_unmapped = 1; // OK, we've set the Scsi "->result" field, so proceed with calling // Linux Scsi "done" (if not NULL), and free any kernel memory we // may have allocated for the exchange. PCI_TRACEO( (ULONG)Exchanges->fcExchange[x_ID].Cmnd, 0xAC); // complete the command back to upper Scsi drivers if( Exchanges->fcExchange[ x_ID ].Cmnd->scsi_done != NULL) { // Calling "done" on an Linux _abort() aborted // Cmnd causes a kernel panic trying to re-free mem. // Actually, we shouldn't do anything with an _abort CMND if( Exchanges->fcExchange[ x_ID ].Cmnd->result != (DID_ABORT<<16) ) { PCI_TRACE(0xAC) call_scsi_done(Exchanges->fcExchange[ x_ID ].Cmnd); } else { // printk(" not calling scsi_done on x_ID %Xh, Cmnd %p\n", // x_ID, Exchanges->fcExchange[ x_ID ].Cmnd); } } else{ printk(" x_ID %Xh, type %Xh, Cdb0 %Xh\n", x_ID, Exchanges->fcExchange[ x_ID ].type, Exchanges->fcExchange[ x_ID ].Cmnd->cmnd[0]); printk(" cpqfcTS: Null scsi_done function pointer!\n"); } // Now, clean up non-Scsi_Cmnd items... CleanUpSestResources: if (!already_unmapped) cpqfc_pci_unmap(pcidev, Exchanges->fcExchange[x_ID].Cmnd, fcChip, x_ID); // undo DMA mappings. // Was an Extended Scatter/Gather page allocated? We know // this by checking DWORD 4, bit 31 ("LOC") of SEST entry if( !(fcChip->SEST->u[ x_ID ].IWE.Buff_Off & 0x80000000)) { PSGPAGES p, next; // extended S/G list was used -- Free the allocated ext. S/G pages for (p = fcChip->SEST->sgPages[x_ID]; p != NULL; p = next) { next = p->next; kfree(p); } fcChip->SEST->sgPages[x_ID] = NULL; } Exchanges->fcExchange[ x_ID ].Cmnd = NULL; } // Done with FCP (SEST) exchanges // the remaining logic is common to ALL Exchanges: // FCP(SEST) and LinkServ. Exchanges->fcExchange[ x_ID ].type = 0; // there -- FREE! Exchanges->fcExchange[ x_ID ].status = 0; PCI_TRACEO( x_ID, 0xAC) return; } // (END of CompleteExchange function) // Unfortunately, we must snoop all command completions in // order to manipulate certain return fields, and take note of // device types, etc., to facilitate the Fibre-Channel to SCSI // "mapping". // (Watch for BIG Endian confusion on some payload fields) void cpqfcTSCheckandSnoopFCP( PTACHYON fcChip, ULONG x_ID) { FC_EXCHANGES *Exchanges = fcChip->Exchanges; Scsi_Cmnd *Cmnd = Exchanges->fcExchange[ x_ID].Cmnd; FCP_STATUS_RESPONSE *pFcpStatus = (PFCP_STATUS_RESPONSE)&fcChip->SEST->RspHDR[ x_ID ].pl; UCHAR ScsiStatus; ScsiStatus = pFcpStatus->fcp_status >>24; #ifdef FCP_COMPLETION_DBG printk("ScsiStatus = 0x%X\n", ScsiStatus); #endif // First, check FCP status if( pFcpStatus->fcp_status & FCP_RSP_LEN_VALID ) { // check response code (RSP_CODE) -- most popular is bad len // 1st 4 bytes of rsp info -- only byte 3 interesting if( pFcpStatus->fcp_rsp_info & FCP_DATA_LEN_NOT_BURST_LEN ) { // do we EVER get here? printk("cpqfcTS: FCP data len not burst len, x_ID %Xh\n", x_ID); } } // for now, go by the ScsiStatus, and manipulate certain // commands when necessary... if( ScsiStatus == 0) // SCSI status byte "good"? { Cmnd->result = 0; // everything's OK if( (Cmnd->cmnd[0] == INQUIRY)) { UCHAR *InquiryData = Cmnd->request_buffer; PFC_LOGGEDIN_PORT pLoggedInPort; // We need to manipulate INQUIRY // strings for COMPAQ RAID controllers to force // Linux to scan additional LUNs. Namely, set // the Inquiry string byte 2 (ANSI-approved version) // to 2. if( !memcmp( &InquiryData[8], "COMPAQ", 6 )) { InquiryData[2] = 0x2; // claim SCSI-2 compliance, // so multiple LUNs may be scanned. // (no SCSI-2 problems known in CPQ) } // snoop the Inquiry to detect Disk, Tape, etc. type // (search linked list for the port_id we sent INQUIRY to) pLoggedInPort = fcFindLoggedInPort( fcChip, NULL, // DON'T search Scsi Nexus (we will set it) Exchanges->fcExchange[ x_ID].fchs.d_id & 0xFFFFFF, NULL, // DON'T search linked list for FC WWN NULL); // DON'T care about end of list if( pLoggedInPort ) { pLoggedInPort->ScsiNexus.InqDeviceType = InquiryData[0]; } else { printk("cpqfcTS: can't find LoggedIn FC port %06X for INQUIRY\n", Exchanges->fcExchange[ x_ID].fchs.d_id & 0xFFFFFF); } } } // Scsi Status not good -- pass it back to caller else { Cmnd->result = ScsiStatus; // SCSI status byte is 1st // check for valid "sense" data if( pFcpStatus->fcp_status & FCP_SNS_LEN_VALID ) { // limit Scsi Sense field length! int SenseLen = pFcpStatus->fcp_sns_len >>24; // (BigEndian) lower byte SenseLen = SenseLen > sizeof( Cmnd->sense_buffer) ? sizeof( Cmnd->sense_buffer) : SenseLen; #ifdef FCP_COMPLETION_DBG printk("copy sense_buffer %p, len %d, result %Xh\n", Cmnd->sense_buffer, SenseLen, Cmnd->result); #endif // NOTE: There is some dispute over the FCP response // format. Most FC devices assume that FCP_RSP_INFO // is 8 bytes long, in spite of the fact that FCP_RSP_LEN // is (virtually) always 0 and the field is "invalid". // Some other devices assume that // the FCP_SNS_INFO begins after FCP_RSP_LEN bytes (i.e. 0) // when the FCP_RSP is invalid (this almost appears to be // one of those "religious" issues). // Consequently, we test the usual position of FCP_SNS_INFO // for 7Xh, since the SCSI sense format says the first // byte ("error code") should be 0x70 or 0x71. In practice, // we find that every device does in fact have 0x70 or 0x71 // in the first byte position, so this test works for all // FC devices. // (This logic is especially effective for the CPQ/DEC HSG80 // & HSG60 controllers). if( (pFcpStatus->fcp_sns_info[0] & 0x70) == 0x70 ) memcpy( Cmnd->sense_buffer, &pFcpStatus->fcp_sns_info[0], SenseLen); else { unsigned char *sbPtr = (unsigned char *)&pFcpStatus->fcp_sns_info[0]; sbPtr -= 8; // back up 8 bytes hoping to find the // start of the sense buffer memcpy( Cmnd->sense_buffer, sbPtr, SenseLen); } // in the special case of Device Reset, tell upper layer // to immediately retry (with SOFT_ERROR status) // look for Sense Key Unit Attention (0x6) with ASC Device // Reset (0x29) // printk("SenseLen %d, Key = 0x%X, ASC = 0x%X\n", // SenseLen, Cmnd->sense_buffer[2], // Cmnd->sense_buffer[12]); if( ((Cmnd->sense_buffer[2] & 0xF) == 0x6) && (Cmnd->sense_buffer[12] == 0x29) ) // Sense Code "reset" { Cmnd->result |= (DID_SOFT_ERROR << 16); // "Host" status byte 3rd } // check for SenseKey "HARDWARE ERROR", ASC InternalTargetFailure else if( ((Cmnd->sense_buffer[2] & 0xF) == 0x4) && // "hardware error" (Cmnd->sense_buffer[12] == 0x44) ) // Addtl. Sense Code { // printk("HARDWARE_ERROR, Channel/Target/Lun %d/%d/%d\n", // Cmnd->channel, Cmnd->target, Cmnd->lun); Cmnd->result |= (DID_ERROR << 16); // "Host" status byte 3rd } } // (end of sense len valid) // there is no sense data to help out Linux's Scsi layers... // We'll just return the Scsi status and hope he will "do the // right thing" else { // as far as we know, the Scsi status is sufficient Cmnd->result |= (DID_OK << 16); // "Host" status byte 3rd } } } //PPPPPPPPPPPPPPPPPPPPPPPPP PAYLOAD PPPPPPPPP // build data PAYLOAD; SCSI FCP_CMND I.U. // remember BIG ENDIAN payload - DWord values must be byte-reversed // (hence the affinity for byte pointer building). static int build_FCP_payload( Scsi_Cmnd *Cmnd, UCHAR* payload, ULONG type, ULONG fcp_dl ) { int i; switch( type) { case SCSI_IWE: case SCSI_IRE: // 8 bytes FCP_LUN // Peripheral Device or Volume Set addressing, and LUN mapping // When the FC port was looked up, we copied address mode // and any LUN mask to the scratch pad SCp.phase & .mode *payload++ = (UCHAR)Cmnd->SCp.phase; // Now, because of "lun masking" // (aka selective storage presentation), // the contiguous Linux Scsi lun number may not match the // device's lun number, so we may have to "map". *payload++ = (UCHAR)Cmnd->SCp.have_data_in; // We don't know of anyone in the FC business using these // extra "levels" of addressing. In fact, confusion still exists // just using the FIRST level... ;-) *payload++ = 0; // 2nd level addressing *payload++ = 0; *payload++ = 0; // 3rd level addressing *payload++ = 0; *payload++ = 0; // 4th level addressing *payload++ = 0; // 4 bytes Control Field FCP_CNTL *payload++ = 0; // byte 0: (MSB) reserved *payload++ = 0; // byte 1: task codes // byte 2: task management flags // another "use" of the spare field to accomplish TDR // note combination needed if( (Cmnd->cmnd[0] == RELEASE) && (Cmnd->SCp.buffers_residual == FCP_TARGET_RESET) ) { Cmnd->cmnd[0] = 0; // issue "Test Unit Ready" for TDR *payload++ = 0x20; // target device reset bit } else *payload++ = 0; // no TDR // byte 3: (LSB) execution management codes // bit 0 write, bit 1 read (don't set together) if( fcp_dl != 0 ) { if( type == SCSI_IWE ) // WRITE *payload++ = 1; else // READ *payload++ = 2; } else { // On some devices, if RD or WR bits are set, // and fcp_dl is 0, they will generate an error on the command. // (i.e., if direction is specified, they insist on a length). *payload++ = 0; // no data (necessary for CPQ) } // NOTE: clean this up if/when MAX_COMMAND_SIZE is increased to 16 // FCP_CDB allows 16 byte SCSI command descriptor blk; // Linux SCSI CDB array is MAX_COMMAND_SIZE (12 at this time...) for( i=0; (i < Cmnd->cmd_len) && i < MAX_COMMAND_SIZE; i++) *payload++ = Cmnd->cmnd[i]; // if( Cmnd->cmd_len == 16 ) // { // memcpy( payload, &Cmnd->SCp.buffers_residual, 4); // } payload+= (16 - i); // FCP_DL is largest number of expected data bytes // per CDB (i.e. read/write command) *payload++ = (UCHAR)(fcp_dl >>24); // (MSB) 8 bytes data len FCP_DL *payload++ = (UCHAR)(fcp_dl >>16); *payload++ = (UCHAR)(fcp_dl >>8); *payload++ = (UCHAR)fcp_dl; // (LSB) break; case SCSI_TWE: // need FCP_XFER_RDY *payload++ = 0; // (4 bytes) DATA_RO (MSB byte 0) *payload++ = 0; *payload++ = 0; *payload++ = 0; // LSB (byte 3) // (4 bytes) BURST_LEN // size of following FCP_DATA payload *payload++ = (UCHAR)(fcp_dl >>24); // (MSB) 8 bytes data len FCP_DL *payload++ = (UCHAR)(fcp_dl >>16); *payload++ = (UCHAR)(fcp_dl >>8); *payload++ = (UCHAR)fcp_dl; // (LSB) // 4 bytes RESERVED *payload++ = 0; *payload++ = 0; *payload++ = 0; *payload++ = 0; break; default: break; } return 0; }