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