AuxXxilium/linux_dsm_epyc7002
1
0
Fork 0
mirror of https://github.com/AuxXxilium/linux_dsm_epyc7002.git synced 2024-11-30 04:56:43 +07:00
Code Issues Actions Packages Projects Releases Wiki Activity
f68bcc2df8
linux_dsm_epyc7002/drivers/scsi/cpqfcTSworker.c
be7db055dd [PATCH] remove old scsi data direction macros 
these have been wrappers for the generic dma direction bits since 2.5.x.
This patch converts the few remaining drivers and removes the macros.

Arjan noticed there's some hunk in here that shouldn't.  Updated patch
below:

Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2005-04-18 13:49:58 -05:00

6517 lines
207 KiB
C
Raw Blame History

/* 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(&current->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;
}
Reference in New Issue View Git Blame Copy Permalink