aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/scsi/cpqfcTSworker.c
diff options
context:
space:
mode:
authorLinus Torvalds <torvalds@ppc970.osdl.org>2005-04-16 18:20:36 -0400
committerLinus Torvalds <torvalds@ppc970.osdl.org>2005-04-16 18:20:36 -0400
commit1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 (patch)
tree0bba044c4ce775e45a88a51686b5d9f90697ea9d /drivers/scsi/cpqfcTSworker.c
Linux-2.6.12-rc2v2.6.12-rc2
Initial git repository build. I'm not bothering with the full history, even though we have it. We can create a separate "historical" git archive of that later if we want to, and in the meantime it's about 3.2GB when imported into git - space that would just make the early git days unnecessarily complicated, when we don't have a lot of good infrastructure for it. Let it rip!
Diffstat (limited to 'drivers/scsi/cpqfcTSworker.c')
-rw-r--r--drivers/scsi/cpqfcTSworker.c6516
1 files changed, 6516 insertions, 0 deletions
diff --git a/drivers/scsi/cpqfcTSworker.c b/drivers/scsi/cpqfcTSworker.c
new file mode 100644
index 000000000000..a5fd7427e9da
--- /dev/null
+++ b/drivers/scsi/cpqfcTSworker.c
@@ -0,0 +1,6516 @@
1/* Copyright(c) 2000, Compaq Computer Corporation
2 * Fibre Channel Host Bus Adapter
3 * 64-bit, 66MHz PCI
4 * Originally developed and tested on:
5 * (front): [chip] Tachyon TS HPFC-5166A/1.2 L2C1090 ...
6 * SP# P225CXCBFIEL6T, Rev XC
7 * SP# 161290-001, Rev XD
8 * (back): Board No. 010008-001 A/W Rev X5, FAB REV X5
9 *
10 * This program is free software; you can redistribute it and/or modify it
11 * under the terms of the GNU General Public License as published by the
12 * Free Software Foundation; either version 2, or (at your option) any
13 * later version.
14 *
15 * This program is distributed in the hope that it will be useful, but
16 * WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * General Public License for more details.
19 * Written by Don Zimmerman
20*/
21
22#include <linux/sched.h>
23#include <linux/timer.h>
24#include <linux/string.h>
25#include <linux/slab.h>
26#include <linux/ioport.h>
27#include <linux/kernel.h>
28#include <linux/stat.h>
29#include <linux/blkdev.h>
30#include <linux/interrupt.h>
31#include <linux/delay.h>
32#include <linux/smp_lock.h>
33#include <linux/pci.h>
34
35#define SHUTDOWN_SIGS (sigmask(SIGKILL)|sigmask(SIGINT)|sigmask(SIGTERM))
36
37#include <asm/system.h>
38#include <asm/irq.h>
39#include <asm/dma.h>
40
41#include "scsi.h"
42#include <scsi/scsi_host.h> // struct Scsi_Host definition for T handler
43#include "cpqfcTSchip.h"
44#include "cpqfcTSstructs.h"
45#include "cpqfcTStrigger.h"
46
47//#define LOGIN_DBG 1
48
49// REMARKS:
50// Since Tachyon chips may be permitted to wait from 500ms up to 2 sec
51// to empty an outgoing frame from its FIFO to the Fibre Channel stream,
52// we cannot do everything we need to in the interrupt handler. Specifically,
53// every time a link re-init (e.g. LIP) takes place, all SCSI I/O has to be
54// suspended until the login sequences have been completed. Login commands
55// are frames just like SCSI commands are frames; they are subject to the same
56// timeout issues and delays. Also, various specs provide up to 2 seconds for
57// devices to log back in (i.e. respond with ACC to a login frame), so I/O to
58// that device has to be suspended.
59// A serious problem here occurs on highly loaded FC-AL systems. If our FC port
60// has a low priority (e.g. high arbitrated loop physical address, alpa), and
61// some other device is hogging bandwidth (permissible under FC-AL), we might
62// time out thinking the link is hung, when it's simply busy. Many such
63// considerations complicate the design. Although Tachyon assumes control
64// (in silicon) for many link-specific issues, the Linux driver is left with the
65// rest, which turns out to be a difficult, time critical chore.
66
67// These "worker" functions will handle things like FC Logins; all
68// processes with I/O to our device must wait for the Login to complete
69// and (if successful) I/O to resume. In the event of a malfunctioning or
70// very busy loop, it may take hundreds of millisecs or even seconds to complete
71// a frame send. We don't want to hang up the entire server (and all
72// processes which don't depend on Fibre) during this wait.
73
74// The Tachyon chip can have around 30,000 I/O operations ("exchanges")
75// open at one time. However, each exchange must be initiated
76// synchronously (i.e. each of the 30k I/O had to be started one at a
77// time by sending a starting frame via Tachyon's outbound que).
78
79// To accommodate kernel "module" build, this driver limits the exchanges
80// to 256, because of the contiguous physical memory limitation of 128M.
81
82// Typical FC Exchanges are opened presuming the FC frames start without errors,
83// while Exchange completion is handled in the interrupt handler. This
84// optimizes performance for the "everything's working" case.
85// However, when we have FC related errors or hot plugging of FC ports, we pause
86// I/O and handle FC-specific tasks in the worker thread. These FC-specific
87// functions will handle things like FC Logins and Aborts. As the Login sequence
88// completes to each and every target, I/O can resume to that target.
89
90// Our kernel "worker thread" must share the HBA with threads calling
91// "queuecommand". We define a "BoardLock" semaphore which indicates
92// to "queuecommand" that the HBA is unavailable, and Cmnds are added to a
93// board lock Q. When the worker thread finishes with the board, the board
94// lock Q commands are completed with status causing immediate retry.
95// Typically, the board is locked while Logins are in progress after an
96// FC Link Down condition. When Cmnds are re-queued after board lock, the
97// particular Scsi channel/target may or may not have logged back in. When
98// the device is waiting for login, the "prli" flag is clear, in which case
99// commands are passed to a Link Down Q. Whenever the login finally completes,
100// the LinkDown Q is completed, again with status causing immediate retry.
101// When FC devices are logged in, we build and start FC commands to the
102// devices.
103
104// NOTE!! As of May 2000, kernel 2.2.14, the error recovery logic for devices
105// that never log back in (e.g. physically removed) is NOT completely
106// understood. I've still seen instances of system hangs on failed Write
107// commands (possibly from the ext2 layer?) on device removal. Such special
108// cases need to be evaluated from a system/application view - e.g., how
109// exactly does the system want me to complete commands when the device is
110// physically removed??
111
112// local functions
113
114static void SetLoginFields(
115 PFC_LOGGEDIN_PORT pLoggedInPort,
116 TachFCHDR_GCMND* fchs,
117 BOOLEAN PDisc,
118 BOOLEAN Originator);
119
120static void AnalyzeIncomingFrame(
121 CPQFCHBA *cpqfcHBAdata,
122 ULONG QNdx );
123
124static void SendLogins( CPQFCHBA *cpqfcHBAdata, __u32 *FabricPortIds );
125
126static int verify_PLOGI( PTACHYON fcChip,
127 TachFCHDR_GCMND* fchs, ULONG* reject_explain);
128static int verify_PRLI( TachFCHDR_GCMND* fchs, ULONG* reject_explain);
129
130static void LoadWWN( PTACHYON fcChip, UCHAR* dest, UCHAR type);
131static void BuildLinkServicePayload(
132 PTACHYON fcChip, ULONG type, void* payload);
133
134static void UnblockScsiDevice( struct Scsi_Host *HostAdapter,
135 PFC_LOGGEDIN_PORT pLoggedInPort);
136
137static void cpqfcTSCheckandSnoopFCP( PTACHYON fcChip, ULONG x_ID);
138
139static void CompleteBoardLockCmnd( CPQFCHBA *cpqfcHBAdata);
140
141static void RevalidateSEST( struct Scsi_Host *HostAdapter,
142 PFC_LOGGEDIN_PORT pLoggedInPort);
143
144static void IssueReportLunsCommand(
145 CPQFCHBA* cpqfcHBAdata,
146 TachFCHDR_GCMND* fchs);
147
148// (see scsi_error.c comments on kernel task creation)
149
150void cpqfcTSWorkerThread( void *host)
151{
152 struct Scsi_Host *HostAdapter = (struct Scsi_Host*)host;
153 CPQFCHBA *cpqfcHBAdata = (CPQFCHBA *)HostAdapter->hostdata;
154#ifdef PCI_KERNEL_TRACE
155 PTACHYON fcChip = &cpqfcHBAdata->fcChip;
156#endif
157 DECLARE_MUTEX_LOCKED(fcQueReady);
158 DECLARE_MUTEX_LOCKED(fcTYOBcomplete);
159 DECLARE_MUTEX_LOCKED(TachFrozen);
160 DECLARE_MUTEX_LOCKED(BoardLock);
161
162 ENTER("WorkerThread");
163
164 lock_kernel();
165 daemonize("cpqfcTS_wt_%d", HostAdapter->host_no);
166 siginitsetinv(&current->blocked, SHUTDOWN_SIGS);
167
168
169 cpqfcHBAdata->fcQueReady = &fcQueReady; // primary wait point
170 cpqfcHBAdata->TYOBcomplete = &fcTYOBcomplete;
171 cpqfcHBAdata->TachFrozen = &TachFrozen;
172
173
174 cpqfcHBAdata->worker_thread = current;
175
176 unlock_kernel();
177
178 if( cpqfcHBAdata->notify_wt != NULL )
179 up( cpqfcHBAdata->notify_wt); // OK to continue
180
181 while(1)
182 {
183 unsigned long flags;
184
185 down_interruptible( &fcQueReady); // wait for something to do
186
187 if (signal_pending(current) )
188 break;
189
190 PCI_TRACE( 0x90)
191 // first, take the IO lock so the SCSI upper layers can't call
192 // into our _quecommand function (this also disables INTs)
193 spin_lock_irqsave( HostAdapter->host_lock, flags); // STOP _que function
194 PCI_TRACE( 0x90)
195
196 CPQ_SPINLOCK_HBA( cpqfcHBAdata)
197 // next, set this pointer to indicate to the _quecommand function
198 // that the board is in use, so it should que the command and
199 // immediately return (we don't actually require the semaphore function
200 // in this driver rev)
201
202 cpqfcHBAdata->BoardLock = &BoardLock;
203
204 PCI_TRACE( 0x90)
205
206 // release the IO lock (and re-enable interrupts)
207 spin_unlock_irqrestore( HostAdapter->host_lock, flags);
208
209 // disable OUR HBA interrupt (keep them off as much as possible
210 // during error recovery)
211 disable_irq( cpqfcHBAdata->HostAdapter->irq);
212
213 // OK, let's process the Fibre Channel Link Q and do the work
214 cpqfcTS_WorkTask( HostAdapter);
215
216 // hopefully, no more "work" to do;
217 // re-enable our INTs for "normal" completion processing
218 enable_irq( cpqfcHBAdata->HostAdapter->irq);
219
220
221 cpqfcHBAdata->BoardLock = NULL; // allow commands to be queued
222 CPQ_SPINUNLOCK_HBA( cpqfcHBAdata)
223
224
225 // Now, complete any Cmnd we Q'd up while BoardLock was held
226
227 CompleteBoardLockCmnd( cpqfcHBAdata);
228
229
230 }
231 // hopefully, the signal was for our module exit...
232 if( cpqfcHBAdata->notify_wt != NULL )
233 up( cpqfcHBAdata->notify_wt); // yep, we're outta here
234}
235
236
237// Freeze Tachyon routine.
238// If Tachyon is already frozen, return FALSE
239// If Tachyon is not frozen, call freeze function, return TRUE
240//
241static BOOLEAN FreezeTach( CPQFCHBA *cpqfcHBAdata)
242{
243 PTACHYON fcChip = &cpqfcHBAdata->fcChip;
244 BOOLEAN FrozeTach = FALSE;
245 // It's possible that the chip is already frozen; if so,
246 // "Freezing" again will NOT! generate another Freeze
247 // Completion Message.
248
249 if( (fcChip->Registers.TYstatus.value & 0x70000) != 0x70000)
250 { // (need to freeze...)
251 fcChip->FreezeTachyon( fcChip, 2); // both ERQ and FCP assists
252
253 // 2. Get Tach freeze confirmation
254 // (synchronize SEST manipulation with Freeze Completion Message)
255 // we need INTs on so semaphore can be set.
256 enable_irq( cpqfcHBAdata->HostAdapter->irq); // only way to get Semaphore
257 down_interruptible( cpqfcHBAdata->TachFrozen); // wait for INT handler sem.
258 // can we TIMEOUT semaphore wait?? TBD
259 disable_irq( cpqfcHBAdata->HostAdapter->irq);
260
261 FrozeTach = TRUE;
262 } // (else, already frozen)
263
264 return FrozeTach;
265}
266
267
268
269
270// This is the kernel worker thread task, which processes FC
271// tasks which were queued by the Interrupt handler or by
272// other WorkTask functions.
273
274#define DBG 1
275//#undef DBG
276void cpqfcTS_WorkTask( struct Scsi_Host *HostAdapter)
277{
278 CPQFCHBA *cpqfcHBAdata = (CPQFCHBA *)HostAdapter->hostdata;
279 PTACHYON fcChip = &cpqfcHBAdata->fcChip;
280 FC_EXCHANGES *Exchanges = fcChip->Exchanges;
281 ULONG QconsumerNdx;
282 LONG ExchangeID;
283 ULONG ulStatus=0;
284 TachFCHDR_GCMND fchs;
285 PFC_LINK_QUE fcLQ = cpqfcHBAdata->fcLQ;
286
287 ENTER("WorkTask");
288
289 // copy current index to work on
290 QconsumerNdx = fcLQ->consumer;
291
292 PCI_TRACEO( fcLQ->Qitem[QconsumerNdx].Type, 0x90)
293
294
295 // NOTE: when this switch completes, we will "consume" the Que item
296// printk("Que type %Xh\n", fcLQ->Qitem[QconsumerNdx].Type);
297 switch( fcLQ->Qitem[QconsumerNdx].Type )
298 {
299 // incoming frame - link service (ACC, UNSOL REQ, etc.)
300 // or FCP-SCSI command
301 case SFQ_UNKNOWN:
302 AnalyzeIncomingFrame( cpqfcHBAdata, QconsumerNdx );
303
304 break;
305
306
307
308 case EXCHANGE_QUEUED: // an Exchange (i.e. FCP-SCSI) was previously
309 // Queued because the link was down. The
310 // heartbeat timer detected it and Queued it here.
311 // We attempt to start it again, and if
312 // successful we clear the EXCHANGE_Q flag.
313 // If the link doesn't come up, the Exchange
314 // will eventually time-out.
315
316 ExchangeID = (LONG) // x_ID copied from DPC timeout function
317 fcLQ->Qitem[QconsumerNdx].ulBuff[0];
318
319 // It's possible that a Q'd exchange could have already
320 // been started by other logic (e.g. ABTS process)
321 // Don't start if already started (Q'd flag clear)
322
323 if( Exchanges->fcExchange[ExchangeID].status & EXCHANGE_QUEUED )
324 {
325// printk(" *Start Q'd x_ID %Xh: type %Xh ",
326// ExchangeID, Exchanges->fcExchange[ExchangeID].type);
327
328 ulStatus = cpqfcTSStartExchange( cpqfcHBAdata, ExchangeID);
329 if( !ulStatus )
330 {
331// printk("success* ");
332 }
333 else
334 {
335#ifdef DBG
336
337 if( ulStatus == EXCHANGE_QUEUED)
338 printk("Queued* ");
339 else
340 printk("failed* ");
341
342#endif
343 }
344 }
345 break;
346
347
348 case LINKDOWN:
349 // (lots of things already done in INT handler) future here?
350 break;
351
352
353 case LINKACTIVE: // Tachyon set the Lup bit in FM status
354 // NOTE: some misbehaving FC ports (like Tach2.1)
355 // can re-LIP immediately after a LIP completes.
356
357 // if "initiator", need to verify LOGs with ports
358// printk("\n*LNKUP* ");
359
360 if( fcChip->Options.initiator )
361 SendLogins( cpqfcHBAdata, NULL ); // PLOGI or PDISC, based on fcPort data
362 // if SendLogins successfully completes, PortDiscDone
363 // will be set.
364
365
366 // If SendLogins was successful, then we expect to get incoming
367 // ACCepts or REJECTs, which are handled below.
368
369 break;
370
371 // LinkService and Fabric request/reply processing
372 case ELS_FDISC: // need to send Fabric Discovery (Login)
373 case ELS_FLOGI: // need to send Fabric Login
374 case ELS_SCR: // need to send State Change Registration
375 case FCS_NSR: // need to send Name Service Request
376 case ELS_PLOGI: // need to send PLOGI
377 case ELS_ACC: // send generic ACCept
378 case ELS_PLOGI_ACC: // need to send ELS ACCept frame to recv'd PLOGI
379 case ELS_PRLI_ACC: // need to send ELS ACCept frame to recv'd PRLI
380 case ELS_LOGO: // need to send ELS LOGO (logout)
381 case ELS_LOGO_ACC: // need to send ELS ACCept frame to recv'd PLOGI
382 case ELS_RJT: // ReJecT reply
383 case ELS_PRLI: // need to send ELS PRLI
384
385
386// printk(" *ELS %Xh* ", fcLQ->Qitem[QconsumerNdx].Type);
387 // if PortDiscDone is not set, it means the SendLogins routine
388 // failed to complete -- assume that LDn occurred, so login frames
389 // are invalid
390 if( !cpqfcHBAdata->PortDiscDone) // cleared by LDn
391 {
392 printk("Discard Q'd ELS login frame\n");
393 break;
394 }
395
396 ulStatus = cpqfcTSBuildExchange(
397 cpqfcHBAdata,
398 fcLQ->Qitem[QconsumerNdx].Type, // e.g. PLOGI
399 (TachFCHDR_GCMND*)
400 fcLQ->Qitem[QconsumerNdx].ulBuff, // incoming fchs
401 NULL, // no data (no scatter/gather list)
402 &ExchangeID );// fcController->fcExchanges index, -1 if failed
403
404 if( !ulStatus ) // Exchange setup?
405 {
406 ulStatus = cpqfcTSStartExchange( cpqfcHBAdata, ExchangeID );
407 if( !ulStatus )
408 {
409 // submitted to Tach's Outbound Que (ERQ PI incremented)
410 // waited for completion for ELS type (Login frames issued
411 // synchronously)
412 }
413 else
414 // check reason for Exchange not being started - we might
415 // want to Queue and start later, or fail with error
416 {
417
418 }
419 }
420
421 else // Xchange setup failed...
422 printk(" cpqfcTSBuildExchange failed: %Xh\n", ulStatus );
423
424 break;
425
426 case SCSI_REPORT_LUNS:
427 // pass the incoming frame (actually, it's a PRLI frame)
428 // so we can send REPORT_LUNS, in order to determine VSA/PDU
429 // FCP-SCSI Lun address mode
430 IssueReportLunsCommand( cpqfcHBAdata, (TachFCHDR_GCMND*)
431 fcLQ->Qitem[QconsumerNdx].ulBuff);
432
433 break;
434
435
436
437
438 case BLS_ABTS: // need to ABORT one or more exchanges
439 {
440 LONG x_ID = fcLQ->Qitem[QconsumerNdx].ulBuff[0];
441 BOOLEAN FrozeTach = FALSE;
442
443 if ( x_ID >= TACH_SEST_LEN ) // (in)sanity check
444 {
445// printk( " cpqfcTS ERROR! BOGUS x_ID %Xh", x_ID);
446 break;
447 }
448
449
450 if( Exchanges->fcExchange[ x_ID].Cmnd == NULL ) // should be RARE
451 {
452// printk(" ABTS %Xh Scsi Cmnd null! ", x_ID);
453
454 break; // nothing to abort!
455 }
456
457//#define ABTS_DBG
458#ifdef ABTS_DBG
459 printk("INV SEST[%X] ", x_ID);
460 if( Exchanges->fcExchange[x_ID].status & FC2_TIMEOUT)
461 {
462 printk("FC2TO");
463 }
464 if( Exchanges->fcExchange[x_ID].status & INITIATOR_ABORT)
465 {
466 printk("IA");
467 }
468 if( Exchanges->fcExchange[x_ID].status & PORTID_CHANGED)
469 {
470 printk("PORTID");
471 }
472 if( Exchanges->fcExchange[x_ID].status & DEVICE_REMOVED)
473 {
474 printk("DEVRM");
475 }
476 if( Exchanges->fcExchange[x_ID].status & LINKFAIL_TX)
477 {
478 printk("LKF");
479 }
480 if( Exchanges->fcExchange[x_ID].status & FRAME_TO)
481 {
482 printk("FRMTO");
483 }
484 if( Exchanges->fcExchange[x_ID].status & ABORTSEQ_NOTIFY)
485 {
486 printk("ABSQ");
487 }
488 if( Exchanges->fcExchange[x_ID].status & SFQ_FRAME)
489 {
490 printk("SFQFR");
491 }
492
493 if( Exchanges->fcExchange[ x_ID].type == 0x2000)
494 printk(" WR");
495 else if( Exchanges->fcExchange[ x_ID].type == 0x3000)
496 printk(" RD");
497 else if( Exchanges->fcExchange[ x_ID].type == 0x10)
498 printk(" ABTS");
499 else
500 printk(" %Xh", Exchanges->fcExchange[ x_ID].type);
501
502 if( !(Exchanges->fcExchange[x_ID].status & INITIATOR_ABORT))
503 {
504 printk(" Cmd %p, ",
505 Exchanges->fcExchange[ x_ID].Cmnd);
506
507 printk(" brd/chn/trg/lun %d/%d/%d/%d port_id %06X\n",
508 cpqfcHBAdata->HBAnum,
509 Exchanges->fcExchange[ x_ID].Cmnd->channel,
510 Exchanges->fcExchange[ x_ID].Cmnd->target,
511 Exchanges->fcExchange[ x_ID].Cmnd->lun,
512 Exchanges->fcExchange[ x_ID].fchs.d_id & 0xFFFFFF);
513 }
514 else // assume that Cmnd ptr is invalid on _abort()
515 {
516 printk(" Cmd ptr invalid\n");
517 }
518
519#endif
520
521
522 // Steps to ABORT a SEST exchange:
523 // 1. Freeze TL SCSI assists & ERQ (everything)
524 // 2. Receive FROZEN inbound CM (must succeed!)
525 // 3. Invalidate x_ID SEST entry
526 // 4. Resume TL SCSI assists & ERQ (everything)
527 // 5. Build/start on exchange - change "type" to BLS_ABTS,
528 // timeout to X sec (RA_TOV from PLDA is actually 0)
529 // 6. Set Exchange Q'd status if ABTS cannot be started,
530 // or simply complete Exchange in "Terminate" condition
531
532 PCI_TRACEO( x_ID, 0xB4)
533
534 // 1 & 2 . Freeze Tach & get confirmation of freeze
535 FrozeTach = FreezeTach( cpqfcHBAdata);
536
537 // 3. OK, Tachyon is frozen, so we can invalidate SEST exchange.
538 // FC2_TIMEOUT means we are originating the abort, while
539 // TARGET_ABORT means we are ACCepting an abort.
540 // LINKFAIL_TX, ABORTSEQ_NOFITY, INV_ENTRY or FRAME_TO are
541 // all from Tachyon:
542 // Exchange was corrupted by LDn or other FC physical failure
543 // INITIATOR_ABORT means the upper layer driver/application
544 // requested the abort.
545
546
547
548 // clear bit 31 (VALid), to invalidate & take control from TL
549 fcChip->SEST->u[ x_ID].IWE.Hdr_Len &= 0x7FFFFFFF;
550
551
552 // examine and Tach's "Linked List" for IWEs that
553 // received (nearly) simultaneous transfer ready (XRDY)
554 // repair linked list if necessary (TBD!)
555 // (If we ignore the "Linked List", we will time out
556 // WRITE commands where we received the FCP-SCSI XFRDY
557 // frame (because Tachyon didn't processes it). Linked List
558 // management should be done as an optimization.
559
560// readl( fcChip->Registers.ReMapMemBase+TL_MEM_SEST_LINKED_LIST ));
561
562
563
564
565 // 4. Resume all Tachlite functions (for other open Exchanges)
566 // as quickly as possible to allow other exchanges to other ports
567 // to resume. Freezing Tachyon may cause cascading errors, because
568 // any received SEST frame cannot be processed by the SEST.
569 // Don't "unfreeze" unless Link is operational
570 if( FrozeTach ) // did we just freeze it (above)?
571 fcChip->UnFreezeTachyon( fcChip, 2); // both ERQ and FCP assists
572
573
574 PCI_TRACEO( x_ID, 0xB4)
575
576 // Note there is no confirmation that the chip is "unfrozen". Also,
577 // if the Link is down when unfreeze is called, it has no effect.
578 // Chip will unfreeze when the Link is back up.
579
580 // 5. Now send out Abort commands if possible
581 // Some Aborts can't be "sent" (Port_id changed or gone);
582 // if the device is gone, there is no port_id to send the ABTS to.
583
584 if( !(Exchanges->fcExchange[ x_ID].status & PORTID_CHANGED)
585 &&
586 !(Exchanges->fcExchange[ x_ID].status & DEVICE_REMOVED) )
587 {
588 Exchanges->fcExchange[ x_ID].type = BLS_ABTS;
589 fchs.s_id = Exchanges->fcExchange[ x_ID].fchs.d_id;
590 ulStatus = cpqfcTSBuildExchange(
591 cpqfcHBAdata,
592 BLS_ABTS,
593 &fchs, // (uses only s_id)
594 NULL, // (no scatter/gather list for ABTS)
595 &x_ID );// ABTS on this Exchange ID
596
597 if( !ulStatus ) // Exchange setup build OK?
598 {
599
600 // ABTS may be needed because an Exchange was corrupted
601 // by a Link disruption. If the Link is UP, we can
602 // presume that this ABTS can start immediately; otherwise,
603 // set Que'd status so the Login functions
604 // can restart it when the FC physical Link is restored
605 if( ((fcChip->Registers.FMstatus.value &0xF0) &0x80)) // loop init?
606 {
607// printk(" *set Q status x_ID %Xh on LDn* ", x_ID);
608 Exchanges->fcExchange[ x_ID].status |= EXCHANGE_QUEUED;
609 }
610
611 else // what FC device (port_id) does the Cmd belong to?
612 {
613 PFC_LOGGEDIN_PORT pLoggedInPort =
614 Exchanges->fcExchange[ x_ID].pLoggedInPort;
615
616 // if Port is logged in, we might start the abort.
617
618 if( (pLoggedInPort != NULL)
619 &&
620 (pLoggedInPort->prli == TRUE) )
621 {
622 // it's possible that an Exchange has already been Queued
623 // to start after Login completes. Check and don't
624 // start it (again) here if Q'd status set
625// printk(" ABTS xchg %Xh ", x_ID);
626 if( Exchanges->fcExchange[x_ID].status & EXCHANGE_QUEUED)
627 {
628// printk("already Q'd ");
629 }
630 else
631 {
632// printk("starting ");
633
634 fcChip->fcStats.FC2aborted++;
635 ulStatus = cpqfcTSStartExchange( cpqfcHBAdata, x_ID );
636 if( !ulStatus )
637 {
638 // OK
639 // submitted to Tach's Outbound Que (ERQ PI incremented)
640 }
641 else
642 {
643/* printk("ABTS exchange start failed -status %Xh, x_ID %Xh ",
644 ulStatus, x_ID);
645*/
646 }
647 }
648 }
649 else
650 {
651/* printk(" ABTS NOT starting xchg %Xh, %p ",
652 x_ID, pLoggedInPort);
653 if( pLoggedInPort )
654 printk("prli %d ", pLoggedInPort->prli);
655*/
656 }
657 }
658 }
659 else // what the #@!
660 { // how do we fail to build an Exchange for ABTS??
661 printk("ABTS exchange build failed -status %Xh, x_ID %Xh\n",
662 ulStatus, x_ID);
663 }
664 }
665 else // abort without ABTS -- just complete exchange/Cmnd to Linux
666 {
667// printk(" *Terminating x_ID %Xh on %Xh* ",
668// x_ID, Exchanges->fcExchange[x_ID].status);
669 cpqfcTSCompleteExchange( cpqfcHBAdata->PciDev, fcChip, x_ID);
670
671 }
672 } // end of ABTS case
673 break;
674
675
676
677 case BLS_ABTS_ACC: // need to ACCept one ABTS
678 // (NOTE! this code not updated for Linux yet..)
679
680
681 printk(" *ABTS_ACC* ");
682 // 1. Freeze TL
683
684 fcChip->FreezeTachyon( fcChip, 2); // both ERQ and FCP assists
685
686 memcpy( // copy the incoming ABTS frame
687 &fchs,
688 fcLQ->Qitem[QconsumerNdx].ulBuff, // incoming fchs
689 sizeof( fchs));
690
691 // 3. OK, Tachyon is frozen so we can invalidate SEST entry
692 // (if necessary)
693 // Status FC2_TIMEOUT means we are originating the abort, while
694 // TARGET_ABORT means we are ACCepting an abort
695
696 ExchangeID = fchs.ox_rx_id & 0x7FFF; // RX_ID for exchange
697// printk("ABTS ACC for Target ExchangeID %Xh\n", ExchangeID);
698
699
700 // sanity check on received ExchangeID
701 if( Exchanges->fcExchange[ ExchangeID].status == TARGET_ABORT )
702 {
703 // clear bit 31 (VALid), to invalidate & take control from TL
704// printk("Invalidating SEST exchange %Xh\n", ExchangeID);
705 fcChip->SEST->u[ ExchangeID].IWE.Hdr_Len &= 0x7FFFFFFF;
706 }
707
708
709 // 4. Resume all Tachlite functions (for other open Exchanges)
710 // as quickly as possible to allow other exchanges to other ports
711 // to resume. Freezing Tachyon for too long may royally screw
712 // up everything!
713 fcChip->UnFreezeTachyon( fcChip, 2); // both ERQ and FCP assists
714
715 // Note there is no confirmation that the chip is "unfrozen". Also,
716 // if the Link is down when unfreeze is called, it has no effect.
717 // Chip will unfreeze when the Link is back up.
718
719 // 5. Now send out Abort ACC reply for this exchange
720 Exchanges->fcExchange[ ExchangeID].type = BLS_ABTS_ACC;
721
722 fchs.s_id = Exchanges->fcExchange[ ExchangeID].fchs.d_id;
723 ulStatus = cpqfcTSBuildExchange(
724 cpqfcHBAdata,
725 BLS_ABTS_ACC,
726 &fchs,
727 NULL, // no data (no scatter/gather list)
728 &ExchangeID );// fcController->fcExchanges index, -1 if failed
729
730 if( !ulStatus ) // Exchange setup?
731 {
732 ulStatus = cpqfcTSStartExchange( cpqfcHBAdata, ExchangeID );
733 if( !ulStatus )
734 {
735 // submitted to Tach's Outbound Que (ERQ PI incremented)
736 // waited for completion for ELS type (Login frames issued
737 // synchronously)
738 }
739 else
740 // check reason for Exchange not being started - we might
741 // want to Queue and start later, or fail with error
742 {
743
744 }
745 }
746 break;
747
748
749 case BLS_ABTS_RJT: // need to ReJecT one ABTS; reject implies the
750 // exchange doesn't exist in the TARGET context.
751 // ExchangeID has to come from LinkService space.
752
753 printk(" *ABTS_RJT* ");
754 ulStatus = cpqfcTSBuildExchange(
755 cpqfcHBAdata,
756 BLS_ABTS_RJT,
757 (TachFCHDR_GCMND*)
758 fcLQ->Qitem[QconsumerNdx].ulBuff, // incoming fchs
759 NULL, // no data (no scatter/gather list)
760 &ExchangeID );// fcController->fcExchanges index, -1 if failed
761
762 if( !ulStatus ) // Exchange setup OK?
763 {
764 ulStatus = cpqfcTSStartExchange( cpqfcHBAdata, ExchangeID );
765 // If it fails, we aren't required to retry.
766 }
767 if( ulStatus )
768 {
769 printk("Failed to send BLS_RJT for ABTS, X_ID %Xh\n", ExchangeID);
770 }
771 else
772 {
773 printk("Sent BLS_RJT for ABTS, X_ID %Xh\n", ExchangeID);
774
775 }
776
777 break;
778
779
780
781 default:
782 break;
783 } // end switch
784//doNothing:
785 // done with this item - now set the NEXT index
786
787 if( QconsumerNdx+1 >= FC_LINKQ_DEPTH ) // rollover test
788 {
789 fcLQ->consumer = 0;
790 }
791 else
792 {
793 fcLQ->consumer++;
794 }
795
796 PCI_TRACEO( fcLQ->Qitem[QconsumerNdx].Type, 0x94)
797
798 LEAVE("WorkTask");
799 return;
800}
801
802
803
804
805// When Tachyon reports link down, bad al_pa, or Link Service (e.g. Login)
806// commands come in, post to the LinkQ so that action can be taken outside the
807// interrupt handler.
808// This circular Q works like Tachyon's que - the producer points to the next
809// (unused) entry. Called by Interrupt handler, WorkerThread, Timer
810// sputlinkq
811void cpqfcTSPutLinkQue( CPQFCHBA *cpqfcHBAdata,
812 int Type,
813 void *QueContent)
814{
815 PTACHYON fcChip = &cpqfcHBAdata->fcChip;
816// FC_EXCHANGES *Exchanges = fcChip->Exchanges;
817 PFC_LINK_QUE fcLQ = cpqfcHBAdata->fcLQ;
818 ULONG ndx;
819
820 ENTER("cpqfcTSPutLinkQ");
821
822 ndx = fcLQ->producer;
823
824 ndx += 1; // test for Que full
825
826
827
828 if( ndx >= FC_LINKQ_DEPTH ) // rollover test
829 ndx = 0;
830
831 if( ndx == fcLQ->consumer ) // QUE full test
832 {
833 // QUE was full! lost LK command (fatal to logic)
834 fcChip->fcStats.lnkQueFull++;
835
836 printk("*LinkQ Full!*");
837 TriggerHBA( fcChip->Registers.ReMapMemBase, 1);
838/*
839 {
840 int i;
841 printk("LinkQ PI %d, CI %d\n", fcLQ->producer,
842 fcLQ->consumer);
843
844 for( i=0; i< FC_LINKQ_DEPTH; )
845 {
846 printk(" [%d]%Xh ", i, fcLQ->Qitem[i].Type);
847 if( (++i %8) == 0) printk("\n");
848 }
849
850 }
851*/
852 printk( "cpqfcTS: WARNING!! PutLinkQue - FULL!\n"); // we're hung
853 }
854 else // QUE next element
855 {
856 // Prevent certain multiple (back-to-back) requests.
857 // This is important in that we don't want to issue multiple
858 // ABTS for the same Exchange, or do multiple FM inits, etc.
859 // We can never be sure of the timing of events reported to
860 // us by Tach's IMQ, which can depend on system/bus speeds,
861 // FC physical link circumstances, etc.
862
863 if( (fcLQ->producer != fcLQ->consumer)
864 &&
865 (Type == FMINIT) )
866 {
867 LONG lastNdx; // compute previous producer index
868 if( fcLQ->producer)
869 lastNdx = fcLQ->producer- 1;
870 else
871 lastNdx = FC_LINKQ_DEPTH-1;
872
873
874 if( fcLQ->Qitem[lastNdx].Type == FMINIT)
875 {
876// printk(" *skip FMINIT Q post* ");
877// goto DoneWithPutQ;
878 }
879
880 }
881
882 // OK, add the Q'd item...
883
884 fcLQ->Qitem[fcLQ->producer].Type = Type;
885
886 memcpy(
887 fcLQ->Qitem[fcLQ->producer].ulBuff,
888 QueContent,
889 sizeof(fcLQ->Qitem[fcLQ->producer].ulBuff));
890
891 fcLQ->producer = ndx; // increment Que producer
892
893 // set semaphore to wake up Kernel (worker) thread
894 //
895 up( cpqfcHBAdata->fcQueReady );
896 }
897
898//DoneWithPutQ:
899
900 LEAVE("cpqfcTSPutLinkQ");
901}
902
903
904
905
906// reset device ext FC link Q
907void cpqfcTSLinkQReset( CPQFCHBA *cpqfcHBAdata)
908
909{
910 PFC_LINK_QUE fcLQ = cpqfcHBAdata->fcLQ;
911 fcLQ->producer = 0;
912 fcLQ->consumer = 0;
913
914}
915
916
917
918
919
920// When Tachyon gets an unassisted FCP-SCSI frame, post here so
921// an arbitrary context thread (e.g. IOCTL loopback test function)
922// can process it.
923
924// (NOTE: Not revised for Linux)
925// This Q works like Tachyon's que - the producer points to the next
926// (unused) entry.
927void cpqfcTSPutScsiQue( CPQFCHBA *cpqfcHBAdata,
928 int Type,
929 void *QueContent)
930{
931// CPQFCHBA *cpqfcHBAdata = (CPQFCHBA *)HostAdapter->hostdata;
932// PTACHYON fcChip = &cpqfcHBAdata->fcChip;
933
934// ULONG ndx;
935
936// ULONG *pExchangeID;
937// LONG ExchangeID;
938
939/*
940 KeAcquireSpinLockAtDpcLevel( &pDevExt->fcScsiQueLock);
941 ndx = pDevExt->fcScsiQue.producer + 1; // test for Que full
942
943 if( ndx >= FC_SCSIQ_DEPTH ) // rollover test
944 ndx = 0;
945
946 if( ndx == pDevExt->fcScsiQue.consumer ) // QUE full test
947 {
948 // QUE was full! lost LK command (fatal to logic)
949 fcChip->fcStats.ScsiQueFull++;
950#ifdef DBG
951 printk( "fcPutScsiQue - FULL!\n");
952#endif
953
954 }
955 else // QUE next element
956 {
957 pDevExt->fcScsiQue.Qitem[pDevExt->fcScsiQue.producer].Type = Type;
958
959 if( Type == FCP_RSP )
960 {
961 // this TL inbound message type means that a TL SEST exchange has
962 // copied an FCP response frame into a buffer pointed to by the SEST
963 // entry. That buffer is allocated in the SEST structure at ->RspHDR.
964 // Copy the RspHDR for use by the Que handler.
965 pExchangeID = (ULONG *)QueContent;
966
967 memcpy(
968 pDevExt->fcScsiQue.Qitem[pDevExt->fcScsiQue.producer].ulBuff,
969 &fcChip->SEST->RspHDR[ *pExchangeID ],
970 sizeof(pDevExt->fcScsiQue.Qitem[0].ulBuff)); // (any element for size)
971
972 }
973 else
974 {
975 memcpy(
976 pDevExt->fcScsiQue.Qitem[pDevExt->fcScsiQue.producer].ulBuff,
977 QueContent,
978 sizeof(pDevExt->fcScsiQue.Qitem[pDevExt->fcScsiQue.producer].ulBuff));
979 }
980
981 pDevExt->fcScsiQue.producer = ndx; // increment Que
982
983
984 KeSetEvent( &pDevExt->TYIBscsi, // signal any waiting thread
985 0, // no priority boost
986 FALSE ); // no waiting later for this event
987 }
988 KeReleaseSpinLockFromDpcLevel( &pDevExt->fcScsiQueLock);
989*/
990}
991
992
993
994
995
996
997
998static void ProcessELS_Request( CPQFCHBA*,TachFCHDR_GCMND*);
999
1000static void ProcessELS_Reply( CPQFCHBA*,TachFCHDR_GCMND*);
1001
1002static void ProcessFCS_Reply( CPQFCHBA*,TachFCHDR_GCMND*);
1003
1004void cpqfcTSImplicitLogout( CPQFCHBA* cpqfcHBAdata,
1005 PFC_LOGGEDIN_PORT pFcPort)
1006{
1007 PTACHYON fcChip = &cpqfcHBAdata->fcChip;
1008
1009 if( pFcPort->port_id != 0xFFFC01 ) // don't care about Fabric
1010 {
1011 fcChip->fcStats.logouts++;
1012 printk("cpqfcTS: Implicit logout of WWN %08X%08X, port_id %06X\n",
1013 (ULONG)pFcPort->u.liWWN,
1014 (ULONG)(pFcPort->u.liWWN >>32),
1015 pFcPort->port_id);
1016
1017 // Terminate I/O with this (Linux) Scsi target
1018 cpqfcTSTerminateExchange( cpqfcHBAdata,
1019 &pFcPort->ScsiNexus,
1020 DEVICE_REMOVED);
1021 }
1022
1023 // Do an "implicit logout" - we can't really Logout the device
1024 // (i.e. with LOGOut Request) because of port_id confusion
1025 // (i.e. the Other port has no port_id).
1026 // A new login for that WWN will have to re-write port_id (0 invalid)
1027 pFcPort->port_id = 0; // invalid!
1028 pFcPort->pdisc = FALSE;
1029 pFcPort->prli = FALSE;
1030 pFcPort->plogi = FALSE;
1031 pFcPort->flogi = FALSE;
1032 pFcPort->LOGO_timer = 0;
1033 pFcPort->device_blocked = TRUE; // block Scsi Requests
1034 pFcPort->ScsiNexus.VolumeSetAddressing=0;
1035}
1036
1037
1038// On FC-AL, there is a chance that a previously known device can
1039// be quietly removed (e.g. with non-managed hub),
1040// while a NEW device (with different WWN) took the same alpa or
1041// even 24-bit port_id. This chance is unlikely but we must always
1042// check for it.
1043static void TestDuplicatePortId( CPQFCHBA* cpqfcHBAdata,
1044 PFC_LOGGEDIN_PORT pLoggedInPort)
1045{
1046 PTACHYON fcChip = &cpqfcHBAdata->fcChip;
1047 // set "other port" at beginning of fcPorts list
1048 PFC_LOGGEDIN_PORT pOtherPortWithPortId = fcChip->fcPorts.pNextPort;
1049 while( pOtherPortWithPortId )
1050 {
1051 if( (pOtherPortWithPortId->port_id ==
1052 pLoggedInPort->port_id)
1053 &&
1054 (pOtherPortWithPortId != pLoggedInPort) )
1055 {
1056 // trouble! (Implicitly) Log the other guy out
1057 printk(" *port_id %Xh is duplicated!* ",
1058 pOtherPortWithPortId->port_id);
1059 cpqfcTSImplicitLogout( cpqfcHBAdata, pOtherPortWithPortId);
1060 }
1061 pOtherPortWithPortId = pOtherPortWithPortId->pNextPort;
1062 }
1063}
1064
1065
1066
1067
1068
1069
1070// Dynamic Memory Allocation for newly discovered FC Ports.
1071// For simplicity, maintain fcPorts structs for ALL
1072// for discovered devices, including those we never do I/O with
1073// (e.g. Fabric addresses)
1074
1075static PFC_LOGGEDIN_PORT CreateFcPort(
1076 CPQFCHBA* cpqfcHBAdata,
1077 PFC_LOGGEDIN_PORT pLastLoggedInPort,
1078 TachFCHDR_GCMND* fchs,
1079 LOGIN_PAYLOAD* plogi)
1080{
1081 PTACHYON fcChip = &cpqfcHBAdata->fcChip;
1082 PFC_LOGGEDIN_PORT pNextLoggedInPort = NULL;
1083 int i;
1084
1085
1086 printk("cpqfcTS: New FC port %06Xh WWN: ", fchs->s_id);
1087 for( i=3; i>=0; i--) // copy the LOGIN port's WWN
1088 printk("%02X", plogi->port_name[i]);
1089 for( i=7; i>3; i--) // copy the LOGIN port's WWN
1090 printk("%02X", plogi->port_name[i]);
1091
1092
1093 // allocate mem for new port
1094 // (these are small and rare allocations...)
1095 pNextLoggedInPort = kmalloc( sizeof( FC_LOGGEDIN_PORT), GFP_ATOMIC );
1096
1097
1098 // allocation succeeded? Fill out NEW PORT
1099 if( pNextLoggedInPort )
1100 {
1101 // clear out any garbage (sometimes exists)
1102 memset( pNextLoggedInPort, 0, sizeof( FC_LOGGEDIN_PORT));
1103
1104
1105 // If we login to a Fabric, we don't want to treat it
1106 // as a SCSI device...
1107 if( (fchs->s_id & 0xFFF000) != 0xFFF000)
1108 {
1109 int i;
1110
1111 // create a unique "virtual" SCSI Nexus (for now, just a
1112 // new target ID) -- we will update channel/target on REPORT_LUNS
1113 // special case for very first SCSI target...
1114 if( cpqfcHBAdata->HostAdapter->max_id == 0)
1115 {
1116 pNextLoggedInPort->ScsiNexus.target = 0;
1117 fcChip->fcPorts.ScsiNexus.target = -1; // don't use "stub"
1118 }
1119 else
1120 {
1121 pNextLoggedInPort->ScsiNexus.target =
1122 cpqfcHBAdata->HostAdapter->max_id;
1123 }
1124
1125 // initialize the lun[] Nexus struct for lun masking
1126 for( i=0; i< CPQFCTS_MAX_LUN; i++)
1127 pNextLoggedInPort->ScsiNexus.lun[i] = 0xFF; // init to NOT USED
1128
1129 pNextLoggedInPort->ScsiNexus.channel = 0; // cpqfcTS has 1 FC port
1130
1131 printk(" SCSI Chan/Trgt %d/%d",
1132 pNextLoggedInPort->ScsiNexus.channel,
1133 pNextLoggedInPort->ScsiNexus.target);
1134
1135 // tell Scsi layers about the new target...
1136 cpqfcHBAdata->HostAdapter->max_id++;
1137// printk("HostAdapter->max_id = %d\n",
1138// cpqfcHBAdata->HostAdapter->max_id);
1139 }
1140 else
1141 {
1142 // device is NOT SCSI (in case of Fabric)
1143 pNextLoggedInPort->ScsiNexus.target = -1; // invalid
1144 }
1145
1146 // create forward link to new port
1147 pLastLoggedInPort->pNextPort = pNextLoggedInPort;
1148 printk("\n");
1149
1150 }
1151 return pNextLoggedInPort; // NULL on allocation failure
1152} // end NEW PORT (WWN) logic
1153
1154
1155
1156// For certain cases, we want to terminate exchanges without
1157// sending ABTS to the device. Examples include when an FC
1158// device changed it's port_id after Loop re-init, or when
1159// the device sent us a logout. In the case of changed port_id,
1160// we want to complete the command and return SOFT_ERROR to
1161// force a re-try. In the case of LOGOut, we might return
1162// BAD_TARGET if the device is really gone.
1163// Since we must ensure that Tachyon is not operating on the
1164// exchange, we have to freeze the chip
1165// sterminateex
1166void cpqfcTSTerminateExchange(
1167 CPQFCHBA* cpqfcHBAdata, SCSI_NEXUS *ScsiNexus, int TerminateStatus)
1168{
1169 PTACHYON fcChip = &cpqfcHBAdata->fcChip;
1170 FC_EXCHANGES *Exchanges = fcChip->Exchanges;
1171 ULONG x_ID;
1172
1173 if( ScsiNexus )
1174 {
1175// printk("TerminateExchange: ScsiNexus chan/target %d/%d\n",
1176// ScsiNexus->channel, ScsiNexus->target);
1177
1178 }
1179
1180 for( x_ID = 0; x_ID < TACH_SEST_LEN; x_ID++)
1181 {
1182 if( Exchanges->fcExchange[x_ID].type ) // in use?
1183 {
1184 if( ScsiNexus == NULL ) // our HBA changed - term. all
1185 {
1186 Exchanges->fcExchange[x_ID].status = TerminateStatus;
1187 cpqfcTSPutLinkQue( cpqfcHBAdata, BLS_ABTS, &x_ID );
1188 }
1189 else
1190 {
1191 // If a device, according to WWN, has been removed, it's
1192 // port_id may be used by another working device, so we
1193 // have to terminate by SCSI target, NOT port_id.
1194 if( Exchanges->fcExchange[x_ID].Cmnd) // Cmnd in progress?
1195 {
1196 if( (Exchanges->fcExchange[x_ID].Cmnd->device->id == ScsiNexus->target)
1197 &&
1198 (Exchanges->fcExchange[x_ID].Cmnd->device->channel == ScsiNexus->channel))
1199 {
1200 Exchanges->fcExchange[x_ID].status = TerminateStatus;
1201 cpqfcTSPutLinkQue( cpqfcHBAdata, BLS_ABTS, &x_ID ); // timed-out
1202 }
1203 }
1204
1205 // (in case we ever need it...)
1206 // all SEST structures have a remote node ID at SEST DWORD 2
1207 // if( (fcChip->SEST->u[ x_ID ].TWE.Remote_Node_ID >> 8)
1208 // == port_id)
1209 }
1210 }
1211 }
1212}
1213
1214
1215static void ProcessELS_Request(
1216 CPQFCHBA* cpqfcHBAdata, TachFCHDR_GCMND* fchs)
1217{
1218 PTACHYON fcChip = &cpqfcHBAdata->fcChip;
1219// FC_EXCHANGES *Exchanges = fcChip->Exchanges;
1220// ULONG ox_id = (fchs->ox_rx_id >>16);
1221 PFC_LOGGEDIN_PORT pLoggedInPort=NULL, pLastLoggedInPort;
1222 BOOLEAN NeedReject = FALSE;
1223 ULONG ls_reject_code = 0; // default don'n know??
1224
1225
1226 // Check the incoming frame for a supported ELS type
1227 switch( fchs->pl[0] & 0xFFFF)
1228 {
1229 case 0x0050: // PDISC?
1230
1231 // Payload for PLOGI and PDISC is identical (request & reply)
1232 if( !verify_PLOGI( fcChip, fchs, &ls_reject_code) ) // valid payload?
1233 {
1234 LOGIN_PAYLOAD logi; // FC-PH Port Login
1235
1236 // PDISC payload OK. If critical login fields
1237 // (e.g. WWN) matches last login for this port_id,
1238 // we may resume any prior exchanges
1239 // with the other port
1240
1241
1242 BigEndianSwap( (UCHAR*)&fchs->pl[0], (UCHAR*)&logi, sizeof(logi));
1243
1244 pLoggedInPort = fcFindLoggedInPort(
1245 fcChip,
1246 NULL, // don't search Scsi Nexus
1247 0, // don't search linked list for port_id
1248 &logi.port_name[0], // search linked list for WWN
1249 &pLastLoggedInPort); // must return non-NULL; when a port_id
1250 // is not found, this pointer marks the
1251 // end of the singly linked list
1252
1253 if( pLoggedInPort != NULL) // WWN found (prior login OK)
1254 {
1255
1256 if( (fchs->s_id & 0xFFFFFF) == pLoggedInPort->port_id)
1257 {
1258 // Yes. We were expecting PDISC?
1259 if( pLoggedInPort->pdisc )
1260 {
1261 // Yes; set fields accordingly. (PDISC, not Originator)
1262 SetLoginFields( pLoggedInPort, fchs, TRUE, FALSE);
1263
1264 // send 'ACC' reply
1265 cpqfcTSPutLinkQue( cpqfcHBAdata,
1266 ELS_PLOGI_ACC, // (PDISC same as PLOGI ACC)
1267 fchs );
1268
1269 // OK to resume I/O...
1270 }
1271 else
1272 {
1273 printk("Not expecting PDISC (pdisc=FALSE)\n");
1274 NeedReject = TRUE;
1275 // set reject reason code
1276 ls_reject_code =
1277 LS_RJT_REASON( PROTOCOL_ERROR, INITIATOR_CTL_ERROR);
1278 }
1279 }
1280 else
1281 {
1282 if( pLoggedInPort->port_id != 0)
1283 {
1284 printk("PDISC PortID change: old %Xh, new %Xh\n",
1285 pLoggedInPort->port_id, fchs->s_id &0xFFFFFF);
1286 }
1287 NeedReject = TRUE;
1288 // set reject reason code
1289 ls_reject_code =
1290 LS_RJT_REASON( PROTOCOL_ERROR, INITIATOR_CTL_ERROR);
1291
1292 }
1293 }
1294 else
1295 {
1296 printk("PDISC Request from unknown WWN\n");
1297 NeedReject = TRUE;
1298
1299 // set reject reason code
1300 ls_reject_code =
1301 LS_RJT_REASON( LOGICAL_ERROR, INVALID_PORT_NAME);
1302 }
1303
1304 }
1305 else // Payload unacceptable
1306 {
1307 printk("payload unacceptable\n");
1308 NeedReject = TRUE; // reject code already set
1309
1310 }
1311
1312 if( NeedReject)
1313 {
1314 ULONG port_id;
1315 // The PDISC failed. Set login struct flags accordingly,
1316 // terminate any I/O to this port, and Q a PLOGI
1317 if( pLoggedInPort )
1318 {
1319 pLoggedInPort->pdisc = FALSE;
1320 pLoggedInPort->prli = FALSE;
1321 pLoggedInPort->plogi = FALSE;
1322
1323 cpqfcTSTerminateExchange( cpqfcHBAdata,
1324 &pLoggedInPort->ScsiNexus, PORTID_CHANGED);
1325 port_id = pLoggedInPort->port_id;
1326 }
1327 else
1328 {
1329 port_id = fchs->s_id &0xFFFFFF;
1330 }
1331 fchs->reserved = ls_reject_code; // borrow this (unused) field
1332 cpqfcTSPutLinkQue( cpqfcHBAdata, ELS_RJT, fchs );
1333 }
1334
1335 break;
1336
1337
1338
1339 case 0x0003: // PLOGI?
1340
1341 // Payload for PLOGI and PDISC is identical (request & reply)
1342 if( !verify_PLOGI( fcChip, fchs, &ls_reject_code) ) // valid payload?
1343 {
1344 LOGIN_PAYLOAD logi; // FC-PH Port Login
1345 BOOLEAN NeedReject = FALSE;
1346
1347 // PDISC payload OK. If critical login fields
1348 // (e.g. WWN) matches last login for this port_id,
1349 // we may resume any prior exchanges
1350 // with the other port
1351
1352
1353 BigEndianSwap( (UCHAR*)&fchs->pl[0], (UCHAR*)&logi, sizeof(logi));
1354
1355 pLoggedInPort = fcFindLoggedInPort(
1356 fcChip,
1357 NULL, // don't search Scsi Nexus
1358 0, // don't search linked list for port_id
1359 &logi.port_name[0], // search linked list for WWN
1360 &pLastLoggedInPort); // must return non-NULL; when a port_id
1361 // is not found, this pointer marks the
1362 // end of the singly linked list
1363
1364 if( pLoggedInPort == NULL) // WWN not found -New Port
1365 {
1366 pLoggedInPort = CreateFcPort(
1367 cpqfcHBAdata,
1368 pLastLoggedInPort,
1369 fchs,
1370 &logi);
1371 if( pLoggedInPort == NULL )
1372 {
1373 printk(" cpqfcTS: New port allocation failed - lost FC device!\n");
1374 // Now Q a LOGOut Request, since we won't be talking to that device
1375
1376 NeedReject = TRUE;
1377
1378 // set reject reason code
1379 ls_reject_code =
1380 LS_RJT_REASON( LOGICAL_ERROR, NO_LOGIN_RESOURCES);
1381
1382 }
1383 }
1384 if( !NeedReject )
1385 {
1386
1387 // OK - we have valid fcPort ptr; set fields accordingly.
1388 // (not PDISC, not Originator)
1389 SetLoginFields( pLoggedInPort, fchs, FALSE, FALSE);
1390
1391 // send 'ACC' reply
1392 cpqfcTSPutLinkQue( cpqfcHBAdata,
1393 ELS_PLOGI_ACC, // (PDISC same as PLOGI ACC)
1394 fchs );
1395 }
1396 }
1397 else // Payload unacceptable
1398 {
1399 printk("payload unacceptable\n");
1400 NeedReject = TRUE; // reject code already set
1401 }
1402
1403 if( NeedReject)
1404 {
1405 // The PDISC failed. Set login struct flags accordingly,
1406 // terminate any I/O to this port, and Q a PLOGI
1407 pLoggedInPort->pdisc = FALSE;
1408 pLoggedInPort->prli = FALSE;
1409 pLoggedInPort->plogi = FALSE;
1410
1411 fchs->reserved = ls_reject_code; // borrow this (unused) field
1412
1413 // send 'RJT' reply
1414 cpqfcTSPutLinkQue( cpqfcHBAdata, ELS_RJT, fchs );
1415 }
1416
1417 // terminate any exchanges with this device...
1418 if( pLoggedInPort )
1419 {
1420 cpqfcTSTerminateExchange( cpqfcHBAdata,
1421 &pLoggedInPort->ScsiNexus, PORTID_CHANGED);
1422 }
1423 break;
1424
1425
1426
1427 case 0x1020: // PRLI?
1428 {
1429 BOOLEAN NeedReject = TRUE;
1430 pLoggedInPort = fcFindLoggedInPort(
1431 fcChip,
1432 NULL, // don't search Scsi Nexus
1433 (fchs->s_id & 0xFFFFFF), // search linked list for port_id
1434 NULL, // DON'T search linked list for WWN
1435 NULL); // don't care
1436
1437 if( pLoggedInPort == NULL )
1438 {
1439 // huh?
1440 printk(" Unexpected PRLI Request -not logged in!\n");
1441
1442 // set reject reason code
1443 ls_reject_code = LS_RJT_REASON( PROTOCOL_ERROR, INITIATOR_CTL_ERROR);
1444
1445 // Q a LOGOut here?
1446 }
1447 else
1448 {
1449 // verify the PRLI ACC payload
1450 if( !verify_PRLI( fchs, &ls_reject_code) )
1451 {
1452 // PRLI Reply is acceptable; were we expecting it?
1453 if( pLoggedInPort->plogi )
1454 {
1455 // yes, we expected the PRLI ACC (not PDISC; not Originator)
1456 SetLoginFields( pLoggedInPort, fchs, FALSE, FALSE);
1457
1458 // Q an ACCept Reply
1459 cpqfcTSPutLinkQue( cpqfcHBAdata,
1460 ELS_PRLI_ACC,
1461 fchs );
1462
1463 NeedReject = FALSE;
1464 }
1465 else
1466 {
1467 // huh?
1468 printk(" (unexpected) PRLI REQEST with plogi FALSE\n");
1469
1470 // set reject reason code
1471 ls_reject_code = LS_RJT_REASON( PROTOCOL_ERROR, INITIATOR_CTL_ERROR);
1472
1473 // Q a LOGOut here?
1474
1475 }
1476 }
1477 else
1478 {
1479 printk(" PRLI REQUEST payload failed verify\n");
1480 // (reject code set by "verify")
1481
1482 // Q a LOGOut here?
1483 }
1484 }
1485
1486 if( NeedReject )
1487 {
1488 // Q a ReJecT Reply with reason code
1489 fchs->reserved = ls_reject_code;
1490 cpqfcTSPutLinkQue( cpqfcHBAdata,
1491 ELS_RJT, // Q Type
1492 fchs );
1493 }
1494 }
1495 break;
1496
1497
1498
1499
1500 case 0x0005: // LOGOut?
1501 {
1502 // was this LOGOUT because we sent a ELS_PDISC to an FC device
1503 // with changed (or new) port_id, or does the port refuse
1504 // to communicate to us?
1505 // We maintain a logout counter - if we get 3 consecutive LOGOuts,
1506 // give up!
1507 LOGOUT_PAYLOAD logo;
1508 BOOLEAN GiveUpOnDevice = FALSE;
1509 ULONG ls_reject_code = 0;
1510
1511 BigEndianSwap( (UCHAR*)&fchs->pl[0], (UCHAR*)&logo, sizeof(logo));
1512
1513 pLoggedInPort = fcFindLoggedInPort(
1514 fcChip,
1515 NULL, // don't search Scsi Nexus
1516 0, // don't search linked list for port_id
1517 &logo.port_name[0], // search linked list for WWN
1518 NULL); // don't care about end of list
1519
1520 if( pLoggedInPort ) // found the device?
1521 {
1522 // Q an ACC reply
1523 cpqfcTSPutLinkQue( cpqfcHBAdata,
1524 ELS_LOGO_ACC, // Q Type
1525 fchs ); // device to respond to
1526
1527 // set login struct fields (LOGO_counter increment)
1528 SetLoginFields( pLoggedInPort, fchs, FALSE, FALSE);
1529
1530 // are we an Initiator?
1531 if( fcChip->Options.initiator)
1532 {
1533 // we're an Initiator, so check if we should
1534 // try (another?) login
1535
1536 // Fabrics routinely log out from us after
1537 // getting device info - don't try to log them
1538 // back in.
1539 if( (fchs->s_id & 0xFFF000) == 0xFFF000 )
1540 {
1541 ; // do nothing
1542 }
1543 else if( pLoggedInPort->LOGO_counter <= 3)
1544 {
1545 // try (another) login (PLOGI request)
1546
1547 cpqfcTSPutLinkQue( cpqfcHBAdata,
1548 ELS_PLOGI, // Q Type
1549 fchs );
1550
1551 // Terminate I/O with "retry" potential
1552 cpqfcTSTerminateExchange( cpqfcHBAdata,
1553 &pLoggedInPort->ScsiNexus,
1554 PORTID_CHANGED);
1555 }
1556 else
1557 {
1558 printk(" Got 3 LOGOuts - terminating comm. with port_id %Xh\n",
1559 fchs->s_id &&0xFFFFFF);
1560 GiveUpOnDevice = TRUE;
1561 }
1562 }
1563 else
1564 {
1565 GiveUpOnDevice = TRUE;
1566 }
1567
1568
1569 if( GiveUpOnDevice == TRUE )
1570 {
1571 cpqfcTSTerminateExchange( cpqfcHBAdata,
1572 &pLoggedInPort->ScsiNexus,
1573 DEVICE_REMOVED);
1574 }
1575 }
1576 else // we don't know this WWN!
1577 {
1578 // Q a ReJecT Reply with reason code
1579 fchs->reserved = ls_reject_code;
1580 cpqfcTSPutLinkQue( cpqfcHBAdata,
1581 ELS_RJT, // Q Type
1582 fchs );
1583 }
1584 }
1585 break;
1586
1587
1588
1589
1590 // FABRIC only case
1591 case 0x0461: // ELS RSCN (Registered State Change Notification)?
1592 {
1593 int Ports;
1594 int i;
1595 __u32 Buff;
1596 // Typically, one or more devices have been added to or dropped
1597 // from the Fabric.
1598 // The format of this frame is defined in FC-FLA (Rev 2.7, Aug 1997)
1599 // The first 32-bit word has a 2-byte Payload Length, which
1600 // includes the 4 bytes of the first word. Consequently,
1601 // this PL len must never be less than 4, must be a multiple of 4,
1602 // and has a specified max value 256.
1603 // (Endianess!)
1604 Ports = ((fchs->pl[0] >>24) - 4) / 4;
1605 Ports = Ports > 63 ? 63 : Ports;
1606
1607 printk(" RSCN ports: %d\n", Ports);
1608 if( Ports <= 0 ) // huh?
1609 {
1610 // ReJecT the command
1611 fchs->reserved = LS_RJT_REASON( UNABLE_TO_PERFORM, 0);
1612
1613 cpqfcTSPutLinkQue( cpqfcHBAdata,
1614 ELS_RJT, // Q Type
1615 fchs );
1616
1617 break;
1618 }
1619 else // Accept the command
1620 {
1621 cpqfcTSPutLinkQue( cpqfcHBAdata,
1622 ELS_ACC, // Q Type
1623 fchs );
1624 }
1625
1626 // Check the "address format" to determine action.
1627 // We have 3 cases:
1628 // 0 = Port Address; 24-bit address of affected device
1629 // 1 = Area Address; MS 16 bits valid
1630 // 2 = Domain Address; MS 8 bits valid
1631 for( i=0; i<Ports; i++)
1632 {
1633 BigEndianSwap( (UCHAR*)&fchs->pl[i+1],(UCHAR*)&Buff, 4);
1634 switch( Buff & 0xFF000000)
1635 {
1636
1637 case 0: // Port Address?
1638
1639 case 0x01000000: // Area Domain?
1640 case 0x02000000: // Domain Address
1641 // For example, "port_id" 0x201300
1642 // OK, let's try a Name Service Request (Query)
1643 fchs->s_id = 0xFFFFFC; // Name Server Address
1644 cpqfcTSPutLinkQue( cpqfcHBAdata, FCS_NSR, fchs);
1645
1646 break;
1647
1648
1649 default: // huh? new value on version change?
1650 break;
1651 }
1652 }
1653 }
1654 break;
1655
1656
1657
1658
1659 default: // don't support this request (yet)
1660 // set reject reason code
1661 fchs->reserved = LS_RJT_REASON( UNABLE_TO_PERFORM,
1662 REQUEST_NOT_SUPPORTED);
1663
1664 cpqfcTSPutLinkQue( cpqfcHBAdata,
1665 ELS_RJT, // Q Type
1666 fchs );
1667 break;
1668 }
1669}
1670
1671
1672static void ProcessELS_Reply(
1673 CPQFCHBA* cpqfcHBAdata, TachFCHDR_GCMND* fchs)
1674{
1675 PTACHYON fcChip = &cpqfcHBAdata->fcChip;
1676 FC_EXCHANGES *Exchanges = fcChip->Exchanges;
1677 ULONG ox_id = (fchs->ox_rx_id >>16);
1678 ULONG ls_reject_code;
1679 PFC_LOGGEDIN_PORT pLoggedInPort, pLastLoggedInPort;
1680
1681 // If this is a valid reply, then we MUST have sent a request.
1682 // Verify that we can find a valid request OX_ID corresponding to
1683 // this reply
1684
1685
1686 if( Exchanges->fcExchange[(fchs->ox_rx_id >>16)].type == 0)
1687 {
1688 printk(" *Discarding ACC/RJT frame, xID %04X/%04X* ",
1689 ox_id, fchs->ox_rx_id & 0xffff);
1690 goto Quit; // exit this routine
1691 }
1692
1693
1694 // Is the reply a RJT (reject)?
1695 if( (fchs->pl[0] & 0xFFFFL) == 0x01) // Reject reply?
1696 {
1697// ****** REJECT REPLY ********
1698 switch( Exchanges->fcExchange[ox_id].type )
1699 {
1700
1701 case ELS_FDISC: // we sent out Fabric Discovery
1702 case ELS_FLOGI: // we sent out FLOGI
1703
1704 printk("RJT received on Fabric Login from %Xh, reason %Xh\n",
1705 fchs->s_id, fchs->pl[1]);
1706
1707 break;
1708
1709 default:
1710 break;
1711 }
1712
1713 goto Done;
1714 }
1715
1716 // OK, we have an ACCept...
1717 // What's the ACC type? (according to what we sent)
1718 switch( Exchanges->fcExchange[ox_id].type )
1719 {
1720
1721 case ELS_PLOGI: // we sent out PLOGI
1722 if( !verify_PLOGI( fcChip, fchs, &ls_reject_code) )
1723 {
1724 LOGIN_PAYLOAD logi; // FC-PH Port Login
1725
1726 // login ACC payload acceptable; search for WWN in our list
1727 // of fcPorts
1728
1729 BigEndianSwap( (UCHAR*)&fchs->pl[0], (UCHAR*)&logi, sizeof(logi));
1730
1731 pLoggedInPort = fcFindLoggedInPort(
1732 fcChip,
1733 NULL, // don't search Scsi Nexus
1734 0, // don't search linked list for port_id
1735 &logi.port_name[0], // search linked list for WWN
1736 &pLastLoggedInPort); // must return non-NULL; when a port_id
1737 // is not found, this pointer marks the
1738 // end of the singly linked list
1739
1740 if( pLoggedInPort == NULL) // WWN not found - new port
1741 {
1742
1743 pLoggedInPort = CreateFcPort(
1744 cpqfcHBAdata,
1745 pLastLoggedInPort,
1746 fchs,
1747 &logi);
1748
1749 if( pLoggedInPort == NULL )
1750 {
1751 printk(" cpqfcTS: New port allocation failed - lost FC device!\n");
1752 // Now Q a LOGOut Request, since we won't be talking to that device
1753
1754 goto Done; // exit with error! dropped login frame
1755 }
1756 }
1757 else // WWN was already known. Ensure that any open
1758 // exchanges for this WWN are terminated.
1759 // NOTE: It's possible that a device can change its
1760 // 24-bit port_id after a Link init or Fabric change
1761 // (e.g. LIP or Fabric RSCN). In that case, the old
1762 // 24-bit port_id may be duplicated, or no longer exist.
1763 {
1764
1765 cpqfcTSTerminateExchange( cpqfcHBAdata,
1766 &pLoggedInPort->ScsiNexus, PORTID_CHANGED);
1767 }
1768
1769 // We have an fcPort struct - set fields accordingly
1770 // not PDISC, originator
1771 SetLoginFields( pLoggedInPort, fchs, FALSE, TRUE);
1772
1773 // We just set a "port_id"; is it duplicated?
1774 TestDuplicatePortId( cpqfcHBAdata, pLoggedInPort);
1775
1776 // For Fabric operation, we issued PLOGI to 0xFFFFFC
1777 // so we can send SCR (State Change Registration)
1778 // Check for this special case...
1779 if( fchs->s_id == 0xFFFFFC )
1780 {
1781 // PLOGI ACC was a Fabric response... issue SCR
1782 fchs->s_id = 0xFFFFFD; // address for SCR
1783 cpqfcTSPutLinkQue( cpqfcHBAdata, ELS_SCR, fchs);
1784 }
1785
1786 else
1787 {
1788 // Now we need a PRLI to enable FCP-SCSI operation
1789 // set flags and Q up a ELS_PRLI
1790 cpqfcTSPutLinkQue( cpqfcHBAdata, ELS_PRLI, fchs);
1791 }
1792 }
1793 else
1794 {
1795 // login payload unacceptable - reason in ls_reject_code
1796 // Q up a Logout Request
1797 printk("Login Payload unacceptable\n");
1798
1799 }
1800 break;
1801
1802
1803 // PDISC logic very similar to PLOGI, except we never want
1804 // to allocate mem for "new" port, and we set flags differently
1805 // (might combine later with PLOGI logic for efficiency)
1806 case ELS_PDISC: // we sent out PDISC
1807 if( !verify_PLOGI( fcChip, fchs, &ls_reject_code) )
1808 {
1809 LOGIN_PAYLOAD logi; // FC-PH Port Login
1810 BOOLEAN NeedLogin = FALSE;
1811
1812 // login payload acceptable; search for WWN in our list
1813 // of (previously seen) fcPorts
1814
1815 BigEndianSwap( (UCHAR*)&fchs->pl[0], (UCHAR*)&logi, sizeof(logi));
1816
1817 pLoggedInPort = fcFindLoggedInPort(
1818 fcChip,
1819 NULL, // don't search Scsi Nexus
1820 0, // don't search linked list for port_id
1821 &logi.port_name[0], // search linked list for WWN
1822 &pLastLoggedInPort); // must return non-NULL; when a port_id
1823 // is not found, this pointer marks the
1824 // end of the singly linked list
1825
1826 if( pLoggedInPort != NULL) // WWN found?
1827 {
1828 // WWN has same port_id as last login? (Of course, a properly
1829 // working FC device should NEVER ACCept a PDISC if it's
1830 // port_id changed, but check just in case...)
1831 if( (fchs->s_id & 0xFFFFFF) == pLoggedInPort->port_id)
1832 {
1833 // Yes. We were expecting PDISC?
1834 if( pLoggedInPort->pdisc )
1835 {
1836 int i;
1837
1838
1839 // PDISC expected -- set fields. (PDISC, Originator)
1840 SetLoginFields( pLoggedInPort, fchs, TRUE, TRUE);
1841
1842 // We are ready to resume FCP-SCSI to this device...
1843 // Do we need to start anything that was Queued?
1844
1845 for( i=0; i< TACH_SEST_LEN; i++)
1846 {
1847 // see if any exchange for this PDISC'd port was queued
1848 if( ((fchs->s_id &0xFFFFFF) ==
1849 (Exchanges->fcExchange[i].fchs.d_id & 0xFFFFFF))
1850 &&
1851 (Exchanges->fcExchange[i].status & EXCHANGE_QUEUED))
1852 {
1853 fchs->reserved = i; // copy ExchangeID
1854// printk(" *Q x_ID %Xh after PDISC* ",i);
1855
1856 cpqfcTSPutLinkQue( cpqfcHBAdata, EXCHANGE_QUEUED, fchs );
1857 }
1858 }
1859
1860 // Complete commands Q'd while we were waiting for Login
1861
1862 UnblockScsiDevice( cpqfcHBAdata->HostAdapter, pLoggedInPort);
1863 }
1864 else
1865 {
1866 printk("Not expecting PDISC (pdisc=FALSE)\n");
1867 NeedLogin = TRUE;
1868 }
1869 }
1870 else
1871 {
1872 printk("PDISC PortID change: old %Xh, new %Xh\n",
1873 pLoggedInPort->port_id, fchs->s_id &0xFFFFFF);
1874 NeedLogin = TRUE;
1875
1876 }
1877 }
1878 else
1879 {
1880 printk("PDISC ACC from unknown WWN\n");
1881 NeedLogin = TRUE;
1882 }
1883
1884 if( NeedLogin)
1885 {
1886
1887 // The PDISC failed. Set login struct flags accordingly,
1888 // terminate any I/O to this port, and Q a PLOGI
1889 if( pLoggedInPort ) // FC device previously known?
1890 {
1891
1892 cpqfcTSPutLinkQue( cpqfcHBAdata,
1893 ELS_LOGO, // Q Type
1894 fchs ); // has port_id to send to
1895
1896 // There are a variety of error scenarios which can result
1897 // in PDISC failure, so as a catchall, add the check for
1898 // duplicate port_id.
1899 TestDuplicatePortId( cpqfcHBAdata, pLoggedInPort);
1900
1901// TriggerHBA( fcChip->Registers.ReMapMemBase, 0);
1902 pLoggedInPort->pdisc = FALSE;
1903 pLoggedInPort->prli = FALSE;
1904 pLoggedInPort->plogi = FALSE;
1905
1906 cpqfcTSTerminateExchange( cpqfcHBAdata,
1907 &pLoggedInPort->ScsiNexus, PORTID_CHANGED);
1908 }
1909 cpqfcTSPutLinkQue( cpqfcHBAdata, ELS_PLOGI, fchs );
1910 }
1911 }
1912 else
1913 {
1914 // login payload unacceptable - reason in ls_reject_code
1915 // Q up a Logout Request
1916 printk("ERROR: Login Payload unacceptable!\n");
1917
1918 }
1919
1920 break;
1921
1922
1923
1924 case ELS_PRLI: // we sent out PRLI
1925
1926
1927 pLoggedInPort = fcFindLoggedInPort(
1928 fcChip,
1929 NULL, // don't search Scsi Nexus
1930 (fchs->s_id & 0xFFFFFF), // search linked list for port_id
1931 NULL, // DON'T search linked list for WWN
1932 NULL); // don't care
1933
1934 if( pLoggedInPort == NULL )
1935 {
1936 // huh?
1937 printk(" Unexpected PRLI ACCept frame!\n");
1938
1939 // Q a LOGOut here?
1940
1941 goto Done;
1942 }
1943
1944 // verify the PRLI ACC payload
1945 if( !verify_PRLI( fchs, &ls_reject_code) )
1946 {
1947 // PRLI Reply is acceptable; were we expecting it?
1948 if( pLoggedInPort->plogi )
1949 {
1950 // yes, we expected the PRLI ACC (not PDISC; Originator)
1951 SetLoginFields( pLoggedInPort, fchs, FALSE, TRUE);
1952
1953 // OK, let's send a REPORT_LUNS command to determine
1954 // whether VSA or PDA FCP-LUN addressing is used.
1955
1956 cpqfcTSPutLinkQue( cpqfcHBAdata, SCSI_REPORT_LUNS, fchs );
1957
1958 // It's possible that a device we were talking to changed
1959 // port_id, and has logged back in. This function ensures
1960 // that I/O will resume.
1961 UnblockScsiDevice( cpqfcHBAdata->HostAdapter, pLoggedInPort);
1962
1963 }
1964 else
1965 {
1966 // huh?
1967 printk(" (unexpected) PRLI ACCept with plogi FALSE\n");
1968
1969 // Q a LOGOut here?
1970 goto Done;
1971 }
1972 }
1973 else
1974 {
1975 printk(" PRLI ACCept payload failed verify\n");
1976
1977 // Q a LOGOut here?
1978 }
1979
1980 break;
1981
1982 case ELS_FLOGI: // we sent out FLOGI (Fabric Login)
1983
1984 // update the upper 16 bits of our port_id in Tachyon
1985 // the switch adds those upper 16 bits when responding
1986 // to us (i.e. we are the destination_id)
1987 fcChip->Registers.my_al_pa = (fchs->d_id & 0xFFFFFF);
1988 writel( fcChip->Registers.my_al_pa,
1989 fcChip->Registers.ReMapMemBase + TL_MEM_TACH_My_ID);
1990
1991 // now send out a PLOGI to the well known port_id 0xFFFFFC
1992 fchs->s_id = 0xFFFFFC;
1993 cpqfcTSPutLinkQue( cpqfcHBAdata, ELS_PLOGI, fchs);
1994
1995 break;
1996
1997
1998 case ELS_FDISC: // we sent out FDISC (Fabric Discovery (Login))
1999
2000 printk( " ELS_FDISC success ");
2001 break;
2002
2003
2004 case ELS_SCR: // we sent out State Change Registration
2005 // now we can issue Name Service Request to find any
2006 // Fabric-connected devices we might want to login to.
2007
2008
2009 fchs->s_id = 0xFFFFFC; // Name Server Address
2010 cpqfcTSPutLinkQue( cpqfcHBAdata, FCS_NSR, fchs);
2011
2012
2013 break;
2014
2015
2016 default:
2017 printk(" *Discarding unknown ACC frame, xID %04X/%04X* ",
2018 ox_id, fchs->ox_rx_id & 0xffff);
2019 break;
2020 }
2021
2022
2023Done:
2024 // Regardless of whether the Reply is valid or not, the
2025 // the exchange is done - complete
2026 cpqfcTSCompleteExchange(cpqfcHBAdata->PciDev, fcChip, (fchs->ox_rx_id >>16));
2027
2028Quit:
2029 return;
2030}
2031
2032
2033
2034
2035
2036
2037// **************** Fibre Channel Services **************
2038// This is where we process the Directory (Name) Service Reply
2039// to know which devices are on the Fabric
2040
2041static void ProcessFCS_Reply(
2042 CPQFCHBA* cpqfcHBAdata, TachFCHDR_GCMND* fchs)
2043{
2044 PTACHYON fcChip = &cpqfcHBAdata->fcChip;
2045 FC_EXCHANGES *Exchanges = fcChip->Exchanges;
2046 ULONG ox_id = (fchs->ox_rx_id >>16);
2047// ULONG ls_reject_code;
2048// PFC_LOGGEDIN_PORT pLoggedInPort, pLastLoggedInPort;
2049
2050 // If this is a valid reply, then we MUST have sent a request.
2051 // Verify that we can find a valid request OX_ID corresponding to
2052 // this reply
2053
2054 if( Exchanges->fcExchange[(fchs->ox_rx_id >>16)].type == 0)
2055 {
2056 printk(" *Discarding Reply frame, xID %04X/%04X* ",
2057 ox_id, fchs->ox_rx_id & 0xffff);
2058 goto Quit; // exit this routine
2059 }
2060
2061
2062 // OK, we were expecting it. Now check to see if it's a
2063 // "Name Service" Reply, and if so force a re-validation of
2064 // Fabric device logins (i.e. Start the login timeout and
2065 // send PDISC or PLOGI)
2066 // (Endianess Byte Swap?)
2067 if( fchs->pl[1] == 0x02FC ) // Name Service
2068 {
2069 // got a new (or NULL) list of Fabric attach devices...
2070 // Invalidate current logins
2071
2072 PFC_LOGGEDIN_PORT pLoggedInPort = &fcChip->fcPorts;
2073 while( pLoggedInPort ) // for all ports which are expecting
2074 // PDISC after the next LIP, set the
2075 // logoutTimer
2076 {
2077
2078 if( (pLoggedInPort->port_id & 0xFFFF00) // Fabric device?
2079 &&
2080 (pLoggedInPort->port_id != 0xFFFFFC) ) // NOT the F_Port
2081 {
2082 pLoggedInPort->LOGO_timer = 6; // what's the Fabric timeout??
2083 // suspend any I/O in progress until
2084 // PDISC received...
2085 pLoggedInPort->prli = FALSE; // block FCP-SCSI commands
2086 }
2087
2088 pLoggedInPort = pLoggedInPort->pNextPort;
2089 }
2090
2091 if( fchs->pl[2] == 0x0280) // ACCept?
2092 {
2093 // Send PLOGI or PDISC to these Fabric devices
2094 SendLogins( cpqfcHBAdata, &fchs->pl[4] );
2095 }
2096
2097
2098 // As of this writing, the only reason to reject is because NO
2099 // devices are left on the Fabric. We already started
2100 // "logged out" timers; if the device(s) don't come
2101 // back, we'll do the implicit logout in the heart beat
2102 // timer routine
2103 else // ReJecT
2104 {
2105 // this just means no Fabric device is visible at this instant
2106 }
2107 }
2108
2109 // Regardless of whether the Reply is valid or not, the
2110 // the exchange is done - complete
2111 cpqfcTSCompleteExchange(cpqfcHBAdata->PciDev, fcChip, (fchs->ox_rx_id >>16));
2112
2113Quit:
2114 return;
2115}
2116
2117
2118
2119
2120
2121
2122
2123static void AnalyzeIncomingFrame(
2124 CPQFCHBA *cpqfcHBAdata,
2125 ULONG QNdx )
2126{
2127 PTACHYON fcChip = &cpqfcHBAdata->fcChip;
2128 FC_EXCHANGES *Exchanges = fcChip->Exchanges;
2129 PFC_LINK_QUE fcLQ = cpqfcHBAdata->fcLQ;
2130 TachFCHDR_GCMND* fchs =
2131 (TachFCHDR_GCMND*)fcLQ->Qitem[QNdx].ulBuff;
2132// ULONG ls_reject_code; // reason for rejecting login
2133 LONG ExchangeID;
2134// FC_LOGGEDIN_PORT *pLoggedInPort;
2135 BOOLEAN AbortAccept;
2136
2137 ENTER("AnalyzeIncomingFrame");
2138
2139
2140
2141 switch( fcLQ->Qitem[QNdx].Type) // FCP or Unknown
2142 {
2143
2144 case SFQ_UNKNOWN: // unknown frame (e.g. LIP position frame, NOP, etc.)
2145
2146
2147 // ********* FC-4 Device Data/ Fibre Channel Service *************
2148 if( ((fchs->d_id &0xF0000000) == 0) // R_CTL (upper nibble) 0x0?
2149 &&
2150 (fchs->f_ctl & 0x20000000) ) // TYPE 20h is Fibre Channel Service
2151 {
2152
2153 // ************** FCS Reply **********************
2154
2155 if( (fchs->d_id & 0xff000000L) == 0x03000000L) // (31:23 R_CTL)
2156 {
2157 ProcessFCS_Reply( cpqfcHBAdata, fchs );
2158
2159 } // end of FCS logic
2160
2161 }
2162
2163
2164 // *********** Extended Link Service **************
2165
2166 else if( fchs->d_id & 0x20000000 // R_CTL 0x2?
2167 &&
2168 (fchs->f_ctl & 0x01000000) ) // TYPE = 1
2169 {
2170
2171 // these frames are either a response to
2172 // something we sent (0x23) or "unsolicited"
2173 // frames (0x22).
2174
2175
2176 // **************Extended Link REPLY **********************
2177 // R_CTL Solicited Control Reply
2178
2179 if( (fchs->d_id & 0xff000000L) == 0x23000000L) // (31:23 R_CTL)
2180 {
2181
2182 ProcessELS_Reply( cpqfcHBAdata, fchs );
2183
2184 } // end of "R_CTL Solicited Control Reply"
2185
2186
2187
2188
2189 // **************Extended Link REQUEST **********************
2190 // (unsolicited commands from another port or task...)
2191
2192 // R_CTL Ext Link REQUEST
2193 else if( (fchs->d_id & 0xff000000L) == 0x22000000L &&
2194 (fchs->ox_rx_id != 0xFFFFFFFFL) ) // (ignore LIP frame)
2195 {
2196
2197
2198
2199 ProcessELS_Request( cpqfcHBAdata, fchs );
2200
2201 }
2202
2203
2204
2205 // ************** LILP **********************
2206 else if( (fchs->d_id & 0xff000000L) == 0x22000000L &&
2207 (fchs->ox_rx_id == 0xFFFFFFFFL)) // (e.g., LIP frames)
2208
2209 {
2210 // SANMark specifies that when available, we must use
2211 // the LILP frame to determine which ALPAs to send Port Discovery
2212 // to...
2213
2214 if( fchs->pl[0] == 0x0711L) // ELS_PLOGI?
2215 {
2216// UCHAR *ptr = (UCHAR*)&fchs->pl[1];
2217// printk(" %d ALPAs found\n", *ptr);
2218 memcpy( fcChip->LILPmap, &fchs->pl[1], 32*4); // 32 DWORDs
2219 fcChip->Options.LILPin = 1; // our LILPmap is valid!
2220 // now post to make Port Discovery happen...
2221 cpqfcTSPutLinkQue( cpqfcHBAdata, LINKACTIVE, fchs);
2222 }
2223 }
2224 }
2225
2226
2227 // ***************** BASIC LINK SERVICE *****************
2228
2229 else if( fchs->d_id & 0x80000000 // R_CTL:
2230 && // Basic Link Service Request
2231 !(fchs->f_ctl & 0xFF000000) ) // type=0 for BLS
2232 {
2233
2234 // Check for ABTS (Abort Sequence)
2235 if( (fchs->d_id & 0x8F000000) == 0x81000000)
2236 {
2237 // look for OX_ID, S_ID pair that matches in our
2238 // fcExchanges table; if found, reply with ACCept and complete
2239 // the exchange
2240
2241 // Per PLDA, an ABTS is sent by an initiator; therefore
2242 // assume that if we have an exhange open to the port who
2243 // sent ABTS, it will be the d_id of what we sent.
2244 for( ExchangeID = 0, AbortAccept=FALSE;
2245 ExchangeID < TACH_SEST_LEN; ExchangeID++)
2246 {
2247 // Valid "target" exchange 24-bit port_id matches?
2248 // NOTE: For the case of handling Intiator AND Target
2249 // functions on the same chip, we can have TWO Exchanges
2250 // with the same OX_ID -- OX_ID/FFFF for the CMND, and
2251 // OX_ID/RX_ID for the XRDY or DATA frame(s). Ideally,
2252 // we would like to support ABTS from Initiators or Targets,
2253 // but it's not clear that can be supported on Tachyon for
2254 // all cases (requires more investigation).
2255
2256 if( (Exchanges->fcExchange[ ExchangeID].type == SCSI_TWE ||
2257 Exchanges->fcExchange[ ExchangeID].type == SCSI_TRE)
2258 &&
2259 ((Exchanges->fcExchange[ ExchangeID].fchs.d_id & 0xFFFFFF) ==
2260 (fchs->s_id & 0xFFFFFF)) )
2261 {
2262
2263 // target xchnge port_id matches -- how about OX_ID?
2264 if( (Exchanges->fcExchange[ ExchangeID].fchs.ox_rx_id &0xFFFF0000)
2265 == (fchs->ox_rx_id & 0xFFFF0000) )
2266 // yes! post ACCept response; will be completed by fcStart
2267 {
2268 Exchanges->fcExchange[ ExchangeID].status = TARGET_ABORT;
2269
2270 // copy (add) rx_id field for simplified ACCept reply
2271 fchs->ox_rx_id =
2272 Exchanges->fcExchange[ ExchangeID].fchs.ox_rx_id;
2273
2274 cpqfcTSPutLinkQue( cpqfcHBAdata,
2275 BLS_ABTS_ACC, // Q Type
2276 fchs ); // void QueContent
2277 AbortAccept = TRUE;
2278 printk("ACCepting ABTS for x_ID %8.8Xh, SEST pair %8.8Xh\n",
2279 fchs->ox_rx_id, Exchanges->fcExchange[ ExchangeID].fchs.ox_rx_id);
2280 break; // ABTS can affect only ONE exchange -exit loop
2281 }
2282 }
2283 } // end of FOR loop
2284 if( !AbortAccept ) // can't ACCept ABTS - send Reject
2285 {
2286 printk("ReJecTing: can't find ExchangeID %8.8Xh for ABTS command\n",
2287 fchs->ox_rx_id);
2288 if( Exchanges->fcExchange[ ExchangeID].type
2289 &&
2290 !(fcChip->SEST->u[ ExchangeID].IWE.Hdr_Len
2291 & 0x80000000))
2292 {
2293 cpqfcTSCompleteExchange( cpqfcHBAdata->PciDev, fcChip, ExchangeID);
2294 }
2295 else
2296 {
2297 printk("Unexpected ABTS ReJecT! SEST[%X] Dword 0: %Xh\n",
2298 ExchangeID, fcChip->SEST->u[ ExchangeID].IWE.Hdr_Len);
2299 }
2300 }
2301 }
2302
2303 // Check for BLS {ABTS? (Abort Sequence)} ACCept
2304 else if( (fchs->d_id & 0x8F000000) == 0x84000000)
2305 {
2306 // target has responded with ACC for our ABTS;
2307 // complete the indicated exchange with ABORTED status
2308 // Make no checks for correct RX_ID, since
2309 // all we need to conform ABTS ACC is the OX_ID.
2310 // Verify that the d_id matches!
2311
2312 ExchangeID = (fchs->ox_rx_id >> 16) & 0x7FFF; // x_id from ACC
2313// printk("ABTS ACC x_ID 0x%04X 0x%04X, status %Xh\n",
2314// fchs->ox_rx_id >> 16, fchs->ox_rx_id & 0xffff,
2315// Exchanges->fcExchange[ExchangeID].status);
2316
2317
2318
2319 if( ExchangeID < TACH_SEST_LEN ) // x_ID makes sense
2320 {
2321 // Does "target" exchange 24-bit port_id match?
2322 // (See "NOTE" above for handling Intiator AND Target in
2323 // the same device driver)
2324 // First, if this is a target response, then we originated
2325 // (initiated) it with BLS_ABTS:
2326
2327 if( (Exchanges->fcExchange[ ExchangeID].type == BLS_ABTS)
2328
2329 &&
2330 // Second, does the source of this ACC match the destination
2331 // of who we originally sent it to?
2332 ((Exchanges->fcExchange[ ExchangeID].fchs.d_id & 0xFFFFFF) ==
2333 (fchs->s_id & 0xFFFFFF)) )
2334 {
2335 cpqfcTSCompleteExchange( cpqfcHBAdata->PciDev, fcChip, ExchangeID );
2336 }
2337 }
2338 }
2339 // Check for BLS {ABTS? (Abort Sequence)} ReJecT
2340 else if( (fchs->d_id & 0x8F000000) == 0x85000000)
2341 {
2342 // target has responded with RJT for our ABTS;
2343 // complete the indicated exchange with ABORTED status
2344 // Make no checks for correct RX_ID, since
2345 // all we need to conform ABTS ACC is the OX_ID.
2346 // Verify that the d_id matches!
2347
2348 ExchangeID = (fchs->ox_rx_id >> 16) & 0x7FFF; // x_id from ACC
2349// printk("BLS_ABTS RJT on Exchange 0x%04X 0x%04X\n",
2350// fchs->ox_rx_id >> 16, fchs->ox_rx_id & 0xffff);
2351
2352 if( ExchangeID < TACH_SEST_LEN ) // x_ID makes sense
2353 {
2354 // Does "target" exchange 24-bit port_id match?
2355 // (See "NOTE" above for handling Intiator AND Target in
2356 // the same device driver)
2357 // First, if this is a target response, then we originated
2358 // (initiated) it with BLS_ABTS:
2359
2360 if( (Exchanges->fcExchange[ ExchangeID].type == BLS_ABTS)
2361
2362 &&
2363 // Second, does the source of this ACC match the destination
2364 // of who we originally sent it to?
2365 ((Exchanges->fcExchange[ ExchangeID].fchs.d_id & 0xFFFFFF) ==
2366 (fchs->s_id & 0xFFFFFF)) )
2367 {
2368 // YES! NOTE: There is a bug in CPQ's RA-4000 box
2369 // where the "reason code" isn't returned in the payload
2370 // For now, simply presume the reject is because the target
2371 // already completed the exchange...
2372
2373// printk("complete x_ID %Xh on ABTS RJT\n", ExchangeID);
2374 cpqfcTSCompleteExchange( cpqfcHBAdata->PciDev, fcChip, ExchangeID );
2375 }
2376 }
2377 } // end of ABTS check
2378 } // end of Basic Link Service Request
2379 break;
2380
2381 default:
2382 printk("AnalyzeIncomingFrame: unknown type: %Xh(%d)\n",
2383 fcLQ->Qitem[QNdx].Type,
2384 fcLQ->Qitem[QNdx].Type);
2385 break;
2386 }
2387}
2388
2389
2390// Function for Port Discovery necessary after every FC
2391// initialization (e.g. LIP).
2392// Also may be called if from Fabric Name Service logic.
2393
2394static void SendLogins( CPQFCHBA *cpqfcHBAdata, __u32 *FabricPortIds )
2395{
2396 PTACHYON fcChip = &cpqfcHBAdata->fcChip;
2397 FC_EXCHANGES *Exchanges = fcChip->Exchanges;
2398 ULONG ulStatus=0;
2399 TachFCHDR_GCMND fchs; // copy fields for transmission
2400 int i;
2401 ULONG loginType;
2402 LONG ExchangeID;
2403 PFC_LOGGEDIN_PORT pLoggedInPort;
2404 __u32 PortIds[ number_of_al_pa];
2405 int NumberOfPorts=0;
2406
2407 // We're going to presume (for now) that our limit of Fabric devices
2408 // is the same as the number of alpa on a private loop (126 devices).
2409 // (Of course this could be changed to support however many we have
2410 // memory for).
2411 memset( &PortIds[0], 0, sizeof(PortIds));
2412
2413 // First, check if this login is for our own Link Initialization
2414 // (e.g. LIP on FC-AL), or if we have knowledge of Fabric devices
2415 // from a switch. If we are logging into Fabric devices, we'll
2416 // have a non-NULL FabricPortId pointer
2417
2418 if( FabricPortIds != NULL) // may need logins
2419 {
2420 int LastPort=FALSE;
2421 i = 0;
2422 while( !LastPort)
2423 {
2424 // port IDs From NSR payload; byte swap needed?
2425 BigEndianSwap( (UCHAR*)FabricPortIds, (UCHAR*)&PortIds[i], 4);
2426
2427// printk("FPortId[%d] %Xh ", i, PortIds[i]);
2428 if( PortIds[i] & 0x80000000)
2429 LastPort = TRUE;
2430
2431 PortIds[i] &= 0xFFFFFF; // get 24-bit port_id
2432 // some non-Fabric devices (like the Crossroads Fibre/Scsi bridge)
2433 // erroneously use ALPA 0.
2434 if( PortIds[i] ) // need non-zero port_id...
2435 i++;
2436
2437 if( i >= number_of_al_pa ) // (in)sanity check
2438 break;
2439 FabricPortIds++; // next...
2440 }
2441
2442 NumberOfPorts = i;
2443// printk("NumberOf Fabric ports %d", NumberOfPorts);
2444 }
2445
2446 else // need to send logins on our "local" link
2447 {
2448
2449 // are we a loop port? If so, check for reception of LILP frame,
2450 // and if received use it (SANMark requirement)
2451 if( fcChip->Options.LILPin )
2452 {
2453 int j=0;
2454 // sanity check on number of ALPAs from LILP frame...
2455 // For format of LILP frame, see FC-AL specs or
2456 // "Fibre Channel Bench Reference", J. Stai, 1995 (ISBN 1-879936-17-8)
2457 // First byte is number of ALPAs
2458 i = fcChip->LILPmap[0] >= (32*4) ? 32*4 : fcChip->LILPmap[0];
2459 NumberOfPorts = i;
2460// printk(" LILP alpa count %d ", i);
2461 while( i > 0)
2462 {
2463 PortIds[j] = fcChip->LILPmap[1+ j];
2464 j++; i--;
2465 }
2466 }
2467 else // have to send login to everybody
2468 {
2469 int j=0;
2470 i = number_of_al_pa;
2471 NumberOfPorts = i;
2472 while( i > 0)
2473 {
2474 PortIds[j] = valid_al_pa[j]; // all legal ALPAs
2475 j++; i--;
2476 }
2477 }
2478 }
2479
2480
2481 // Now we have a copy of the port_ids (and how many)...
2482 for( i = 0; i < NumberOfPorts; i++)
2483 {
2484 // 24-bit FC Port ID
2485 fchs.s_id = PortIds[i]; // note: only 8-bits used for ALPA
2486
2487
2488 // don't log into ourselves (Linux Scsi disk scan will stop on
2489 // no TARGET support error on us, and quit trying for rest of devices)
2490 if( (fchs.s_id & 0xFF ) == (fcChip->Registers.my_al_pa & 0xFF) )
2491 continue;
2492
2493 // fabric login needed?
2494 if( (fchs.s_id == 0) ||
2495 (fcChip->Options.fabric == 1) )
2496 {
2497 fcChip->Options.flogi = 1; // fabric needs longer for login
2498 // Do we need FLOGI or FDISC?
2499 pLoggedInPort = fcFindLoggedInPort(
2500 fcChip,
2501 NULL, // don't search SCSI Nexus
2502 0xFFFFFC, // search linked list for Fabric port_id
2503 NULL, // don't search WWN
2504 NULL); // (don't care about end of list)
2505
2506 if( pLoggedInPort ) // If found, we have prior experience with
2507 // this port -- check whether PDISC is needed
2508 {
2509 if( pLoggedInPort->flogi )
2510 {
2511 // does the switch support FDISC?? (FLOGI for now...)
2512 loginType = ELS_FLOGI; // prior FLOGI still valid
2513 }
2514 else
2515 loginType = ELS_FLOGI; // expired FLOGI
2516 }
2517 else // first FLOGI?
2518 loginType = ELS_FLOGI;
2519
2520
2521 fchs.s_id = 0xFFFFFE; // well known F_Port address
2522
2523 // Fabrics are not required to support FDISC, and
2524 // it's not clear if that helps us anyway, since
2525 // we'll want a Name Service Request to re-verify
2526 // visible devices...
2527 // Consequently, we always want our upper 16 bit
2528 // port_id to be zero (we'll be rejected if we
2529 // use our prior port_id if we've been plugged into
2530 // a different switch port).
2531 // Trick Tachyon to send to ALPA 0 (see TL/TS UG, pg 87)
2532 // If our ALPA is 55h for instance, we want the FC frame
2533 // s_id to be 0x000055, while Tach's my_al_pa register
2534 // must be 0x000155, to force an OPN at ALPA 0
2535 // (the Fabric port)
2536 fcChip->Registers.my_al_pa &= 0xFF; // only use ALPA for FLOGI
2537 writel( fcChip->Registers.my_al_pa | 0x0100,
2538 fcChip->Registers.ReMapMemBase + TL_MEM_TACH_My_ID);
2539 }
2540
2541 else // not FLOGI...
2542 {
2543 // should we send PLOGI or PDISC? Check if any prior port_id
2544 // (e.g. alpa) completed a PLOGI/PRLI exchange by checking
2545 // the pdisc flag.
2546
2547 pLoggedInPort = fcFindLoggedInPort(
2548 fcChip,
2549 NULL, // don't search SCSI Nexus
2550 fchs.s_id, // search linked list for al_pa
2551 NULL, // don't search WWN
2552 NULL); // (don't care about end of list)
2553
2554
2555
2556 if( pLoggedInPort ) // If found, we have prior experience with
2557 // this port -- check whether PDISC is needed
2558 {
2559 if( pLoggedInPort->pdisc )
2560 {
2561 loginType = ELS_PDISC; // prior PLOGI and PRLI maybe still valid
2562
2563 }
2564 else
2565 loginType = ELS_PLOGI; // prior knowledge, but can't use PDISC
2566 }
2567 else // never talked to this port_id before
2568 loginType = ELS_PLOGI; // prior knowledge, but can't use PDISC
2569 }
2570
2571
2572
2573 ulStatus = cpqfcTSBuildExchange(
2574 cpqfcHBAdata,
2575 loginType, // e.g. PLOGI
2576 &fchs, // no incoming frame (we are originator)
2577 NULL, // no data (no scatter/gather list)
2578 &ExchangeID );// fcController->fcExchanges index, -1 if failed
2579
2580 if( !ulStatus ) // Exchange setup OK?
2581 {
2582 ulStatus = cpqfcTSStartExchange( cpqfcHBAdata, ExchangeID );
2583 if( !ulStatus )
2584 {
2585 // submitted to Tach's Outbound Que (ERQ PI incremented)
2586 // waited for completion for ELS type (Login frames issued
2587 // synchronously)
2588
2589 if( loginType == ELS_PDISC )
2590 {
2591 // now, we really shouldn't Revalidate SEST exchanges until
2592 // we get an ACC reply from our target and verify that
2593 // the target address/WWN is unchanged. However, when a fast
2594 // target gets the PDISC, they can send SEST Exchange data
2595 // before we even get around to processing the PDISC ACC.
2596 // Consequently, we lose the I/O.
2597 // To avoid this, go ahead and Revalidate when the PDISC goes
2598 // out, anticipating that the ACC will be truly acceptable
2599 // (this happens 99.9999....% of the time).
2600 // If we revalidate a SEST write, and write data goes to a
2601 // target that is NOT the one we originated the WRITE to,
2602 // that target is required (FCP-SCSI specs, etc) to discard
2603 // our WRITE data.
2604
2605 // Re-validate SEST entries (Tachyon hardware assists)
2606 RevalidateSEST( cpqfcHBAdata->HostAdapter, pLoggedInPort);
2607 //TriggerHBA( fcChip->Registers.ReMapMemBase, 1);
2608 }
2609 }
2610 else // give up immediately on error
2611 {
2612#ifdef LOGIN_DBG
2613 printk("SendLogins: fcStartExchange failed: %Xh\n", ulStatus );
2614#endif
2615 break;
2616 }
2617
2618
2619 if( fcChip->Registers.FMstatus.value & 0x080 ) // LDn during Port Disc.
2620 {
2621 ulStatus = LNKDWN_OSLS;
2622#ifdef LOGIN_DBG
2623 printk("SendLogins: PortDisc aborted (LDn) @alpa %Xh\n", fchs.s_id);
2624#endif
2625 break;
2626 }
2627 // Check the exchange for bad status (i.e. FrameTimeOut),
2628 // and complete on bad status (most likely due to BAD_ALPA)
2629 // on LDn, DPC function may already complete (ABORT) a started
2630 // exchange, so check type first (type = 0 on complete).
2631 if( Exchanges->fcExchange[ExchangeID].status )
2632 {
2633#ifdef LOGIN_DBG
2634 printk("completing x_ID %X on status %Xh\n",
2635 ExchangeID, Exchanges->fcExchange[ExchangeID].status);
2636#endif
2637 cpqfcTSCompleteExchange( cpqfcHBAdata->PciDev, fcChip, ExchangeID);
2638 }
2639 }
2640 else // Xchange setup failed...
2641 {
2642#ifdef LOGIN_DBG
2643 printk("FC: cpqfcTSBuildExchange failed: %Xh\n", ulStatus );
2644#endif
2645 break;
2646 }
2647 }
2648 if( !ulStatus )
2649 {
2650 // set the event signifying that all ALPAs were sent out.
2651#ifdef LOGIN_DBG
2652 printk("SendLogins: PortDiscDone\n");
2653#endif
2654 cpqfcHBAdata->PortDiscDone = 1;
2655
2656
2657 // TL/TS UG, pg. 184
2658 // 0x0065 = 100ms for RT_TOV
2659 // 0x01f5 = 500ms for ED_TOV
2660 fcChip->Registers.ed_tov.value = 0x006501f5L;
2661 writel( fcChip->Registers.ed_tov.value,
2662 (fcChip->Registers.ed_tov.address));
2663
2664 // set the LP_TOV back to ED_TOV (i.e. 500 ms)
2665 writel( 0x00000010, fcChip->Registers.ReMapMemBase +TL_MEM_FM_TIMEOUT2);
2666 }
2667 else
2668 {
2669 printk("SendLogins: failed at xchng %Xh, alpa %Xh, status %Xh\n",
2670 ExchangeID, fchs.s_id, ulStatus);
2671 }
2672 LEAVE("SendLogins");
2673
2674}
2675
2676
2677// for REPORT_LUNS documentation, see "In-Depth Exploration of Scsi",
2678// D. Deming, 1994, pg 7-19 (ISBN 1-879936-08-9)
2679static void ScsiReportLunsDone(Scsi_Cmnd *Cmnd)
2680{
2681 struct Scsi_Host *HostAdapter = Cmnd->device->host;
2682 CPQFCHBA *cpqfcHBAdata = (CPQFCHBA *)HostAdapter->hostdata;
2683 PTACHYON fcChip = &cpqfcHBAdata->fcChip;
2684 FC_EXCHANGES *Exchanges = fcChip->Exchanges;
2685 PFC_LOGGEDIN_PORT pLoggedInPort;
2686 int LunListLen=0;
2687 int i;
2688 ULONG x_ID = 0xFFFFFFFF;
2689 UCHAR *ucBuff = Cmnd->request_buffer;
2690
2691// printk("cpqfcTS: ReportLunsDone \n");
2692 // first, we need to find the Exchange for this command,
2693 // so we can find the fcPort struct to make the indicated
2694 // changes.
2695 for( i=0; i< TACH_SEST_LEN; i++)
2696 {
2697 if( Exchanges->fcExchange[i].type // exchange defined?
2698 &&
2699 (Exchanges->fcExchange[i].Cmnd == Cmnd) ) // matches?
2700
2701 {
2702 x_ID = i; // found exchange!
2703 break;
2704 }
2705 }
2706 if( x_ID == 0xFFFFFFFF)
2707 {
2708// printk("cpqfcTS: ReportLuns failed - no FC Exchange\n");
2709 goto Done; // Report Luns FC Exchange gone;
2710 // exchange probably Terminated by Implicit logout
2711 }
2712
2713
2714 // search linked list for the port_id we sent INQUIRY to
2715 pLoggedInPort = fcFindLoggedInPort( fcChip,
2716 NULL, // DON'T search Scsi Nexus (we will set it)
2717 Exchanges->fcExchange[ x_ID].fchs.d_id & 0xFFFFFF,
2718 NULL, // DON'T search linked list for FC WWN
2719 NULL); // DON'T care about end of list
2720
2721 if( !pLoggedInPort )
2722 {
2723// printk("cpqfcTS: ReportLuns failed - device gone\n");
2724 goto Done; // error! can't find logged in Port
2725 }
2726 LunListLen = ucBuff[3];
2727 LunListLen += ucBuff[2]>>8;
2728
2729 if( !LunListLen ) // failed
2730 {
2731 // generically speaking, a soft error means we should retry...
2732 if( (Cmnd->result >> 16) == DID_SOFT_ERROR )
2733 {
2734 if( ((Cmnd->sense_buffer[2] & 0xF) == 0x6) &&
2735 (Cmnd->sense_buffer[12] == 0x29) ) // Sense Code "reset"
2736 {
2737 TachFCHDR_GCMND *fchs = &Exchanges->fcExchange[ x_ID].fchs;
2738 // did we fail because of "check condition, device reset?"
2739 // e.g. the device was reset (i.e., at every power up)
2740 // retry the Report Luns
2741
2742 // who are we sending it to?
2743 // we know this because we have a copy of the command
2744 // frame from the original Report Lun command -
2745 // switch the d_id/s_id fields, because the Exchange Build
2746 // context is "reply to source".
2747
2748 fchs->s_id = fchs->d_id; // (temporarily re-use the struct)
2749 cpqfcTSPutLinkQue( cpqfcHBAdata, SCSI_REPORT_LUNS, fchs );
2750 }
2751 }
2752 else // probably, the device doesn't support Report Luns
2753 pLoggedInPort->ScsiNexus.VolumeSetAddressing = 0;
2754 }
2755 else // we have LUN info - check VSA mode
2756 {
2757 // for now, assume all LUNs will have same addr mode
2758 // for VSA, payload byte 8 will be 0x40; otherwise, 0
2759 pLoggedInPort->ScsiNexus.VolumeSetAddressing = ucBuff[8];
2760
2761 // Since we got a Report Luns answer, set lun masking flag
2762 pLoggedInPort->ScsiNexus.LunMasking = 1;
2763
2764 if( LunListLen > 8*CPQFCTS_MAX_LUN) // We expect CPQFCTS_MAX_LUN max
2765 LunListLen = 8*CPQFCTS_MAX_LUN;
2766
2767/*
2768 printk("Device WWN %08X%08X Reports Luns @: ",
2769 (ULONG)(pLoggedInPort->u.liWWN &0xFFFFFFFF),
2770 (ULONG)(pLoggedInPort->u.liWWN>>32));
2771
2772 for( i=8; i<LunListLen+8; i+=8)
2773 {
2774 printk("%02X%02X ", ucBuff[i], ucBuff[i+1] );
2775 }
2776 printk("\n");
2777*/
2778
2779 // Since the device was kind enough to tell us where the
2780 // LUNs are, lets ensure they are contiguous for Linux's
2781 // SCSI driver scan, which expects them to start at 0.
2782 // Since Linux only supports 8 LUNs, only copy the first
2783 // eight from the report luns command
2784
2785 // e.g., the Compaq RA4x00 f/w Rev 2.54 and above may report
2786 // LUNs 4001, 4004, etc., because other LUNs are masked from
2787 // this HBA (owned by someone else). We'll make those appear as
2788 // LUN 0, 1... to Linux
2789 {
2790 int j;
2791 int AppendLunList = 0;
2792 // Walk through the LUN list. The 'j' array number is
2793 // Linux's lun #, while the value of .lun[j] is the target's
2794 // lun #.
2795 // Once we build a LUN list, it's possible for a known device
2796 // to go offline while volumes (LUNs) are added. Later,
2797 // the device will do another PLOGI ... Report Luns command,
2798 // and we must not alter the existing Linux Lun map.
2799 // (This will be very rare).
2800 for( j=0; j < CPQFCTS_MAX_LUN; j++)
2801 {
2802 if( pLoggedInPort->ScsiNexus.lun[j] != 0xFF )
2803 {
2804 AppendLunList = 1;
2805 break;
2806 }
2807 }
2808 if( AppendLunList )
2809 {
2810 int k;
2811 int FreeLunIndex;
2812// printk("cpqfcTS: AppendLunList\n");
2813
2814 // If we get a new Report Luns, we cannot change
2815 // any existing LUN mapping! (Only additive entry)
2816 // For all LUNs in ReportLun list
2817 // if RL lun != ScsiNexus lun
2818 // if RL lun present in ScsiNexus lun[], continue
2819 // else find ScsiNexus lun[]==FF and add, continue
2820
2821 for( i=8, j=0; i<LunListLen+8 && j< CPQFCTS_MAX_LUN; i+=8, j++)
2822 {
2823 if( pLoggedInPort->ScsiNexus.lun[j] != ucBuff[i+1] )
2824 {
2825 // something changed from the last Report Luns
2826 printk(" cpqfcTS: Report Lun change!\n");
2827 for( k=0, FreeLunIndex=CPQFCTS_MAX_LUN;
2828 k < CPQFCTS_MAX_LUN; k++)
2829 {
2830 if( pLoggedInPort->ScsiNexus.lun[k] == 0xFF)
2831 {
2832 FreeLunIndex = k;
2833 break;
2834 }
2835 if( pLoggedInPort->ScsiNexus.lun[k] == ucBuff[i+1] )
2836 break; // we already masked this lun
2837 }
2838 if( k >= CPQFCTS_MAX_LUN )
2839 {
2840 printk(" no room for new LUN %d\n", ucBuff[i+1]);
2841 }
2842 else if( k == FreeLunIndex ) // need to add LUN
2843 {
2844 pLoggedInPort->ScsiNexus.lun[k] = ucBuff[i+1];
2845// printk("add [%d]->%02d\n", k, pLoggedInPort->ScsiNexus.lun[k]);
2846
2847 }
2848 else
2849 {
2850 // lun already known
2851 }
2852 break;
2853 }
2854 }
2855 // print out the new list...
2856 for( j=0; j< CPQFCTS_MAX_LUN; j++)
2857 {
2858 if( pLoggedInPort->ScsiNexus.lun[j] == 0xFF)
2859 break; // done
2860// printk("[%d]->%02d ", j, pLoggedInPort->ScsiNexus.lun[j]);
2861 }
2862 }
2863 else
2864 {
2865// printk("Linux SCSI LUNs[] -> Device LUNs: ");
2866 // first time - this is easy
2867 for( i=8, j=0; i<LunListLen+8 && j< CPQFCTS_MAX_LUN; i+=8, j++)
2868 {
2869 pLoggedInPort->ScsiNexus.lun[j] = ucBuff[i+1];
2870// printk("[%d]->%02d ", j, pLoggedInPort->ScsiNexus.lun[j]);
2871 }
2872// printk("\n");
2873 }
2874 }
2875 }
2876
2877Done: ;
2878}
2879
2880extern int is_private_data_of_cpqfc(CPQFCHBA *hba, void * pointer);
2881extern void cpqfc_free_private_data(CPQFCHBA *hba, cpqfc_passthru_private_t *data);
2882
2883static void
2884call_scsi_done(Scsi_Cmnd *Cmnd)
2885{
2886 CPQFCHBA *hba;
2887 hba = (CPQFCHBA *) Cmnd->device->host->hostdata;
2888 // Was this command a cpqfc passthru ioctl ?
2889 if (Cmnd->sc_request != NULL && Cmnd->device->host != NULL &&
2890 Cmnd->device->host->hostdata != NULL &&
2891 is_private_data_of_cpqfc((CPQFCHBA *) Cmnd->device->host->hostdata,
2892 Cmnd->sc_request->upper_private_data)) {
2893 cpqfc_free_private_data(hba,
2894 Cmnd->sc_request->upper_private_data);
2895 Cmnd->sc_request->upper_private_data = NULL;
2896 Cmnd->result &= 0xff00ffff;
2897 Cmnd->result |= (DID_PASSTHROUGH << 16); // prevents retry
2898 }
2899 if (Cmnd->scsi_done != NULL)
2900 (*Cmnd->scsi_done)(Cmnd);
2901}
2902
2903// After successfully getting a "Process Login" (PRLI) from an
2904// FC port, we want to Discover the LUNs so that we know the
2905// addressing type (e.g., FCP-SCSI Volume Set Address, Peripheral
2906// Unit Device), and whether SSP (Selective Storage Presentation or
2907// Lun Masking) has made the LUN numbers non-zero based or
2908// non-contiguous. To remain backward compatible with the SCSI-2
2909// driver model, which expects a contiguous LUNs starting at 0,
2910// will use the ReportLuns info to map from "device" to "Linux"
2911// LUNs.
2912static void IssueReportLunsCommand(
2913 CPQFCHBA* cpqfcHBAdata,
2914 TachFCHDR_GCMND* fchs)
2915{
2916 PTACHYON fcChip = &cpqfcHBAdata->fcChip;
2917 PFC_LOGGEDIN_PORT pLoggedInPort;
2918 struct scsi_cmnd *Cmnd = NULL;
2919 struct scsi_device *ScsiDev = NULL;
2920 LONG x_ID;
2921 ULONG ulStatus;
2922 UCHAR *ucBuff;
2923
2924 if( !cpqfcHBAdata->PortDiscDone) // cleared by LDn
2925 {
2926 printk("Discard Q'd ReportLun command\n");
2927 goto Done;
2928 }
2929
2930 // find the device (from port_id) we're talking to
2931 pLoggedInPort = fcFindLoggedInPort( fcChip,
2932 NULL, // DON'T search Scsi Nexus
2933 fchs->s_id & 0xFFFFFF,
2934 NULL, // DON'T search linked list for FC WWN
2935 NULL); // DON'T care about end of list
2936 if( pLoggedInPort ) // we'd BETTER find it!
2937 {
2938
2939
2940 if( !(pLoggedInPort->fcp_info & TARGET_FUNCTION) )
2941 goto Done; // forget it - FC device not a "target"
2942
2943
2944 ScsiDev = scsi_get_host_dev (cpqfcHBAdata->HostAdapter);
2945 if (!ScsiDev)
2946 goto Done;
2947
2948 Cmnd = scsi_get_command (ScsiDev, GFP_KERNEL);
2949 if (!Cmnd)
2950 goto Done;
2951
2952 ucBuff = pLoggedInPort->ReportLunsPayload;
2953
2954 memset( ucBuff, 0, REPORT_LUNS_PL);
2955
2956 Cmnd->scsi_done = ScsiReportLunsDone;
2957
2958 Cmnd->request_buffer = pLoggedInPort->ReportLunsPayload;
2959 Cmnd->request_bufflen = REPORT_LUNS_PL;
2960
2961 Cmnd->cmnd[0] = 0xA0;
2962 Cmnd->cmnd[8] = REPORT_LUNS_PL >> 8;
2963 Cmnd->cmnd[9] = (UCHAR)REPORT_LUNS_PL;
2964 Cmnd->cmd_len = 12;
2965
2966 Cmnd->device->channel = pLoggedInPort->ScsiNexus.channel;
2967 Cmnd->device->id = pLoggedInPort->ScsiNexus.target;
2968
2969
2970 ulStatus = cpqfcTSBuildExchange(
2971 cpqfcHBAdata,
2972 SCSI_IRE,
2973 fchs,
2974 Cmnd, // buffer for Report Lun data
2975 &x_ID );// fcController->fcExchanges index, -1 if failed
2976
2977 if( !ulStatus ) // Exchange setup?
2978 {
2979 ulStatus = cpqfcTSStartExchange( cpqfcHBAdata, x_ID );
2980 if( !ulStatus )
2981 {
2982 // submitted to Tach's Outbound Que (ERQ PI incremented)
2983 // waited for completion for ELS type (Login frames issued
2984 // synchronously)
2985 }
2986 else
2987 // check reason for Exchange not being started - we might
2988 // want to Queue and start later, or fail with error
2989 {
2990
2991 }
2992 }
2993
2994 else // Xchange setup failed...
2995 printk(" cpqfcTSBuildExchange failed: %Xh\n", ulStatus );
2996 }
2997 else // like, we just got a PRLI ACC, and now the port is gone?
2998 {
2999 printk(" can't send ReportLuns - no login for port_id %Xh\n",
3000 fchs->s_id & 0xFFFFFF);
3001 }
3002
3003
3004
3005Done:
3006
3007 if (Cmnd)
3008 scsi_put_command (Cmnd);
3009 if (ScsiDev)
3010 scsi_free_host_dev (ScsiDev);
3011}
3012
3013
3014
3015
3016
3017
3018
3019static void CompleteBoardLockCmnd( CPQFCHBA *cpqfcHBAdata)
3020{
3021 int i;
3022 for( i = CPQFCTS_REQ_QUEUE_LEN-1; i>= 0; i--)
3023 {
3024 if( cpqfcHBAdata->BoardLockCmnd[i] != NULL )
3025 {
3026 Scsi_Cmnd *Cmnd = cpqfcHBAdata->BoardLockCmnd[i];
3027 cpqfcHBAdata->BoardLockCmnd[i] = NULL;
3028 Cmnd->result = (DID_SOFT_ERROR << 16); // ask for retry
3029// printk(" BoardLockCmnd[%d] %p Complete, chnl/target/lun %d/%d/%d\n",
3030// i,Cmnd, Cmnd->channel, Cmnd->target, Cmnd->lun);
3031 call_scsi_done(Cmnd);
3032 }
3033 }
3034}
3035
3036
3037
3038
3039
3040
3041// runs every 1 second for FC exchange timeouts and implicit FC device logouts
3042
3043void cpqfcTSheartbeat( unsigned long ptr )
3044{
3045 CPQFCHBA *cpqfcHBAdata = (CPQFCHBA *)ptr;
3046 PTACHYON fcChip = &cpqfcHBAdata->fcChip;
3047 FC_EXCHANGES *Exchanges = fcChip->Exchanges;
3048 PFC_LOGGEDIN_PORT pLoggedInPort = &fcChip->fcPorts;
3049 ULONG i;
3050 unsigned long flags;
3051 DECLARE_MUTEX_LOCKED(BoardLock);
3052
3053 PCI_TRACE( 0xA8)
3054
3055 if( cpqfcHBAdata->BoardLock) // Worker Task Running?
3056 goto Skip;
3057
3058 // STOP _que function
3059 spin_lock_irqsave( cpqfcHBAdata->HostAdapter->host_lock, flags);
3060
3061 PCI_TRACE( 0xA8)
3062
3063
3064 cpqfcHBAdata->BoardLock = &BoardLock; // stop Linux SCSI command queuing
3065
3066 // release the IO lock (and re-enable interrupts)
3067 spin_unlock_irqrestore( cpqfcHBAdata->HostAdapter->host_lock, flags);
3068
3069 // Ensure no contention from _quecommand or Worker process
3070 CPQ_SPINLOCK_HBA( cpqfcHBAdata)
3071
3072 PCI_TRACE( 0xA8)
3073
3074
3075 disable_irq( cpqfcHBAdata->HostAdapter->irq); // our IRQ
3076
3077 // Complete the "bad target" commands (normally only used during
3078 // initialization, since we aren't supposed to call "scsi_done"
3079 // inside the queuecommand() function). (this is overly contorted,
3080 // scsi_done can be safely called from queuecommand for
3081 // this bad target case. May want to simplify this later)
3082
3083 for( i=0; i< CPQFCTS_MAX_TARGET_ID; i++)
3084 {
3085 if( cpqfcHBAdata->BadTargetCmnd[i] )
3086 {
3087 Scsi_Cmnd *Cmnd = cpqfcHBAdata->BadTargetCmnd[i];
3088 cpqfcHBAdata->BadTargetCmnd[i] = NULL;
3089 Cmnd->result = (DID_BAD_TARGET << 16);
3090 call_scsi_done(Cmnd);
3091 }
3092 else
3093 break;
3094 }
3095
3096
3097 // logged in ports -- re-login check (ports required to verify login with
3098 // PDISC after LIP within 2 secs)
3099
3100 // prevent contention
3101 while( pLoggedInPort ) // for all ports which are expecting
3102 // PDISC after the next LIP, check to see if
3103 // time is up!
3104 {
3105 // Important: we only detect "timeout" condition on TRANSITION
3106 // from non-zero to zero
3107 if( pLoggedInPort->LOGO_timer ) // time-out "armed"?
3108 {
3109 if( !(--pLoggedInPort->LOGO_timer) ) // DEC from 1 to 0?
3110 {
3111 // LOGOUT time! Per PLDA, PDISC hasn't complete in 2 secs, so
3112 // issue LOGO request and destroy all I/O with other FC port(s).
3113
3114/*
3115 printk(" ~cpqfcTS heartbeat: LOGOut!~ ");
3116 printk("Linux SCSI Chanl/Target %d/%d (port_id %06Xh) WWN %08X%08X\n",
3117 pLoggedInPort->ScsiNexus.channel,
3118 pLoggedInPort->ScsiNexus.target,
3119 pLoggedInPort->port_id,
3120 (ULONG)(pLoggedInPort->u.liWWN &0xFFFFFFFF),
3121 (ULONG)(pLoggedInPort->u.liWWN>>32));
3122
3123*/
3124 cpqfcTSImplicitLogout( cpqfcHBAdata, pLoggedInPort);
3125
3126 }
3127 // else simply decremented - maybe next time...
3128 }
3129 pLoggedInPort = pLoggedInPort->pNextPort;
3130 }
3131
3132
3133
3134
3135
3136 // ************ FC EXCHANGE TIMEOUT CHECK **************
3137
3138 for( i=0; i< TACH_MAX_XID; i++)
3139 {
3140 if( Exchanges->fcExchange[i].type ) // exchange defined?
3141 {
3142
3143 if( !Exchanges->fcExchange[i].timeOut ) // time expired
3144 {
3145 // Set Exchange timeout status
3146 Exchanges->fcExchange[i].status |= FC2_TIMEOUT;
3147
3148 if( i >= TACH_SEST_LEN ) // Link Service Exchange
3149 {
3150 cpqfcTSCompleteExchange( cpqfcHBAdata->PciDev, fcChip, i); // Don't "abort" LinkService
3151 }
3152
3153 else // SEST Exchange TO -- may post ABTS to Worker Thread Que
3154 {
3155 // (Make sure we don't keep timing it out; let other functions
3156 // complete it or set the timeOut as needed)
3157 Exchanges->fcExchange[i].timeOut = 30000; // seconds default
3158
3159 if( Exchanges->fcExchange[i].type
3160 &
3161 (BLS_ABTS | BLS_ABTS_ACC ) )
3162 {
3163 // For BLS_ABTS*, an upper level might still have
3164 // an outstanding command waiting for low-level completion.
3165 // Also, in the case of a WRITE, we MUST get confirmation
3166 // of either ABTS ACC or RJT before re-using the Exchange.
3167 // It's possible that the RAID cache algorithm can hang
3168 // if we fail to complete a WRITE to a LBA, when a READ
3169 // comes later to that same LBA. Therefore, we must
3170 // ensure that the target verifies receipt of ABTS for
3171 // the exchange
3172
3173 printk("~TO Q'd ABTS (x_ID %Xh)~ ", i);
3174// TriggerHBA( fcChip->Registers.ReMapMemBase);
3175
3176 // On timeout of a ABTS exchange, check to
3177 // see if the FC device has a current valid login.
3178 // If so, restart it.
3179 pLoggedInPort = fcFindLoggedInPort( fcChip,
3180 Exchanges->fcExchange[i].Cmnd, // find Scsi Nexus
3181 0, // DON'T search linked list for FC port id
3182 NULL, // DON'T search linked list for FC WWN
3183 NULL); // DON'T care about end of list
3184
3185 // device exists?
3186 if( pLoggedInPort ) // device exists?
3187 {
3188 if( pLoggedInPort->prli ) // logged in for FCP-SCSI?
3189 {
3190 // attempt to restart the ABTS
3191 printk(" ~restarting ABTS~ ");
3192 cpqfcTSStartExchange( cpqfcHBAdata, i );
3193
3194 }
3195 }
3196 }
3197 else // not an ABTS
3198 {
3199
3200 // We expect the WorkerThread to change the xchng type to
3201 // abort and set appropriate timeout.
3202 cpqfcTSPutLinkQue( cpqfcHBAdata, BLS_ABTS, &i ); // timed-out
3203 }
3204 }
3205 }
3206 else // time not expired...
3207 {
3208 // decrement timeout: 1 or more seconds left
3209 --Exchanges->fcExchange[i].timeOut;
3210 }
3211 }
3212 }
3213
3214
3215 enable_irq( cpqfcHBAdata->HostAdapter->irq);
3216
3217
3218 CPQ_SPINUNLOCK_HBA( cpqfcHBAdata)
3219
3220 cpqfcHBAdata->BoardLock = NULL; // Linux SCSI commands may be queued
3221
3222 // Now, complete any Cmnd we Q'd up while BoardLock was held
3223
3224 CompleteBoardLockCmnd( cpqfcHBAdata);
3225
3226
3227 // restart the timer to run again (1 sec later)
3228Skip:
3229 mod_timer( &cpqfcHBAdata->cpqfcTStimer, jiffies + HZ);
3230
3231 PCI_TRACEO( i, 0xA8)
3232 return;
3233}
3234
3235
3236// put valid FC-AL physical address in spec order
3237static const UCHAR valid_al_pa[]={
3238 0xef, 0xe8, 0xe4, 0xe2,
3239 0xe1, 0xE0, 0xDC, 0xDA,
3240 0xD9, 0xD6, 0xD5, 0xD4,
3241 0xD3, 0xD2, 0xD1, 0xCe,
3242 0xCd, 0xCc, 0xCb, 0xCa,
3243 0xC9, 0xC7, 0xC6, 0xC5,
3244 0xC3, 0xBc, 0xBa, 0xB9,
3245 0xB6, 0xB5, 0xB4, 0xB3,
3246 0xB2, 0xB1, 0xae, 0xad,
3247 0xAc, 0xAb, 0xAa, 0xA9,
3248
3249 0xA7, 0xA6, 0xA5, 0xA3,
3250 0x9f, 0x9e, 0x9d, 0x9b,
3251 0x98, 0x97, 0x90, 0x8f,
3252 0x88, 0x84, 0x82, 0x81,
3253 0x80, 0x7c, 0x7a, 0x79,
3254 0x76, 0x75, 0x74, 0x73,
3255 0x72, 0x71, 0x6e, 0x6d,
3256 0x6c, 0x6b, 0x6a, 0x69,
3257 0x67, 0x66, 0x65, 0x63,
3258 0x5c, 0x5a, 0x59, 0x56,
3259
3260 0x55, 0x54, 0x53, 0x52,
3261 0x51, 0x4e, 0x4d, 0x4c,
3262 0x4b, 0x4a, 0x49, 0x47,
3263 0x46, 0x45, 0x43, 0x3c,
3264 0x3a, 0x39, 0x36, 0x35,
3265 0x34, 0x33, 0x32, 0x31,
3266 0x2e, 0x2d, 0x2c, 0x2b,
3267 0x2a, 0x29, 0x27, 0x26,
3268 0x25, 0x23, 0x1f, 0x1E,
3269 0x1d, 0x1b, 0x18, 0x17,
3270
3271 0x10, 0x0f, 8, 4, 2, 1 }; // ALPA 0 (Fabric) is special case
3272
3273const int number_of_al_pa = (sizeof(valid_al_pa) );
3274
3275
3276
3277// this function looks up an al_pa from the table of valid al_pa's
3278// we decrement from the last decimal loop ID, because soft al_pa
3279// (our typical case) are assigned with highest priority (and high al_pa)
3280// first. See "In-Depth FC-AL", R. Kembel pg. 38
3281// INPUTS:
3282// al_pa - 24 bit port identifier (8 bit al_pa on private loop)
3283// RETURN:
3284// Loop ID - serves are index to array of logged in ports
3285// -1 - invalid al_pa (not all 8 bit values are legal)
3286
3287#if (0)
3288static int GetLoopID( ULONG al_pa )
3289{
3290 int i;
3291
3292 for( i = number_of_al_pa -1; i >= 0; i--) // dec.
3293 {
3294 if( valid_al_pa[i] == (UCHAR)al_pa ) // take lowest 8 bits
3295 return i; // success - found valid al_pa; return decimal LoopID
3296 }
3297 return -1; // failed - not found
3298}
3299#endif
3300
3301extern cpqfc_passthru_private_t *cpqfc_private(Scsi_Request *sr);
3302
3303// Search the singly (forward) linked list "fcPorts" looking for
3304// either the SCSI target (if != -1), port_id (if not NULL),
3305// or WWN (if not null), in that specific order.
3306// If we find a SCSI nexus (from Cmnd arg), set the SCp.phase
3307// field according to VSA or PDU
3308// RETURNS:
3309// Ptr to logged in port struct if found
3310// (NULL if not found)
3311// pLastLoggedInPort - ptr to last struct (for adding new ones)
3312//
3313PFC_LOGGEDIN_PORT fcFindLoggedInPort(
3314 PTACHYON fcChip,
3315 Scsi_Cmnd *Cmnd, // search linked list for Scsi Nexus (channel/target/lun)
3316 ULONG port_id, // search linked list for al_pa, or
3317 UCHAR wwn[8], // search linked list for WWN, or...
3318 PFC_LOGGEDIN_PORT *pLastLoggedInPort )
3319
3320{
3321 PFC_LOGGEDIN_PORT pLoggedInPort = &fcChip->fcPorts;
3322 BOOLEAN target_id_valid=FALSE;
3323 BOOLEAN port_id_valid=FALSE;
3324 BOOLEAN wwn_valid=FALSE;
3325 int i;
3326
3327
3328 if( Cmnd != NULL )
3329 target_id_valid = TRUE;
3330
3331 else if( port_id ) // note! 24-bit NULL address is illegal
3332 port_id_valid = TRUE;
3333
3334 else
3335 {
3336 if( wwn ) // non-null arg? (OK to pass NULL when not searching WWN)
3337 {
3338 for( i=0; i<8; i++) // valid WWN passed? NULL WWN invalid
3339 {
3340 if( wwn[i] != 0 )
3341 wwn_valid = TRUE; // any non-zero byte makes (presumably) valid
3342 }
3343 }
3344 }
3345 // check other options ...
3346
3347
3348 // In case multiple search options are given, we use a priority
3349 // scheme:
3350 // While valid pLoggedIn Ptr
3351 // If port_id is valid
3352 // if port_id matches, return Ptr
3353 // If wwn is valid
3354 // if wwn matches, return Ptr
3355 // Next Ptr in list
3356 //
3357 // Return NULL (not found)
3358
3359
3360 while( pLoggedInPort ) // NULL marks end of list (1st ptr always valid)
3361 {
3362 if( pLastLoggedInPort ) // caller's pointer valid?
3363 *pLastLoggedInPort = pLoggedInPort; // end of linked list
3364
3365 if( target_id_valid )
3366 {
3367 // check Linux Scsi Cmnd for channel/target Nexus match
3368 // (all luns are accessed through matching "pLoggedInPort")
3369 if( (pLoggedInPort->ScsiNexus.target == Cmnd->device->id)
3370 &&
3371 (pLoggedInPort->ScsiNexus.channel == Cmnd->device->channel))
3372 {
3373 // For "passthru" modes, the IOCTL caller is responsible
3374 // for setting the FCP-LUN addressing
3375 if (Cmnd->sc_request != NULL && Cmnd->device->host != NULL &&
3376 Cmnd->device->host->hostdata != NULL &&
3377 is_private_data_of_cpqfc((CPQFCHBA *) Cmnd->device->host->hostdata,
3378 Cmnd->sc_request->upper_private_data)) {
3379 /* This is a passthru... */
3380 cpqfc_passthru_private_t *pd;
3381 pd = Cmnd->sc_request->upper_private_data;
3382 Cmnd->SCp.phase = pd->bus;
3383 // Cmnd->SCp.have_data_in = pd->pdrive;
3384 Cmnd->SCp.have_data_in = Cmnd->device->lun;
3385 } else {
3386 /* This is not a passthru... */
3387
3388 // set the FCP-LUN addressing type
3389 Cmnd->SCp.phase = pLoggedInPort->ScsiNexus.VolumeSetAddressing;
3390
3391 // set the Device Type we got from the snooped INQUIRY string
3392 Cmnd->SCp.Message = pLoggedInPort->ScsiNexus.InqDeviceType;
3393
3394 // handle LUN masking; if not "default" (illegal) lun value,
3395 // the use it. These lun values are set by a successful
3396 // Report Luns command
3397 if( pLoggedInPort->ScsiNexus.LunMasking == 1)
3398 {
3399 if (Cmnd->device->lun > sizeof(pLoggedInPort->ScsiNexus.lun))
3400 return NULL;
3401 // we KNOW all the valid LUNs... 0xFF is invalid!
3402 Cmnd->SCp.have_data_in = pLoggedInPort->ScsiNexus.lun[Cmnd->device->lun];
3403 if (pLoggedInPort->ScsiNexus.lun[Cmnd->device->lun] == 0xFF)
3404 return NULL;
3405 // printk("xlating lun %d to 0x%02x\n", Cmnd->lun,
3406 // pLoggedInPort->ScsiNexus.lun[Cmnd->lun]);
3407 }
3408 else
3409 Cmnd->SCp.have_data_in = Cmnd->device->lun; // Linux & target luns match
3410 }
3411 break; // found it!
3412 }
3413 }
3414
3415 if( port_id_valid ) // look for alpa first
3416 {
3417 if( pLoggedInPort->port_id == port_id )
3418 break; // found it!
3419 }
3420 if( wwn_valid ) // look for wwn second
3421 {
3422
3423 if( !memcmp( &pLoggedInPort->u.ucWWN[0], &wwn[0], 8))
3424 {
3425 // all 8 bytes of WWN match
3426 break; // found it!
3427 }
3428 }
3429
3430 pLoggedInPort = pLoggedInPort->pNextPort; // try next port
3431 }
3432
3433 return pLoggedInPort;
3434}
3435
3436
3437
3438
3439//
3440// We need to examine the SEST table and re-validate
3441// any open Exchanges for this LoggedInPort
3442// To make Tachyon pay attention, Freeze FCP assists,
3443// set VAL bits, Unfreeze FCP assists
3444static void RevalidateSEST( struct Scsi_Host *HostAdapter,
3445 PFC_LOGGEDIN_PORT pLoggedInPort)
3446{
3447 CPQFCHBA *cpqfcHBAdata = (CPQFCHBA *)HostAdapter->hostdata;
3448 PTACHYON fcChip = &cpqfcHBAdata->fcChip;
3449 FC_EXCHANGES *Exchanges = fcChip->Exchanges;
3450 ULONG x_ID;
3451 BOOLEAN TachFroze = FALSE;
3452
3453
3454 // re-validate any SEST exchanges that are permitted
3455 // to survive the link down (e.g., good PDISC performed)
3456 for( x_ID = 0; x_ID < TACH_SEST_LEN; x_ID++)
3457 {
3458
3459 // If the SEST entry port_id matches the pLoggedInPort,
3460 // we need to re-validate
3461 if( (Exchanges->fcExchange[ x_ID].type == SCSI_IRE)
3462 ||
3463 (Exchanges->fcExchange[ x_ID].type == SCSI_IWE))
3464 {
3465
3466 if( (Exchanges->fcExchange[ x_ID].fchs.d_id & 0xFFFFFF) // (24-bit port ID)
3467 == pLoggedInPort->port_id)
3468 {
3469// printk(" re-val xID %Xh ", x_ID);
3470 if( !TachFroze ) // freeze if not already frozen
3471 TachFroze |= FreezeTach( cpqfcHBAdata);
3472 fcChip->SEST->u[ x_ID].IWE.Hdr_Len |= 0x80000000; // set VAL bit
3473 }
3474 }
3475 }
3476
3477 if( TachFroze)
3478 {
3479 fcChip->UnFreezeTachyon( fcChip, 2); // both ERQ and FCP assists
3480 }
3481}
3482
3483
3484// Complete an Linux Cmnds that we Queued because
3485// our FC link was down (cause immediate retry)
3486
3487static void UnblockScsiDevice( struct Scsi_Host *HostAdapter,
3488 PFC_LOGGEDIN_PORT pLoggedInPort)
3489{
3490 CPQFCHBA *cpqfcHBAdata = (CPQFCHBA *)HostAdapter->hostdata;
3491 Scsi_Cmnd* *SCptr = &cpqfcHBAdata->LinkDnCmnd[0];
3492 Scsi_Cmnd *Cmnd;
3493 int indx;
3494
3495
3496
3497 // if the device was previously "blocked", make sure
3498 // we unblock it so Linux SCSI will resume
3499
3500 pLoggedInPort->device_blocked = FALSE; // clear our flag
3501
3502 // check the Link Down command ptr buffer;
3503 // we can complete now causing immediate retry
3504 for( indx=0; indx < CPQFCTS_REQ_QUEUE_LEN; indx++, SCptr++)
3505 {
3506 if( *SCptr != NULL ) // scsi command to complete?
3507 {
3508#ifdef DUMMYCMND_DBG
3509 printk("complete Cmnd %p in LinkDnCmnd[%d]\n", *SCptr,indx);
3510#endif
3511 Cmnd = *SCptr;
3512
3513
3514 // Are there any Q'd commands for this target?
3515 if( (Cmnd->device->id == pLoggedInPort->ScsiNexus.target)
3516 &&
3517 (Cmnd->device->channel == pLoggedInPort->ScsiNexus.channel) )
3518 {
3519 Cmnd->result = (DID_SOFT_ERROR <<16); // force retry
3520 if( Cmnd->scsi_done == NULL)
3521 {
3522 printk("LinkDnCmnd scsi_done ptr null, port_id %Xh\n",
3523 pLoggedInPort->port_id);
3524 }
3525 else
3526 call_scsi_done(Cmnd);
3527 *SCptr = NULL; // free this slot for next use
3528 }
3529 }
3530 }
3531}
3532
3533
3534//#define WWN_DBG 1
3535
3536static void SetLoginFields(
3537 PFC_LOGGEDIN_PORT pLoggedInPort,
3538 TachFCHDR_GCMND* fchs,
3539 BOOLEAN PDisc,
3540 BOOLEAN Originator)
3541{
3542 LOGIN_PAYLOAD logi; // FC-PH Port Login
3543 PRLI_REQUEST prli; // copy for BIG ENDIAN switch
3544 int i;
3545#ifdef WWN_DBG
3546 ULONG ulBuff;
3547#endif
3548
3549 BigEndianSwap( (UCHAR*)&fchs->pl[0], (UCHAR*)&logi, sizeof(logi));
3550
3551 pLoggedInPort->Originator = Originator;
3552 pLoggedInPort->port_id = fchs->s_id & 0xFFFFFF;
3553
3554 switch( fchs->pl[0] & 0xffff )
3555 {
3556 case 0x00000002: // PLOGI or PDISC ACCept?
3557 if( PDisc ) // PDISC accept
3558 goto PDISC_case;
3559
3560 case 0x00000003: // ELS_PLOGI or ELS_PLOGI_ACC
3561
3562 // Login BB_credit typically 0 for Tachyons
3563 pLoggedInPort->BB_credit = logi.cmn_services.bb_credit;
3564
3565 // e.g. 128, 256, 1024, 2048 per FC-PH spec
3566 // We have to use this when setting up SEST Writes,
3567 // since that determines frame size we send.
3568 pLoggedInPort->rx_data_size = logi.class3.rx_data_size;
3569 pLoggedInPort->plogi = TRUE;
3570 pLoggedInPort->pdisc = FALSE;
3571 pLoggedInPort->prli = FALSE; // ELS_PLOGI resets
3572 pLoggedInPort->flogi = FALSE; // ELS_PLOGI resets
3573 pLoggedInPort->logo = FALSE; // ELS_PLOGI resets
3574 pLoggedInPort->LOGO_counter = 0;// ELS_PLOGI resets
3575 pLoggedInPort->LOGO_timer = 0;// ELS_PLOGI resets
3576
3577 // was this PLOGI to a Fabric?
3578 if( pLoggedInPort->port_id == 0xFFFFFC ) // well know address
3579 pLoggedInPort->flogi = TRUE;
3580
3581
3582 for( i=0; i<8; i++) // copy the LOGIN port's WWN
3583 pLoggedInPort->u.ucWWN[i] = logi.port_name[i];
3584
3585#ifdef WWN_DBG
3586 ulBuff = (ULONG)pLoggedInPort->u.liWWN;
3587 if( pLoggedInPort->Originator)
3588 printk("o");
3589 else
3590 printk("r");
3591 printk("PLOGI port_id %Xh, WWN %08X",
3592 pLoggedInPort->port_id, ulBuff);
3593
3594 ulBuff = (ULONG)(pLoggedInPort->u.liWWN >> 32);
3595 printk("%08Xh fcPort %p\n", ulBuff, pLoggedInPort);
3596#endif
3597 break;
3598
3599
3600
3601
3602 case 0x00000005: // ELS_LOGO (logout)
3603
3604
3605 pLoggedInPort->plogi = FALSE;
3606 pLoggedInPort->pdisc = FALSE;
3607 pLoggedInPort->prli = FALSE; // ELS_PLOGI resets
3608 pLoggedInPort->flogi = FALSE; // ELS_PLOGI resets
3609 pLoggedInPort->logo = TRUE; // ELS_PLOGI resets
3610 pLoggedInPort->LOGO_counter++; // ELS_PLOGI resets
3611 pLoggedInPort->LOGO_timer = 0;
3612#ifdef WWN_DBG
3613 ulBuff = (ULONG)pLoggedInPort->u.liWWN;
3614 if( pLoggedInPort->Originator)
3615 printk("o");
3616 else
3617 printk("r");
3618 printk("LOGO port_id %Xh, WWN %08X",
3619 pLoggedInPort->port_id, ulBuff);
3620
3621 ulBuff = (ULONG)(pLoggedInPort->u.liWWN >> 32);
3622 printk("%08Xh\n", ulBuff);
3623#endif
3624 break;
3625
3626
3627
3628PDISC_case:
3629 case 0x00000050: // ELS_PDISC or ELS_PDISC_ACC
3630 pLoggedInPort->LOGO_timer = 0; // stop the time-out
3631
3632 pLoggedInPort->prli = TRUE; // ready to accept FCP-SCSI I/O
3633
3634
3635
3636#ifdef WWN_DBG
3637 ulBuff = (ULONG)pLoggedInPort->u.liWWN;
3638 if( pLoggedInPort->Originator)
3639 printk("o");
3640 else
3641 printk("r");
3642 printk("PDISC port_id %Xh, WWN %08X",
3643 pLoggedInPort->port_id, ulBuff);
3644
3645 ulBuff = (ULONG)(pLoggedInPort->u.liWWN >> 32);
3646 printk("%08Xh\n", ulBuff);
3647#endif
3648
3649
3650
3651 break;
3652
3653
3654
3655 case 0x1020L: // PRLI?
3656 case 0x1002L: // PRLI ACCept?
3657 BigEndianSwap( (UCHAR*)&fchs->pl[0], (UCHAR*)&prli, sizeof(prli));
3658
3659 pLoggedInPort->fcp_info = prli.fcp_info; // target/initiator flags
3660 pLoggedInPort->prli = TRUE; // PLOGI resets, PDISC doesn't
3661
3662 pLoggedInPort->pdisc = TRUE; // expect to send (or receive) PDISC
3663 // next time
3664 pLoggedInPort->LOGO_timer = 0; // will be set next LinkDown
3665#ifdef WWN_DBG
3666 ulBuff = (ULONG)pLoggedInPort->u.liWWN;
3667 if( pLoggedInPort->Originator)
3668 printk("o");
3669 else
3670 printk("r");
3671 printk("PRLI port_id %Xh, WWN %08X",
3672 pLoggedInPort->port_id, ulBuff);
3673
3674 ulBuff = (ULONG)(pLoggedInPort->u.liWWN >> 32);
3675 printk("%08Xh\n", ulBuff);
3676#endif
3677
3678 break;
3679
3680 }
3681
3682 return;
3683}
3684
3685
3686
3687
3688
3689
3690static void BuildLinkServicePayload( PTACHYON fcChip, ULONG type, void* payload)
3691{
3692 LOGIN_PAYLOAD *plogi; // FC-PH Port Login
3693 LOGIN_PAYLOAD PlogiPayload; // copy for BIG ENDIAN switch
3694 PRLI_REQUEST *prli; // FCP-SCSI Process Login
3695 PRLI_REQUEST PrliPayload; // copy for BIG ENDIAN switch
3696 LOGOUT_PAYLOAD *logo;
3697 LOGOUT_PAYLOAD LogoutPayload;
3698// PRLO_REQUEST *prlo;
3699// PRLO_REQUEST PrloPayload;
3700 REJECT_MESSAGE rjt, *prjt;
3701
3702 memset( &PlogiPayload, 0, sizeof( PlogiPayload));
3703 plogi = &PlogiPayload; // load into stack buffer,
3704 // then BIG-ENDIAN switch a copy to caller
3705
3706
3707 switch( type ) // payload type can be ELS_PLOGI, ELS_PRLI, ADISC, ...
3708 {
3709 case ELS_FDISC:
3710 case ELS_FLOGI:
3711 case ELS_PLOGI_ACC: // FC-PH PORT Login Accept
3712 case ELS_PLOGI: // FC-PH PORT Login
3713 case ELS_PDISC: // FC-PH2 Port Discovery - same payload as ELS_PLOGI
3714 plogi->login_cmd = LS_PLOGI;
3715 if( type == ELS_PDISC)
3716 plogi->login_cmd = LS_PDISC;
3717 else if( type == ELS_PLOGI_ACC )
3718 plogi->login_cmd = LS_ACC;
3719
3720 plogi->cmn_services.bb_credit = 0x00;
3721 plogi->cmn_services.lowest_ver = fcChip->lowest_FCPH_ver;
3722 plogi->cmn_services.highest_ver = fcChip->highest_FCPH_ver;
3723 plogi->cmn_services.bb_rx_size = TACHLITE_TS_RX_SIZE;
3724 plogi->cmn_services.common_features = CONTINUOSLY_INCREASING |
3725 RANDOM_RELATIVE_OFFSET;
3726
3727 // fill in with World Wide Name based Port Name - 8 UCHARs
3728 // get from Tach registers WWN hi & lo
3729 LoadWWN( fcChip, plogi->port_name, 0);
3730 // fill in with World Wide Name based Node/Fabric Name - 8 UCHARs
3731 // get from Tach registers WWN hi & lo
3732 LoadWWN( fcChip, plogi->node_name, 1);
3733
3734 // For Seagate Drives.
3735 //
3736 plogi->cmn_services.common_features |= 0x800;
3737 plogi->cmn_services.rel_offset = 0xFE;
3738 plogi->cmn_services.concurrent_seq = 1;
3739 plogi->class1.service_options = 0x00;
3740 plogi->class2.service_options = 0x00;
3741 plogi->class3.service_options = CLASS_VALID;
3742 plogi->class3.initiator_control = 0x00;
3743 plogi->class3.rx_data_size = MAX_RX_PAYLOAD;
3744 plogi->class3.recipient_control =
3745 ERROR_DISCARD | ONE_CATEGORY_SEQUENCE;
3746 plogi->class3.concurrent_sequences = 1;
3747 plogi->class3.open_sequences = 1;
3748 plogi->vendor_id[0] = 'C'; plogi->vendor_id[1] = 'Q';
3749 plogi->vendor_version[0] = 'C'; plogi->vendor_version[1] = 'Q';
3750 plogi->vendor_version[2] = ' '; plogi->vendor_version[3] = '0';
3751 plogi->vendor_version[4] = '0'; plogi->vendor_version[5] = '0';
3752
3753
3754 // FLOGI specific fields... (see FC-FLA, Rev 2.7, Aug 1999, sec 5.1)
3755 if( (type == ELS_FLOGI) || (type == ELS_FDISC) )
3756 {
3757 if( type == ELS_FLOGI )
3758 plogi->login_cmd = LS_FLOGI;
3759 else
3760 plogi->login_cmd = LS_FDISC;
3761
3762 plogi->cmn_services.lowest_ver = 0x20;
3763 plogi->cmn_services.common_features = 0x0800;
3764 plogi->cmn_services.rel_offset = 0;
3765 plogi->cmn_services.concurrent_seq = 0;
3766
3767 plogi->class3.service_options = 0x8800;
3768 plogi->class3.rx_data_size = 0;
3769 plogi->class3.recipient_control = 0;
3770 plogi->class3.concurrent_sequences = 0;
3771 plogi->class3.open_sequences = 0;
3772 }
3773
3774 // copy back to caller's buff, w/ BIG ENDIAN swap
3775 BigEndianSwap( (UCHAR*)&PlogiPayload, payload, sizeof(PlogiPayload));
3776 break;
3777
3778
3779 case ELS_ACC: // generic Extended Link Service ACCept
3780 plogi->login_cmd = LS_ACC;
3781 // copy back to caller's buff, w/ BIG ENDIAN swap
3782 BigEndianSwap( (UCHAR*)&PlogiPayload, payload, 4);
3783 break;
3784
3785
3786
3787 case ELS_SCR: // Fabric State Change Registration
3788 {
3789 SCR_PL scr; // state change registration
3790
3791 memset( &scr, 0, sizeof(scr));
3792
3793 scr.command = LS_SCR; // 0x62000000
3794 // see FC-FLA, Rev 2.7, Table A.22 (pg 82)
3795 scr.function = 3; // 1 = Events detected by Fabric
3796 // 2 = N_Port detected registration
3797 // 3 = Full registration
3798
3799 // copy back to caller's buff, w/ BIG ENDIAN swap
3800 BigEndianSwap( (UCHAR*)&scr, payload, sizeof(SCR_PL));
3801 }
3802
3803 break;
3804
3805
3806 case FCS_NSR: // Fabric Name Service Request
3807 {
3808 NSR_PL nsr; // Name Server Req. payload
3809
3810 memset( &nsr, 0, sizeof(NSR_PL));
3811
3812 // see Brocade Fabric Programming Guide,
3813 // Rev 1.3, pg 4-44
3814 nsr.CT_Rev = 0x01000000;
3815 nsr.FCS_Type = 0xFC020000;
3816 nsr.Command_code = 0x01710000;
3817 nsr.FCP = 8;
3818
3819 // copy back to caller's buff, w/ BIG ENDIAN swap
3820 BigEndianSwap( (UCHAR*)&nsr, payload, sizeof(NSR_PL));
3821 }
3822
3823 break;
3824
3825
3826
3827
3828 case ELS_LOGO: // FC-PH PORT LogOut
3829 logo = &LogoutPayload; // load into stack buffer,
3830 // then BIG-ENDIAN switch a copy to caller
3831 logo->cmd = LS_LOGO;
3832 // load the 3 UCHARs of the node name
3833 // (if private loop, upper two UCHARs 0)
3834 logo->reserved = 0;
3835
3836 logo->n_port_identifier[0] = (UCHAR)(fcChip->Registers.my_al_pa);
3837 logo->n_port_identifier[1] =
3838 (UCHAR)(fcChip->Registers.my_al_pa>>8);
3839 logo->n_port_identifier[2] =
3840 (UCHAR)(fcChip->Registers.my_al_pa>>16);
3841 // fill in with World Wide Name based Port Name - 8 UCHARs
3842 // get from Tach registers WWN hi & lo
3843 LoadWWN( fcChip, logo->port_name, 0);
3844
3845 BigEndianSwap( (UCHAR*)&LogoutPayload,
3846 payload, sizeof(LogoutPayload) ); // 16 UCHAR struct
3847 break;
3848
3849
3850 case ELS_LOGO_ACC: // Logout Accept (FH-PH pg 149, table 74)
3851 logo = &LogoutPayload; // load into stack buffer,
3852 // then BIG-ENDIAN switch a copy to caller
3853 logo->cmd = LS_ACC;
3854 BigEndianSwap( (UCHAR*)&LogoutPayload, payload, 4 ); // 4 UCHAR cmnd
3855 break;
3856
3857
3858 case ELS_RJT: // ELS_RJT link service reject (FH-PH pg 155)
3859
3860 prjt = (REJECT_MESSAGE*)payload; // pick up passed data
3861 rjt.command_code = ELS_RJT;
3862 // reverse fields, because of Swap that follows...
3863 rjt.vendor = prjt->reserved; // vendor specific
3864 rjt.explain = prjt->reason; //
3865 rjt.reason = prjt->explain; //
3866 rjt.reserved = prjt->vendor; //
3867 // BIG-ENDIAN switch a copy to caller
3868 BigEndianSwap( (UCHAR*)&rjt, payload, 8 ); // 8 UCHAR cmnd
3869 break;
3870
3871
3872
3873
3874
3875 case ELS_PRLI_ACC: // Process Login ACCept
3876 case ELS_PRLI: // Process Login
3877 case ELS_PRLO: // Process Logout
3878 memset( &PrliPayload, 0, sizeof( PrliPayload));
3879 prli = &PrliPayload; // load into stack buffer,
3880
3881 if( type == ELS_PRLI )
3882 prli->cmd = 0x20; // Login
3883 else if( type == ELS_PRLO )
3884 prli->cmd = 0x21; // Logout
3885 else if( type == ELS_PRLI_ACC )
3886 {
3887 prli->cmd = 0x02; // Login ACCept
3888 prli->valid = REQUEST_EXECUTED;
3889 }
3890
3891
3892 prli->valid |= SCSI_FCP | ESTABLISH_PAIR;
3893 prli->fcp_info = READ_XFER_RDY;
3894 prli->page_length = 0x10;
3895 prli->payload_length = 20;
3896 // Can be initiator AND target
3897
3898 if( fcChip->Options.initiator )
3899 prli->fcp_info |= INITIATOR_FUNCTION;
3900 if( fcChip->Options.target )
3901 prli->fcp_info |= TARGET_FUNCTION;
3902
3903 BigEndianSwap( (UCHAR*)&PrliPayload, payload, prli->payload_length);
3904 break;
3905
3906
3907
3908 default: // no can do - programming error
3909 printk(" BuildLinkServicePayload unknown!\n");
3910 break;
3911 }
3912}
3913
3914// loads 8 UCHARs for PORT name or NODE name base on
3915// controller's WWN.
3916void LoadWWN( PTACHYON fcChip, UCHAR* dest, UCHAR type)
3917{
3918 UCHAR* bPtr, i;
3919
3920 switch( type )
3921 {
3922 case 0: // Port_Name
3923 bPtr = (UCHAR*)&fcChip->Registers.wwn_hi;
3924 for( i =0; i<4; i++)
3925 dest[i] = *bPtr++;
3926 bPtr = (UCHAR*)&fcChip->Registers.wwn_lo;
3927 for( i =4; i<8; i++)
3928 dest[i] = *bPtr++;
3929 break;
3930 case 1: // Node/Fabric _Name
3931 bPtr = (UCHAR*)&fcChip->Registers.wwn_hi;
3932 for( i =0; i<4; i++)
3933 dest[i] = *bPtr++;
3934 bPtr = (UCHAR*)&fcChip->Registers.wwn_lo;
3935 for( i =4; i<8; i++)
3936 dest[i] = *bPtr++;
3937 break;
3938 }
3939
3940}
3941
3942
3943
3944// We check the Port Login payload for required values. Note that
3945// ELS_PLOGI and ELS_PDISC (Port DISCover) use the same payload.
3946
3947
3948int verify_PLOGI( PTACHYON fcChip,
3949 TachFCHDR_GCMND* fchs,
3950 ULONG* reject_explain)
3951{
3952 LOGIN_PAYLOAD login;
3953
3954 // source, dest, len (should be mult. of 4)
3955 BigEndianSwap( (UCHAR*)&fchs->pl[0], (UCHAR*)&login, sizeof(login));
3956
3957 // check FC version
3958 // if other port's highest supported version
3959 // is less than our lowest, and
3960 // if other port's lowest
3961 if( login.cmn_services.highest_ver < fcChip->lowest_FCPH_ver ||
3962 login.cmn_services.lowest_ver > fcChip->highest_FCPH_ver )
3963 {
3964 *reject_explain = LS_RJT_REASON( LOGICAL_ERROR, OPTIONS_ERROR);
3965 return LOGICAL_ERROR;
3966 }
3967
3968 // Receive Data Field Size must be >=128
3969 // per FC-PH
3970 if (login.cmn_services.bb_rx_size < 128)
3971 {
3972 *reject_explain = LS_RJT_REASON( LOGICAL_ERROR, DATA_FIELD_SIZE_ERROR);
3973 return LOGICAL_ERROR;
3974 }
3975
3976 // Only check Class 3 params
3977 if( login.class3.service_options & CLASS_VALID)
3978 {
3979 if (login.class3.rx_data_size < 128)
3980 {
3981 *reject_explain = LS_RJT_REASON( LOGICAL_ERROR, INVALID_CSP);
3982 return LOGICAL_ERROR;
3983 }
3984 if( login.class3.initiator_control & XID_REQUIRED)
3985 {
3986 *reject_explain = LS_RJT_REASON( LOGICAL_ERROR, INITIATOR_CTL_ERROR);
3987 return LOGICAL_ERROR;
3988 }
3989 }
3990 return 0; // success
3991}
3992
3993
3994
3995
3996int verify_PRLI( TachFCHDR_GCMND* fchs, ULONG* reject_explain)
3997{
3998 PRLI_REQUEST prli; // buffer for BIG ENDIAN
3999
4000 // source, dest, len (should be mult. of 4)
4001 BigEndianSwap( (UCHAR*)&fchs->pl[0], (UCHAR*)&prli, sizeof(prli));
4002
4003 if( prli.fcp_info == 0 ) // i.e., not target or initiator?
4004 {
4005 *reject_explain = LS_RJT_REASON( LOGICAL_ERROR, OPTIONS_ERROR);
4006 return LOGICAL_ERROR;
4007 }
4008
4009 return 0; // success
4010}
4011
4012
4013// SWAP UCHARs as required by Fibre Channel (i.e. BIG ENDIAN)
4014// INPUTS:
4015// source - ptr to LITTLE ENDIAN ULONGS
4016// cnt - number of UCHARs to switch (should be mult. of ULONG)
4017// OUTPUTS:
4018// dest - ptr to BIG ENDIAN copy
4019// RETURN:
4020// none
4021//
4022void BigEndianSwap( UCHAR *source, UCHAR *dest, USHORT cnt)
4023{
4024 int i,j;
4025
4026 source+=3; // start at MSB of 1st ULONG
4027 for( j=0; j < cnt; j+=4, source+=4, dest+=4) // every ULONG
4028 {
4029 for( i=0; i<4; i++) // every UCHAR in ULONG
4030 *(dest+i) = *(source-i);
4031 }
4032}
4033
4034
4035
4036
4037// Build FC Exchanges............
4038
4039static void buildFCPstatus(
4040 PTACHYON fcChip,
4041 ULONG ExchangeID);
4042
4043static LONG FindFreeExchange( PTACHYON fcChip, ULONG type );
4044
4045static ULONG build_SEST_sgList(
4046 struct pci_dev *pcidev,
4047 ULONG *SESTalPairStart,
4048 Scsi_Cmnd *Cmnd,
4049 ULONG *sgPairs,
4050 PSGPAGES *sgPages_head // link list of TL Ext. S/G pages from O/S Pool
4051);
4052
4053static int build_FCP_payload( Scsi_Cmnd *Cmnd,
4054 UCHAR* payload, ULONG type, ULONG fcp_dl );
4055
4056
4057/*
4058 IRB
4059 ERQ __________________
4060 | | / | Req_A_SFS_Len | ____________________
4061 |----------| / | Req_A_SFS_Addr |------->| Reserved |
4062 | IRB | / | Req_A_D_ID | | SOF EOF TimeStamp |
4063 |-----------/ | Req_A_SEST_Index |-+ | R_CTL | D_ID |
4064 | IRB | | Req_B... | | | CS_CTL| S_ID |
4065 |-----------\ | | | | TYPE | F_CTL |
4066 | IRB | \ | | | | SEQ_ID | SEQ_CNT |
4067 |----------- \ | | +-->+--| OX_ID | RX_ID |
4068 | | \ |__________________| | | RO |
4069 | | pl (payload/cmnd) |
4070 | | ..... |
4071 | |___________________|
4072 |
4073 |
4074+-------------------------------------------+
4075|
4076|
4077| e.g. IWE
4078| SEST __________________ for FCP_DATA
4079| | | / | | Hdr_Len | ____________________
4080| |----------| / | Hdr_Addr_Addr |------->| Reserved |
4081| | [0] | / |Remote_ID| RSP_Len| | SOF EOF TimeStamp |
4082| |-----------/ | RSP_Addr |---+ | R_CTL | D_ID |
4083+-> [1] | | | Buff_Off | | | CS_CTL| S_ID |
4084 |-----------\ |BuffIndex| Link | | | TYPE | F_CTL |
4085 | [2] | \ | Rsvd | RX_ID | | | SEQ_ID | SEQ_CNT |
4086 |----------- \ | Data_Len | | | OX_ID | RX_ID |
4087 | ... | \ | Exp_RO | | | RO |
4088 |----------| | Exp_Byte_Cnt | | |___________________|
4089 | SEST_LEN | +--| Len | |
4090 |__________| | | Address | |
4091 | | ... | | for FCP_RSP
4092 | |__________________| | ____________________
4093 | +----| Reserved |
4094 | | SOF EOF TimeStamp |
4095 | | R_CTL | D_ID |
4096 | | CS_CTL| S_ID |
4097 +--- local or extended | .... |
4098 scatter/gather lists
4099 defining upper-layer
4100 data (e.g. from user's App)
4101
4102
4103*/
4104// All TachLite commands must start with a SFS (Single Frame Sequence)
4105// command. In the simplest case (a NOP Basic Link command),
4106// only one frame header and ERQ entry is required. The most complex
4107// case is the SCSI assisted command, which requires an ERQ entry,
4108// SEST entry, and several frame headers and data buffers all
4109// logically linked together.
4110// Inputs:
4111// cpqfcHBAdata - controller struct
4112// type - PLOGI, SCSI_IWE, etc.
4113// InFCHS - Incoming Tachlite FCHS which prompted this exchange
4114// (only s_id set if we are originating)
4115// Data - PVOID to data struct consistent with "type"
4116// fcExchangeIndex - pointer to OX/RD ID value of built exchange
4117// Return:
4118// fcExchangeIndex - OX/RD ID value if successful
4119// 0 - success
4120// INVALID_ARGS - NULL/ invalid passed args
4121// BAD_ALPA - Bad source al_pa address
4122// LNKDWN_OSLS - Link Down (according to this controller)
4123// OUTQUE_FULL - Outbound Que full
4124// DRIVERQ_FULL - controller's Exchange array full
4125// SEST_FULL - SEST table full
4126//
4127// Remarks:
4128// Psuedo code:
4129// Check for NULL pointers / bad args
4130// Build outgoing FCHS - the header/payload struct
4131// Build IRB (for ERQ entry)
4132// if SCSI command, build SEST entry (e.g. IWE, TRE,...)
4133// return success
4134
4135//sbuildex
4136ULONG cpqfcTSBuildExchange(
4137 CPQFCHBA *cpqfcHBAdata,
4138 ULONG type, // e.g. PLOGI
4139 TachFCHDR_GCMND* InFCHS, // incoming FCHS
4140 void *Data, // the CDB, scatter/gather, etc.
4141 LONG *fcExchangeIndex ) // points to allocated exchange,
4142{
4143 PTACHYON fcChip = &cpqfcHBAdata->fcChip;
4144 FC_EXCHANGES *Exchanges = fcChip->Exchanges;
4145 ULONG ulStatus = 0; // assume OK
4146 USHORT ox_ID, rx_ID=0xFFFF;
4147 ULONG SfsLen=0L;
4148 TachLiteIRB* pIRB;
4149 IRBflags IRB_flags;
4150 UCHAR *pIRB_flags = (UCHAR*)&IRB_flags;
4151 TachFCHDR_GCMND* CMDfchs;
4152 TachFCHDR* dataHDR; // 32 byte HEADER ONLY FCP-DATA buffer
4153 TachFCHDR_RSP* rspHDR; // 32 byte header + RSP payload
4154 Scsi_Cmnd *Cmnd = (Scsi_Cmnd*)Data; // Linux Scsi CDB, S/G, ...
4155 TachLiteIWE* pIWE;
4156 TachLiteIRE* pIRE;
4157 TachLiteTWE* pTWE;
4158 TachLiteTRE* pTRE;
4159 ULONG fcp_dl; // total byte length of DATA transferred
4160 ULONG fl; // frame length (FC frame size, 128, 256, 512, 1024)
4161 ULONG sgPairs; // number of valid scatter/gather pairs
4162 int FCP_SCSI_command;
4163 BA_ACC_PAYLOAD *ba_acc;
4164 BA_RJT_PAYLOAD *ba_rjt;
4165
4166 // check passed ARGS
4167 if( !fcChip->ERQ ) // NULL ptr means uninitialized Tachlite chip
4168 return INVALID_ARGS;
4169
4170
4171 if( type == SCSI_IRE ||
4172 type == SCSI_TRE ||
4173 type == SCSI_IWE ||
4174 type == SCSI_TWE)
4175 FCP_SCSI_command = 1;
4176
4177 else
4178 FCP_SCSI_command = 0;
4179
4180
4181 // for commands that pass payload data (e.g. SCSI write)
4182 // examine command struct - verify that the
4183 // length of s/g buffers is adequate for total payload
4184 // length (end of list is NULL address)
4185
4186 if( FCP_SCSI_command )
4187 {
4188 if( Data ) // must have data descriptor (S/G list -- at least
4189 // one address with at least 1 byte of data)
4190 {
4191 // something to do (later)?
4192 }
4193
4194 else
4195 return INVALID_ARGS; // invalid DATA ptr
4196 }
4197
4198
4199
4200 // we can build an Exchange for later Queuing (on the TL chip)
4201 // if an empty slot is available in the DevExt for this controller
4202 // look for available Exchange slot...
4203
4204 if( type != FCP_RESPONSE &&
4205 type != BLS_ABTS &&
4206 type != BLS_ABTS_ACC ) // already have Exchange slot!
4207 *fcExchangeIndex = FindFreeExchange( fcChip, type );
4208
4209 if( *fcExchangeIndex != -1 ) // Exchange is available?
4210 {
4211 // assign tmp ptr (shorthand)
4212 CMDfchs = &Exchanges->fcExchange[ *fcExchangeIndex].fchs;
4213
4214 if( Cmnd != NULL ) // (necessary for ABTS cases)
4215 {
4216 Exchanges->fcExchange[ *fcExchangeIndex].Cmnd = Cmnd; // Linux Scsi
4217 Exchanges->fcExchange[ *fcExchangeIndex].pLoggedInPort =
4218 fcFindLoggedInPort( fcChip,
4219 Exchanges->fcExchange[ *fcExchangeIndex].Cmnd, // find Scsi Nexus
4220 0, // DON'T search linked list for FC port id
4221 NULL, // DON'T search linked list for FC WWN
4222 NULL); // DON'T care about end of list
4223
4224 }
4225
4226
4227 // Build the command frame header (& data) according
4228 // to command type
4229
4230 // fields common for all SFS frame types
4231 CMDfchs->reserved = 0L; // must clear
4232 CMDfchs->sof_eof = 0x75000000L; // SOFi3:EOFn no UAM; LCr=0, no TS
4233
4234 // get the destination port_id from incoming FCHS
4235 // (initialized before calling if we're Originator)
4236 // Frame goes to port it was from - the source_id
4237
4238 CMDfchs->d_id = InFCHS->s_id &0xFFFFFF; // destination (add R_CTL later)
4239 CMDfchs->s_id = fcChip->Registers.my_al_pa; // CS_CTL = 0
4240
4241
4242 // now enter command-specific fields
4243 switch( type )
4244 {
4245
4246 case BLS_NOP: // FC defined basic link service command NO-OP
4247 // ensure unique X_IDs! (use tracking function)
4248
4249 *pIRB_flags = 0; // clear IRB flags
4250 IRB_flags.SFA = 1; // send SFS (not SEST index)
4251 SfsLen = *pIRB_flags;
4252
4253 SfsLen <<= 24; // shift flags to MSB
4254 SfsLen += 32L; // add len to LSB (header only - no payload)
4255
4256 // TYPE[31-24] 00 Basic Link Service
4257 // f_ctl[23:0] exchg originator, 1st seq, xfer S.I.
4258 CMDfchs->d_id |= 0x80000000L; // R_CTL = 80 for NOP (Basic Link Ser.)
4259 CMDfchs->f_ctl = 0x00310000L; // xchng originator, 1st seq,....
4260 CMDfchs->seq_cnt = 0x0L;
4261 CMDfchs->ox_rx_id = 0xFFFF; // RX_ID for now; OX_ID on start
4262 CMDfchs->ro = 0x0L; // relative offset (n/a)
4263 CMDfchs->pl[0] = 0xaabbccddL; // words 8-15 frame data payload (n/a)
4264 Exchanges->fcExchange[ *fcExchangeIndex].timeOut = 1; // seconds
4265 // (NOP should complete ~instantly)
4266 break;
4267
4268
4269
4270
4271 case BLS_ABTS_ACC: // Abort Sequence ACCept
4272 *pIRB_flags = 0; // clear IRB flags
4273 IRB_flags.SFA = 1; // send SFS (not SEST index)
4274 SfsLen = *pIRB_flags;
4275
4276 SfsLen <<= 24; // shift flags to MSB
4277 SfsLen += 32 + 12; // add len to LSB (header + 3 DWORD payload)
4278
4279 CMDfchs->d_id |= 0x84000000L; // R_CTL = 84 for BASIC ACCept
4280 // TYPE[31-24] 00 Basic Link Service
4281 // f_ctl[23:0] exchg originator, not 1st seq, xfer S.I.
4282 CMDfchs->f_ctl = 0x00910000L; // xchnge responder, last seq, xfer SI
4283 // CMDfchs->seq_id & count might be set from DataHdr?
4284 CMDfchs->ro = 0x0L; // relative offset (n/a)
4285 Exchanges->fcExchange[ *fcExchangeIndex].timeOut = 5; // seconds
4286 // (Timeout in case of weird error)
4287
4288 // now set the ACCept payload...
4289 ba_acc = (BA_ACC_PAYLOAD*)&CMDfchs->pl[0];
4290 memset( ba_acc, 0, sizeof( BA_ACC_PAYLOAD));
4291 // Since PLDA requires (only) entire Exchange aborts, we don't need
4292 // to worry about what the last sequence was.
4293
4294 // We expect that a "target" task is accepting the abort, so we
4295 // can use the OX/RX ID pair
4296 ba_acc->ox_rx_id = CMDfchs->ox_rx_id;
4297
4298 // source, dest, #bytes
4299 BigEndianSwap((UCHAR *)&CMDfchs->ox_rx_id, (UCHAR *)&ba_acc->ox_rx_id, 4);
4300
4301 ba_acc->low_seq_cnt = 0;
4302 ba_acc->high_seq_cnt = 0xFFFF;
4303
4304
4305 break;
4306
4307
4308 case BLS_ABTS_RJT: // Abort Sequence ACCept
4309 *pIRB_flags = 0; // clear IRB flags
4310 IRB_flags.SFA = 1; // send SFS (not SEST index)
4311 SfsLen = *pIRB_flags;
4312
4313 SfsLen <<= 24; // shift flags to MSB
4314 SfsLen += 32 + 12; // add len to LSB (header + 3 DWORD payload)
4315
4316 CMDfchs->d_id |= 0x85000000L; // R_CTL = 85 for BASIC ReJecT
4317 // f_ctl[23:0] exchg originator, not 1st seq, xfer S.I.
4318 // TYPE[31-24] 00 Basic Link Service
4319 CMDfchs->f_ctl = 0x00910000L; // xchnge responder, last seq, xfer SI
4320 // CMDfchs->seq_id & count might be set from DataHdr?
4321 CMDfchs->ro = 0x0L; // relative offset (n/a)
4322 Exchanges->fcExchange[ *fcExchangeIndex].timeOut = 5; // seconds
4323 // (Timeout in case of weird error)
4324
4325 CMDfchs->ox_rx_id = InFCHS->ox_rx_id; // copy from sender!
4326
4327 // now set the ReJecT payload...
4328 ba_rjt = (BA_RJT_PAYLOAD*)&CMDfchs->pl[0];
4329 memset( ba_rjt, 0, sizeof( BA_RJT_PAYLOAD));
4330
4331 // We expect that a "target" task couldn't find the Exhange in the
4332 // array of active exchanges, so we use a new LinkService X_ID.
4333 // See Reject payload description in FC-PH (Rev 4.3), pg. 140
4334 ba_rjt->reason_code = 0x09; // "unable to perform command request"
4335 ba_rjt->reason_explain = 0x03; // invalid OX/RX ID pair
4336
4337
4338 break;
4339
4340
4341 case BLS_ABTS: // FC defined basic link service command ABTS
4342 // Abort Sequence
4343
4344
4345 *pIRB_flags = 0; // clear IRB flags
4346 IRB_flags.SFA = 1; // send SFS (not SEST index)
4347 SfsLen = *pIRB_flags;
4348
4349 SfsLen <<= 24; // shift flags to MSB
4350 SfsLen += 32L; // add len to LSB (header only - no payload)
4351
4352 // TYPE[31-24] 00 Basic Link Service
4353 // f_ctl[23:0] exchg originator, not 1st seq, xfer S.I.
4354 CMDfchs->d_id |= 0x81000000L; // R_CTL = 81 for ABTS
4355 CMDfchs->f_ctl = 0x00110000L; // xchnge originator, last seq, xfer SI
4356 // CMDfchs->seq_id & count might be set from DataHdr?
4357 CMDfchs->ro = 0x0L; // relative offset (n/a)
4358 Exchanges->fcExchange[ *fcExchangeIndex].timeOut = 2; // seconds
4359 // (ABTS must timeout when responder is gone)
4360 break;
4361
4362
4363
4364 case FCS_NSR: // Fabric Name Service Request
4365 Exchanges->fcExchange[ *fcExchangeIndex].reTries = 2;
4366
4367
4368 Exchanges->fcExchange[ *fcExchangeIndex].timeOut = 2; // seconds
4369 // OX_ID, linked to Driver Transaction ID
4370 // (fix-up at Queing time)
4371 CMDfchs->ox_rx_id = 0xFFFF; // RX_ID - Responder (target) to modify
4372 // OX_ID set at ERQueing time
4373 *pIRB_flags = 0; // clear IRB flags
4374 IRB_flags.SFA = 1; // send SFS (not SEST index)
4375 SfsLen = *pIRB_flags;
4376
4377 SfsLen <<= 24; // shift flags to MSB
4378 SfsLen += (32L + sizeof(NSR_PL)); // add len (header & NSR payload)
4379
4380 CMDfchs->d_id |= 0x02000000L; // R_CTL = 02 for -
4381 // Name Service Request: Unsolicited
4382 // TYPE[31-24] 01 Extended Link Service
4383 // f_ctl[23:0] exchg originator, 1st seq, xfer S.I.
4384 CMDfchs->f_ctl = 0x20210000L;
4385 // OX_ID will be fixed-up at Tachyon enqueing time
4386 CMDfchs->seq_cnt = 0; // seq ID, DF_ctl, seq cnt
4387 CMDfchs->ro = 0x0L; // relative offset (n/a)
4388
4389 BuildLinkServicePayload( fcChip, type, &CMDfchs->pl[0]);
4390
4391
4392
4393
4394
4395
4396 break;
4397
4398
4399
4400
4401 case ELS_PLOGI: // FC-PH extended link service command Port Login
4402 // (May, 2000)
4403 // NOTE! This special case facilitates SANMark testing. The SANMark
4404 // test script for initialization-timeout.fcal.SANMark-1.fc
4405 // "eats" the OPN() primitive without issuing an R_RDY, causing
4406 // Tachyon to report LST (loop state timeout), which causes a
4407 // LIP. To avoid this, simply send out the frame (i.e. assuming a
4408 // buffer credit of 1) without waiting for R_RDY. Many FC devices
4409 // (other than Tachyon) have been doing this for years. We don't
4410 // ever want to do this for non-Link Service frames unless the
4411 // other device really did report non-zero login BB credit (i.e.
4412 // in the PLOGI ACCept frame).
4413// CMDfchs->sof_eof |= 0x00000400L; // LCr=1
4414
4415 case ELS_FDISC: // Fabric Discovery (Login)
4416 case ELS_FLOGI: // Fabric Login
4417 case ELS_SCR: // Fabric State Change Registration
4418 case ELS_LOGO: // FC-PH extended link service command Port Logout
4419 case ELS_PDISC: // FC-PH extended link service cmnd Port Discovery
4420 case ELS_PRLI: // FC-PH extended link service cmnd Process Login
4421
4422 Exchanges->fcExchange[ *fcExchangeIndex].reTries = 2;
4423
4424
4425 Exchanges->fcExchange[ *fcExchangeIndex].timeOut = 2; // seconds
4426 // OX_ID, linked to Driver Transaction ID
4427 // (fix-up at Queing time)
4428 CMDfchs->ox_rx_id = 0xFFFF; // RX_ID - Responder (target) to modify
4429 // OX_ID set at ERQueing time
4430 *pIRB_flags = 0; // clear IRB flags
4431 IRB_flags.SFA = 1; // send SFS (not SEST index)
4432 SfsLen = *pIRB_flags;
4433
4434 SfsLen <<= 24; // shift flags to MSB
4435 if( type == ELS_LOGO )
4436 SfsLen += (32L + 16L); // add len (header & PLOGI payload)
4437 else if( type == ELS_PRLI )
4438 SfsLen += (32L + 20L); // add len (header & PRLI payload)
4439 else if( type == ELS_SCR )
4440 SfsLen += (32L + sizeof(SCR_PL)); // add len (header & SCR payload)
4441 else
4442 SfsLen += (32L + 116L); // add len (header & PLOGI payload)
4443
4444 CMDfchs->d_id |= 0x22000000L; // R_CTL = 22 for -
4445 // Extended Link_Data: Unsolicited Control
4446 // TYPE[31-24] 01 Extended Link Service
4447 // f_ctl[23:0] exchg originator, 1st seq, xfer S.I.
4448 CMDfchs->f_ctl = 0x01210000L;
4449 // OX_ID will be fixed-up at Tachyon enqueing time
4450 CMDfchs->seq_cnt = 0; // seq ID, DF_ctl, seq cnt
4451 CMDfchs->ro = 0x0L; // relative offset (n/a)
4452
4453 BuildLinkServicePayload( fcChip, type, &CMDfchs->pl[0]);
4454
4455 break;
4456
4457
4458
4459 case ELS_LOGO_ACC: // FC-PH extended link service logout accept
4460 case ELS_RJT: // extended link service reject (add reason)
4461 case ELS_ACC: // ext. link service generic accept
4462 case ELS_PLOGI_ACC:// ext. link service login accept (PLOGI or PDISC)
4463 case ELS_PRLI_ACC: // ext. link service process login accept
4464
4465
4466 Exchanges->fcExchange[ *fcExchangeIndex].timeOut = 1; // assume done
4467 // ensure unique X_IDs! (use tracking function)
4468 // OX_ID from initiator cmd
4469 ox_ID = (USHORT)(InFCHS->ox_rx_id >> 16);
4470 rx_ID = 0xFFFF; // RX_ID, linked to Driver Exchange ID
4471
4472 *pIRB_flags = 0; // clear IRB flags
4473 IRB_flags.SFA = 1; // send SFS (not SEST index)
4474 SfsLen = *pIRB_flags;
4475
4476 SfsLen <<= 24; // shift flags to MSB
4477 if( type == ELS_RJT )
4478 {
4479 SfsLen += (32L + 8L); // add len (header + payload)
4480
4481 // ELS_RJT reason codes (utilize unused "reserved" field)
4482 CMDfchs->pl[0] = 1;
4483 CMDfchs->pl[1] = InFCHS->reserved;
4484
4485 }
4486 else if( (type == ELS_LOGO_ACC) || (type == ELS_ACC) )
4487 SfsLen += (32L + 4L); // add len (header + payload)
4488 else if( type == ELS_PLOGI_ACC )
4489 SfsLen += (32L + 116L); // add len (header + payload)
4490 else if( type == ELS_PRLI_ACC )
4491 SfsLen += (32L + 20L); // add len (header + payload)
4492
4493 CMDfchs->d_id |= 0x23000000L; // R_CTL = 23 for -
4494 // Extended Link_Data: Control Reply
4495 // TYPE[31-24] 01 Extended Link Service
4496 // f_ctl[23:0] exchg responder, last seq, e_s, tsi
4497 CMDfchs->f_ctl = 0x01990000L;
4498 CMDfchs->seq_cnt = 0x0L;
4499 CMDfchs->ox_rx_id = 0L; // clear
4500 CMDfchs->ox_rx_id = ox_ID; // load upper 16 bits
4501 CMDfchs->ox_rx_id <<= 16; // shift them
4502
4503 CMDfchs->ro = 0x0L; // relative offset (n/a)
4504
4505 BuildLinkServicePayload( fcChip, type, &CMDfchs->pl[0]);
4506
4507 break;
4508
4509
4510 // Fibre Channel SCSI 'originator' sequences...
4511 // (originator means 'initiator' in FCP-SCSI)
4512
4513 case SCSI_IWE: // TachLite Initiator Write Entry
4514 {
4515 PFC_LOGGEDIN_PORT pLoggedInPort =
4516 Exchanges->fcExchange[ *fcExchangeIndex].pLoggedInPort;
4517
4518 Exchanges->fcExchange[ *fcExchangeIndex].reTries = 1;
4519 Exchanges->fcExchange[ *fcExchangeIndex].timeOut = 7; // FC2 timeout
4520
4521 // first, build FCP_CMND
4522 // unique X_ID fix-ups in StartExchange
4523
4524 *pIRB_flags = 0; // clear IRB flags
4525 IRB_flags.SFA = 1; // send SFS FCP-CMND (not SEST index)
4526
4527 // NOTE: unlike FC LinkService login frames, normal
4528 // SCSI commands are sent without outgoing verification
4529 IRB_flags.DCM = 1; // Disable completion message for Cmnd frame
4530 SfsLen = *pIRB_flags;
4531
4532 SfsLen <<= 24; // shift flags to MSB
4533 SfsLen += 64L; // add len to LSB (header & CMND payload)
4534
4535 CMDfchs->d_id |= (0x06000000L); // R_CTL = 6 for command
4536
4537 // TYPE[31-24] 8 for FCP SCSI
4538 // f_ctl[23:0] exchg originator, 1st seq, xfer S.I.
4539 // valid RO
4540 CMDfchs->f_ctl = 0x08210008L;
4541 CMDfchs->seq_cnt = 0x0L;
4542 CMDfchs->ox_rx_id = 0L; // clear for now (-or- in later)
4543 CMDfchs->ro = 0x0L; // relative offset (n/a)
4544
4545 // now, fill out FCP-DATA header
4546 // (use buffer inside SEST object)
4547 dataHDR = &fcChip->SEST->DataHDR[ *fcExchangeIndex ];
4548 dataHDR->reserved = 0L; // must clear
4549 dataHDR->sof_eof = 0x75002000L; // SOFi3:EOFn no UAM; no CLS, noLCr, no TS
4550 dataHDR->d_id = (InFCHS->s_id | 0x01000000L); // R_CTL= FCP_DATA
4551 dataHDR->s_id = fcChip->Registers.my_al_pa; // CS_CTL = 0
4552 // TYPE[31-24] 8 for FCP SCSI
4553 // f_ctl[23:0] xfer S.I.| valid RO
4554 dataHDR->f_ctl = 0x08010008L;
4555 dataHDR->seq_cnt = 0x02000000L; // sequence ID: df_ctl : seqence count
4556 dataHDR->ox_rx_id = 0L; // clear; fix-up dataHDR fields later
4557 dataHDR->ro = 0x0L; // relative offset (n/a)
4558
4559 // Now setup the SEST entry
4560 pIWE = &fcChip->SEST->u[ *fcExchangeIndex ].IWE;
4561
4562 // fill out the IWE:
4563
4564 // VALid entry:Dir outbound:DCM:enable CM:enal INT: FC frame len
4565 pIWE->Hdr_Len = 0x8e000020L; // data frame Len always 32 bytes
4566
4567
4568 // from login parameters with other port, what's the largest frame
4569 // we can send?
4570 if( pLoggedInPort == NULL)
4571 {
4572 ulStatus = INVALID_ARGS; // failed! give up
4573 break;
4574 }
4575 if( pLoggedInPort->rx_data_size >= 2048)
4576 fl = 0x00020000; // 2048 code (only support 1024!)
4577 else if( pLoggedInPort->rx_data_size >= 1024)
4578 fl = 0x00020000; // 1024 code
4579 else if( pLoggedInPort->rx_data_size >= 512)
4580 fl = 0x00010000; // 512 code
4581 else
4582 fl = 0; // 128 bytes -- should never happen
4583
4584
4585 pIWE->Hdr_Len |= fl; // add xmit FC frame len for data phase
4586 pIWE->Hdr_Addr = fcChip->SEST->base +
4587 ((unsigned long)&fcChip->SEST->DataHDR[*fcExchangeIndex] -
4588 (unsigned long)fcChip->SEST);
4589
4590 pIWE->RSP_Len = sizeof(TachFCHDR_RSP) ; // hdr+data (recv'd RSP frame)
4591 pIWE->RSP_Len |= (InFCHS->s_id << 8); // MS 24 bits Remote_ID
4592
4593 memset( &fcChip->SEST->RspHDR[ *fcExchangeIndex].pl, 0,
4594 sizeof( FCP_STATUS_RESPONSE) ); // clear out previous status
4595
4596 pIWE->RSP_Addr = fcChip->SEST->base +
4597 ((unsigned long)&fcChip->SEST->RspHDR[*fcExchangeIndex] -
4598 (unsigned long)fcChip->SEST);
4599
4600 // Do we need local or extended gather list?
4601 // depends on size - we can handle 3 len/addr pairs
4602 // locally.
4603
4604 fcp_dl = build_SEST_sgList(
4605 cpqfcHBAdata->PciDev,
4606 &pIWE->GLen1,
4607 Cmnd, // S/G list
4608 &sgPairs, // return # of pairs in S/G list (from "Data" descriptor)
4609 &fcChip->SEST->sgPages[ *fcExchangeIndex ]);// (for Freeing later)
4610
4611 if( !fcp_dl ) // error building S/G list?
4612 {
4613 ulStatus = MEMPOOL_FAIL;
4614 break; // give up
4615 }
4616
4617 // Now that we know total data length in
4618 // the passed S/G buffer, set FCP CMND frame
4619 build_FCP_payload( Cmnd, (UCHAR*)&CMDfchs->pl[0], type, fcp_dl );
4620
4621
4622
4623 if( sgPairs > 3 ) // need extended s/g list
4624 pIWE->Buff_Off = 0x78000000L; // extended data | (no offset)
4625 else // local data pointers (in SEST)
4626 pIWE->Buff_Off = 0xf8000000L; // local data | (no offset)
4627
4628 // ULONG 5
4629 pIWE->Link = 0x0000ffffL; // Buff_Index | Link
4630
4631 pIWE->RX_ID = 0x0L; // DWord 6: RX_ID set by target XFER_RDY
4632
4633 // DWord 7
4634 pIWE->Data_Len = 0L; // TL enters rcv'd XFER_RDY BURST_LEN
4635 pIWE->Exp_RO = 0L; // DWord 8
4636 // DWord 9
4637 pIWE->Exp_Byte_Cnt = fcp_dl; // sum of gather buffers
4638 }
4639 break;
4640
4641
4642
4643
4644
4645 case SCSI_IRE: // TachLite Initiator Read Entry
4646
4647 if( Cmnd->timeout != 0)
4648 {
4649// printk("Cmnd->timeout %d\n", Cmnd->timeout);
4650 // per Linux Scsi
4651 Exchanges->fcExchange[ *fcExchangeIndex].timeOut = Cmnd->timeout;
4652 }
4653 else // use our best guess, based on FC & device
4654 {
4655
4656 if( Cmnd->SCp.Message == 1 ) // Tape device? (from INQUIRY)
4657 {
4658 // turn off our timeouts (for now...)
4659 Exchanges->fcExchange[ *fcExchangeIndex].timeOut = 0xFFFFFFFF;
4660 }
4661 else
4662 {
4663 Exchanges->fcExchange[ *fcExchangeIndex].reTries = 1;
4664 Exchanges->fcExchange[ *fcExchangeIndex].timeOut = 7; // per SCSI req.
4665 }
4666 }
4667
4668
4669 // first, build FCP_CMND
4670
4671
4672 *pIRB_flags = 0; // clear IRB flags
4673 IRB_flags.SFA = 1; // send SFS FCP-CMND (not SEST index)
4674 // NOTE: unlike FC LinkService login frames,
4675 // normal SCSI commands are sent "open loop"
4676 IRB_flags.DCM = 1; // Disable completion message for Cmnd frame
4677 SfsLen = *pIRB_flags;
4678
4679 SfsLen <<= 24; // shift flags to MSB
4680 SfsLen += 64L; // add len to LSB (header & CMND payload)
4681
4682 CMDfchs->d_id |= (0x06000000L); // R_CTL = 6 for command
4683
4684 // TYPE[31-24] 8 for FCP SCSI
4685 // f_ctl[23:0] exchg originator, 1st seq, xfer S.I.
4686 // valid RO
4687 CMDfchs->f_ctl = 0x08210008L;
4688 CMDfchs->seq_cnt = 0x0L;
4689 // x_ID & data direction bit set later
4690 CMDfchs->ox_rx_id = 0xFFFF; // clear
4691 CMDfchs->ro = 0x0L; // relative offset (n/a)
4692
4693
4694
4695 // Now setup the SEST entry
4696 pIRE = &fcChip->SEST->u[ *fcExchangeIndex ].IRE;
4697
4698 // fill out the IRE:
4699 // VALid entry:Dir outbound:enable CM:enal INT:
4700 pIRE->Seq_Accum = 0xCE000000L; // VAL,DIR inbound,DCM| INI,DAT,RSP
4701
4702 pIRE->reserved = 0L;
4703 pIRE->RSP_Len = sizeof(TachFCHDR_RSP) ; // hdr+data (recv'd RSP frame)
4704 pIRE->RSP_Len |= (InFCHS->s_id << 8); // MS 24 bits Remote_ID
4705
4706 pIRE->RSP_Addr = fcChip->SEST->base +
4707 ((unsigned long)&fcChip->SEST->RspHDR[*fcExchangeIndex] -
4708 (unsigned long)fcChip->SEST);
4709
4710 // Do we need local or extended gather list?
4711 // depends on size - we can handle 3 len/addr pairs
4712 // locally.
4713
4714 fcp_dl = build_SEST_sgList(
4715 cpqfcHBAdata->PciDev,
4716 &pIRE->SLen1,
4717 Cmnd, // SCSI command Data desc. with S/G list
4718 &sgPairs, // return # of pairs in S/G list (from "Data" descriptor)
4719 &fcChip->SEST->sgPages[ *fcExchangeIndex ]);// (for Freeing later)
4720
4721
4722 if( !fcp_dl ) // error building S/G list?
4723 {
4724 // It is permissible to have a ZERO LENGTH Read command.
4725 // If there is the case, simply set fcp_dl (and Exp_Byte_Cnt)
4726 // to 0 and continue.
4727 if( Cmnd->request_bufflen == 0 )
4728 {
4729 fcp_dl = 0; // no FC DATA frames expected
4730
4731 }
4732 else
4733 {
4734 ulStatus = MEMPOOL_FAIL;
4735 break; // give up
4736 }
4737 }
4738
4739 // now that we know the S/G length, build CMND payload
4740 build_FCP_payload( Cmnd, (UCHAR*)&CMDfchs->pl[0], type, fcp_dl );
4741
4742
4743 if( sgPairs > 3 ) // need extended s/g list
4744 pIRE->Buff_Off = 0x00000000; // DWord 4: extended s/g list, no offset
4745 else
4746 pIRE->Buff_Off = 0x80000000; // local data, no offset
4747
4748 pIRE->Buff_Index = 0x0L; // DWord 5: Buff_Index | Reserved
4749
4750 pIRE->Exp_RO = 0x0L; // DWord 6: Expected Rel. Offset
4751
4752 pIRE->Byte_Count = 0; // DWord 7: filled in by TL on err
4753 pIRE->reserved_ = 0; // DWord 8: reserved
4754 // NOTE: 0 length READ is OK.
4755 pIRE->Exp_Byte_Cnt = fcp_dl;// DWord 9: sum of scatter buffers
4756
4757 break;
4758
4759
4760
4761
4762 // Fibre Channel SCSI 'responder' sequences...
4763 // (originator means 'target' in FCP-SCSI)
4764 case SCSI_TWE: // TachLite Target Write Entry
4765
4766 Exchanges->fcExchange[ *fcExchangeIndex].timeOut = 10; // per SCSI req.
4767
4768 // first, build FCP_CMND
4769
4770 *pIRB_flags = 0; // clear IRB flags
4771 IRB_flags.SFA = 1; // send SFS (XFER_RDY)
4772 SfsLen = *pIRB_flags;
4773
4774 SfsLen <<= 24; // shift flags to MSB
4775 SfsLen += (32L + 12L);// add SFS len (header & XFER_RDY payload)
4776
4777 CMDfchs->d_id |= (0x05000000L); // R_CTL = 5 for XFER_RDY
4778
4779 // TYPE[31-24] 8 for FCP SCSI
4780 // f_ctl[23:0] exchg responder, 1st seq, xfer S.I.
4781 // valid RO
4782 CMDfchs->f_ctl = 0x08810008L;
4783 CMDfchs->seq_cnt = 0x01000000; // sequence ID: df_ctl: sequence count
4784 // use originator (other port's) OX_ID
4785 CMDfchs->ox_rx_id = InFCHS->ox_rx_id; // we want upper 16 bits
4786 CMDfchs->ro = 0x0L; // relative offset (n/a)
4787
4788 // now, fill out FCP-RSP header
4789 // (use buffer inside SEST object)
4790
4791 rspHDR = &fcChip->SEST->RspHDR[ *fcExchangeIndex ];
4792 rspHDR->reserved = 0L; // must clear
4793 rspHDR->sof_eof = 0x75000000L; // SOFi3:EOFn no UAM; no CLS, noLCr, no TS
4794 rspHDR->d_id = (InFCHS->s_id | 0x07000000L); // R_CTL= FCP_RSP
4795 rspHDR->s_id = fcChip->Registers.my_al_pa; // CS_CTL = 0
4796 // TYPE[31-24] 8 for FCP SCSI
4797 // f_ctl[23:0] responder|last seq| xfer S.I.
4798 rspHDR->f_ctl = 0x08910000L;
4799 rspHDR->seq_cnt = 0x03000000; // sequence ID
4800 rspHDR->ox_rx_id = InFCHS->ox_rx_id; // gives us OX_ID
4801 rspHDR->ro = 0x0L; // relative offset (n/a)
4802
4803
4804 // Now setup the SEST entry
4805
4806 pTWE = &fcChip->SEST->u[ *fcExchangeIndex ].TWE;
4807
4808 // fill out the TWE:
4809
4810 // VALid entry:Dir outbound:enable CM:enal INT:
4811 pTWE->Seq_Accum = 0xC4000000L; // upper word flags
4812 pTWE->reserved = 0L;
4813 pTWE->Remote_Node_ID = 0L; // no more auto RSP frame! (TL/TS change)
4814 pTWE->Remote_Node_ID |= (InFCHS->s_id << 8); // MS 24 bits Remote_ID
4815
4816
4817 // Do we need local or extended gather list?
4818 // depends on size - we can handle 3 len/addr pairs
4819 // locally.
4820
4821 fcp_dl = build_SEST_sgList(
4822 cpqfcHBAdata->PciDev,
4823 &pTWE->SLen1,
4824 Cmnd, // S/G list
4825 &sgPairs, // return # of pairs in S/G list (from "Data" descriptor)
4826 &fcChip->SEST->sgPages[ *fcExchangeIndex ]);// (for Freeing later)
4827
4828
4829 if( !fcp_dl ) // error building S/G list?
4830 {
4831 ulStatus = MEMPOOL_FAIL;
4832 break; // give up
4833 }
4834
4835 // now that we know the S/G length, build CMND payload
4836 build_FCP_payload( Cmnd, (UCHAR*)&CMDfchs->pl[0], type, fcp_dl );
4837
4838
4839 if( sgPairs > 3 ) // need extended s/g list
4840 pTWE->Buff_Off = 0x00000000; // extended s/g list, no offset
4841 else
4842 pTWE->Buff_Off = 0x80000000; // local data, no offset
4843
4844 pTWE->Buff_Index = 0; // Buff_Index | Link
4845 pTWE->Exp_RO = 0;
4846 pTWE->Byte_Count = 0; // filled in by TL on err
4847 pTWE->reserved_ = 0;
4848 pTWE->Exp_Byte_Cnt = fcp_dl;// sum of scatter buffers
4849
4850 break;
4851
4852
4853
4854
4855
4856
4857 case SCSI_TRE: // TachLite Target Read Entry
4858
4859 // It doesn't make much sense for us to "time-out" a READ,
4860 // but we'll use it for design consistency and internal error recovery.
4861 Exchanges->fcExchange[ *fcExchangeIndex].timeOut = 10; // per SCSI req.
4862
4863 // I/O request block settings...
4864 *pIRB_flags = 0; // clear IRB flags
4865 // check PRLI (process login) info
4866 // to see if Initiator Requires XFER_RDY
4867 // if not, don't send one!
4868 // { PRLI check...}
4869 IRB_flags.SFA = 0; // don't send XFER_RDY - start data
4870 SfsLen = *pIRB_flags;
4871
4872 SfsLen <<= 24; // shift flags to MSB
4873 SfsLen += (32L + 12L);// add SFS len (header & XFER_RDY payload)
4874
4875
4876
4877 // now, fill out FCP-DATA header
4878 // (use buffer inside SEST object)
4879 dataHDR = &fcChip->SEST->DataHDR[ *fcExchangeIndex ];
4880
4881 dataHDR->reserved = 0L; // must clear
4882 dataHDR->sof_eof = 0x75000000L; // SOFi3:EOFn no UAM; no CLS,noLCr,no TS
4883 dataHDR->d_id = (InFCHS->s_id | 0x01000000L); // R_CTL= FCP_DATA
4884 dataHDR->s_id = fcChip->Registers.my_al_pa; // CS_CTL = 0
4885
4886
4887 // TYPE[31-24] 8 for FCP SCSI
4888 // f_ctl[23:0] exchg responder, not 1st seq, xfer S.I.
4889 // valid RO
4890 dataHDR->f_ctl = 0x08810008L;
4891 dataHDR->seq_cnt = 0x01000000; // sequence ID (no XRDY)
4892 dataHDR->ox_rx_id = InFCHS->ox_rx_id & 0xFFFF0000; // we want upper 16 bits
4893 dataHDR->ro = 0x0L; // relative offset (n/a)
4894
4895 // now, fill out FCP-RSP header
4896 // (use buffer inside SEST object)
4897 rspHDR = &fcChip->SEST->RspHDR[ *fcExchangeIndex ];
4898
4899 rspHDR->reserved = 0L; // must clear
4900 rspHDR->sof_eof = 0x75000000L; // SOFi3:EOFn no UAM; no CLS, noLCr, no TS
4901 rspHDR->d_id = (InFCHS->s_id | 0x07000000L); // R_CTL= FCP_RSP
4902 rspHDR->s_id = fcChip->Registers.my_al_pa; // CS_CTL = 0
4903 // TYPE[31-24] 8 for FCP SCSI
4904 // f_ctl[23:0] responder|last seq| xfer S.I.
4905 rspHDR->f_ctl = 0x08910000L;
4906 rspHDR->seq_cnt = 0x02000000; // sequence ID: df_ctl: sequence count
4907
4908 rspHDR->ro = 0x0L; // relative offset (n/a)
4909
4910
4911 // Now setup the SEST entry
4912 pTRE = &fcChip->SEST->u[ *fcExchangeIndex ].TRE;
4913
4914
4915 // VALid entry:Dir outbound:enable CM:enal INT:
4916 pTRE->Hdr_Len = 0x86010020L; // data frame Len always 32 bytes
4917 pTRE->Hdr_Addr = // bus address of dataHDR;
4918 fcChip->SEST->base +
4919 ((unsigned long)&fcChip->SEST->DataHDR[ *fcExchangeIndex ] -
4920 (unsigned long)fcChip->SEST);
4921
4922 pTRE->RSP_Len = 64L; // hdr+data (TL assisted RSP frame)
4923 pTRE->RSP_Len |= (InFCHS->s_id << 8); // MS 24 bits Remote_ID
4924 pTRE->RSP_Addr = // bus address of rspHDR
4925 fcChip->SEST->base +
4926 ((unsigned long)&fcChip->SEST->RspHDR[ *fcExchangeIndex ] -
4927 (unsigned long)fcChip->SEST);
4928
4929 // Do we need local or extended gather list?
4930 // depends on size - we can handle 3 len/addr pairs
4931 // locally.
4932
4933 fcp_dl = build_SEST_sgList(
4934 cpqfcHBAdata->PciDev,
4935 &pTRE->GLen1,
4936 Cmnd, // S/G list
4937 &sgPairs, // return # of pairs in S/G list (from "Data" descriptor)
4938 &fcChip->SEST->sgPages[ *fcExchangeIndex ]);// (for Freeing later)
4939
4940
4941 if( !fcp_dl ) // error building S/G list?
4942 {
4943 ulStatus = MEMPOOL_FAIL;
4944 break; // give up
4945 }
4946
4947 // no payload or command to build -- READ doesn't need XRDY
4948
4949
4950 if( sgPairs > 3 ) // need extended s/g list
4951 pTRE->Buff_Off = 0x78000000L; // extended data | (no offset)
4952 else // local data pointers (in SEST)
4953 pTRE->Buff_Off = 0xf8000000L; // local data | (no offset)
4954
4955 // ULONG 5
4956 pTRE->Buff_Index = 0L; // Buff_Index | reserved
4957 pTRE->reserved = 0x0L; // DWord 6
4958
4959 // DWord 7: NOTE: zero length will
4960 // hang TachLite!
4961 pTRE->Data_Len = fcp_dl; // e.g. sum of scatter buffers
4962
4963 pTRE->reserved_ = 0L; // DWord 8
4964 pTRE->reserved__ = 0L; // DWord 9
4965
4966 break;
4967
4968
4969
4970
4971
4972
4973
4974 case FCP_RESPONSE:
4975 // Target response frame: this sequence uses an OX/RX ID
4976 // pair from a completed SEST exchange. We built most
4977 // of the response frame when we created the TWE/TRE.
4978
4979 *pIRB_flags = 0; // clear IRB flags
4980 IRB_flags.SFA = 1; // send SFS (RSP)
4981 SfsLen = *pIRB_flags;
4982
4983 SfsLen <<= 24; // shift flags to MSB
4984 SfsLen += sizeof(TachFCHDR_RSP);// add SFS len (header & RSP payload)
4985
4986
4987 Exchanges->fcExchange[ *fcExchangeIndex].type =
4988 FCP_RESPONSE; // change Exchange type to "response" phase
4989
4990 // take advantage of prior knowledge of OX/RX_ID pair from
4991 // previous XFER outbound frame (still in fchs of exchange)
4992 fcChip->SEST->RspHDR[ *fcExchangeIndex ].ox_rx_id =
4993 CMDfchs->ox_rx_id;
4994
4995 // Check the status of the DATA phase of the exchange so we can report
4996 // status to the initiator
4997 buildFCPstatus( fcChip, *fcExchangeIndex); // set RSP payload fields
4998
4999 memcpy(
5000 CMDfchs, // re-use same XFER fchs for Response frame
5001 &fcChip->SEST->RspHDR[ *fcExchangeIndex ],
5002 sizeof( TachFCHDR_RSP ));
5003
5004
5005 break;
5006
5007 default:
5008 printk("cpqfcTS: don't know how to build FC type: %Xh(%d)\n", type,type);
5009 break;
5010
5011 }
5012
5013
5014
5015 if( !ulStatus) // no errors above?
5016 {
5017 // FCHS is built; now build IRB
5018
5019 // link the just built FCHS (the "command") to the IRB entry
5020 // for this Exchange.
5021 pIRB = &Exchanges->fcExchange[ *fcExchangeIndex].IRB;
5022
5023 // len & flags according to command type above
5024 pIRB->Req_A_SFS_Len = SfsLen; // includes IRB flags & len
5025 pIRB->Req_A_SFS_Addr = // TL needs physical addr of frame to send
5026 fcChip->exch_dma_handle + (unsigned long)CMDfchs -
5027 (unsigned long)Exchanges;
5028
5029 pIRB->Req_A_SFS_D_ID = CMDfchs->d_id << 8; // Dest_ID must be consistent!
5030
5031 // Exchange is complete except for "fix-up" fields to be set
5032 // at Tachyon Queuing time:
5033 // IRB->Req_A_Trans_ID (OX_ID/ RX_ID):
5034 // for SEST entry, lower bits correspond to actual FC Exchange ID
5035 // fchs->OX_ID or RX_ID
5036 }
5037 else
5038 {
5039#ifdef DBG
5040 printk( "FC Error: SEST build Pool Allocation failed\n");
5041#endif
5042 // return resources...
5043 cpqfcTSCompleteExchange( cpqfcHBAdata->PciDev, fcChip, *fcExchangeIndex); // SEST build failed
5044 }
5045 }
5046 else // no Exchanges available
5047 {
5048 ulStatus = SEST_FULL;
5049 printk( "FC Error: no fcExchanges available\n");
5050 }
5051 return ulStatus;
5052}
5053
5054
5055
5056
5057
5058
5059// set RSP payload fields
5060static void buildFCPstatus( PTACHYON fcChip, ULONG ExchangeID)
5061{
5062 FC_EXCHANGES *Exchanges = fcChip->Exchanges;
5063 FC_EXCHANGE *pExchange = &Exchanges->fcExchange[ExchangeID]; // shorthand
5064 PFCP_STATUS_RESPONSE pFcpStatus;
5065
5066 memset( &fcChip->SEST->RspHDR[ ExchangeID ].pl, 0,
5067 sizeof( FCP_STATUS_RESPONSE) );
5068 if( pExchange->status ) // something wrong?
5069 {
5070 pFcpStatus = (PFCP_STATUS_RESPONSE) // cast RSP buffer for this xchng
5071 &fcChip->SEST->RspHDR[ ExchangeID ].pl;
5072 if( pExchange->status & COUNT_ERROR )
5073 {
5074
5075 // set FCP response len valid (so we can report count error)
5076 pFcpStatus->fcp_status |= FCP_RSP_LEN_VALID;
5077 pFcpStatus->fcp_rsp_len = 0x04000000; // 4 byte len (BIG Endian)
5078
5079 pFcpStatus->fcp_rsp_info = FCP_DATA_LEN_NOT_BURST_LEN; // RSP_CODE
5080 }
5081 }
5082}
5083
5084
5085static dma_addr_t
5086cpqfc_pci_map_sg_page(
5087 struct pci_dev *pcidev,
5088 ULONG *hw_paddr, // where to put phys addr for HW use
5089 void *sgp_vaddr, // the virtual address of the sg page
5090 dma_addr_t *umap_paddr, // where to put phys addr for unmap
5091 unsigned int *maplen, // where to store sg entry length
5092 int PairCount) // number of sg pairs used in the page.
5093{
5094 unsigned long aligned_addr = (unsigned long) sgp_vaddr;
5095
5096 *maplen = PairCount * 8;
5097 aligned_addr += TL_EXT_SG_PAGE_BYTELEN;
5098 aligned_addr &= ~(TL_EXT_SG_PAGE_BYTELEN -1);
5099
5100 *umap_paddr = pci_map_single(pcidev, (void *) aligned_addr,
5101 *maplen, PCI_DMA_TODEVICE);
5102 *hw_paddr = (ULONG) *umap_paddr;
5103
5104# if BITS_PER_LONG > 32
5105 if( *umap_paddr >>32 ) {
5106 printk("cqpfcTS:Tach SG DMA addr %p>32 bits\n",
5107 (void*)umap_paddr);
5108 return 0;
5109 }
5110# endif
5111 return *umap_paddr;
5112}
5113
5114static void
5115cpqfc_undo_SEST_mappings(struct pci_dev *pcidev,
5116 unsigned long contigaddr, int len, int dir,
5117 struct scatterlist *sgl, int use_sg,
5118 PSGPAGES *sgPages_head,
5119 int allocated_pages)
5120{
5121 PSGPAGES i, next;
5122
5123 if (contigaddr != (unsigned long) NULL)
5124 pci_unmap_single(pcidev, contigaddr, len, dir);
5125
5126 if (sgl != NULL)
5127 pci_unmap_sg(pcidev, sgl, use_sg, dir);
5128
5129 for (i=*sgPages_head; i != NULL ;i = next)
5130 {
5131 pci_unmap_single(pcidev, i->busaddr, i->maplen,
5132 scsi_to_pci_dma_dir(PCI_DMA_TODEVICE));
5133 i->busaddr = (dma_addr_t) NULL;
5134 i->maplen = 0L;
5135 next = i->next;
5136 kfree(i);
5137 }
5138 *sgPages_head = NULL;
5139}
5140
5141// This routine builds scatter/gather lists into SEST entries
5142// INPUTS:
5143// SESTalPair - SEST address @DWordA "Local Buffer Length"
5144// sgList - Scatter/Gather linked list of Len/Address data buffers
5145// OUTPUT:
5146// sgPairs - number of valid address/length pairs
5147// Remarks:
5148// The SEST data buffer pointers only depend on number of
5149// length/ address pairs, NOT on the type (IWE, TRE,...)
5150// Up to 3 pairs can be referenced in the SEST - more than 3
5151// require this Extended S/G list page. The page holds 4, 8, 16...
5152// len/addr pairs, per Scatter/Gather List Page Length Reg.
5153// TachLite allows pages to be linked to any depth.
5154
5155//#define DBG_SEST_SGLIST 1 // for printing out S/G pairs with Ext. pages
5156
5157static int ap_hi_water = TL_DANGER_SGPAGES;
5158
5159static ULONG build_SEST_sgList(
5160 struct pci_dev *pcidev,
5161 ULONG *SESTalPairStart, // the 3 len/address buffers in SEST
5162 Scsi_Cmnd *Cmnd,
5163 ULONG *sgPairs,
5164 PSGPAGES *sgPages_head) // link list of TL Ext. S/G pages from O/S Pool
5165
5166{
5167 ULONG i, AllocatedPages=0; // Tach Ext. S/G page allocations
5168 ULONG* alPair = SESTalPairStart;
5169 ULONG* ext_sg_page_phys_addr_place = NULL;
5170 int PairCount;
5171 unsigned long ulBuff, contigaddr;
5172 ULONG total_data_len=0; // (in bytes)
5173 ULONG bytes_to_go = Cmnd->request_bufflen; // total xfer (S/G sum)
5174 ULONG thisMappingLen;
5175 struct scatterlist *sgl = NULL; // S/G list (Linux format)
5176 int sg_count, totalsgs;
5177 dma_addr_t busaddr;
5178 unsigned long thislen, offset;
5179 PSGPAGES *sgpage = sgPages_head;
5180 PSGPAGES prev_page = NULL;
5181
5182# define WE_HAVE_SG_LIST (sgl != (unsigned long) NULL)
5183 contigaddr = (unsigned long) NULL;
5184
5185 if( !Cmnd->use_sg ) // no S/G list?
5186 {
5187 if (bytes_to_go <= TL_MAX_SG_ELEM_LEN)
5188 {
5189 *sgPairs = 1; // use "local" S/G pair in SEST entry
5190 // (for now, ignore address bits above #31)
5191
5192 *alPair++ = bytes_to_go; // bits 18-0, length
5193
5194 if (bytes_to_go != 0) {
5195 contigaddr = ulBuff = pci_map_single(pcidev,
5196 Cmnd->request_buffer,
5197 Cmnd->request_bufflen,
5198 scsi_to_pci_dma_dir(Cmnd->sc_data_direction));
5199 // printk("ms %p ", ulBuff);
5200 }
5201 else {
5202 // No data transfer, (e.g.: Test Unit Ready)
5203 // printk("btg=0 ");
5204 *sgPairs = 0;
5205 memset(alPair, 0, sizeof(*alPair));
5206 return 0;
5207 }
5208
5209# if BITS_PER_LONG > 32
5210 if( ulBuff >>32 ) {
5211 printk("FATAL! Tachyon DMA address %p "
5212 "exceeds 32 bits\n", (void*)ulBuff );
5213 return 0;
5214 }
5215# endif
5216 *alPair = (ULONG)ulBuff;
5217 return bytes_to_go;
5218 }
5219 else // We have a single large (too big) contiguous buffer.
5220 { // We will have to break it up. We'll use the scatter
5221 // gather code way below, but use contigaddr instead
5222 // of sg_dma_addr(). (this is a very rare case).
5223
5224 unsigned long btg;
5225 contigaddr = pci_map_single(pcidev, Cmnd->request_buffer,
5226 Cmnd->request_bufflen,
5227 scsi_to_pci_dma_dir(Cmnd->sc_data_direction));
5228
5229 // printk("contigaddr = %p, len = %d\n",
5230 // (void *) contigaddr, bytes_to_go);
5231 totalsgs = 0;
5232 for (btg = bytes_to_go; btg > 0; ) {
5233 btg -= ( btg > TL_MAX_SG_ELEM_LEN ?
5234 TL_MAX_SG_ELEM_LEN : btg );
5235 totalsgs++;
5236 }
5237 sgl = NULL;
5238 *sgPairs = totalsgs;
5239 }
5240 }
5241 else // we do have a scatter gather list
5242 {
5243 // [TBD - update for Linux to support > 32 bits addressing]
5244 // since the format for local & extended S/G lists is different,
5245 // check if S/G pairs exceeds 3.
5246 // *sgPairs = Cmnd->use_sg; Nope, that's wrong.
5247
5248 sgl = (struct scatterlist*)Cmnd->request_buffer;
5249 sg_count = pci_map_sg(pcidev, sgl, Cmnd->use_sg,
5250 scsi_to_pci_dma_dir(Cmnd->sc_data_direction));
5251 if( sg_count <= 3 ) {
5252
5253 // we need to be careful here that no individual mapping
5254 // is too large, and if any is, that breaking it up
5255 // doesn't push us over 3 sgs, or, if it does, that we
5256 // handle that case. Tachyon can take 0x7FFFF bits for length,
5257 // but sg structure uses "unsigned int", on the face of it,
5258 // up to 0xFFFFFFFF or even more.
5259
5260 int i;
5261 unsigned long thislen;
5262
5263 totalsgs = 0;
5264 for (i=0;i<sg_count;i++) {
5265 thislen = sg_dma_len(&sgl[i]);
5266 while (thislen >= TL_MAX_SG_ELEM_LEN) {
5267 totalsgs++;
5268 thislen -= TL_MAX_SG_ELEM_LEN;
5269 }
5270 if (thislen > 0) totalsgs++;
5271 }
5272 *sgPairs = totalsgs;
5273 } else totalsgs = 999; // as a first estimate, definitely >3,
5274
5275 // if (totalsgs != sg_count)
5276 // printk("totalsgs = %d, sgcount=%d\n",totalsgs,sg_count);
5277 }
5278
5279 if( totalsgs <= 3 ) // can (must) use "local" SEST list
5280 {
5281 while( bytes_to_go)
5282 {
5283 offset = 0L;
5284
5285 if ( WE_HAVE_SG_LIST )
5286 thisMappingLen = sg_dma_len(sgl);
5287 else // or contiguous buffer?
5288 thisMappingLen = bytes_to_go;
5289
5290 while (thisMappingLen > 0)
5291 {
5292 thislen = thisMappingLen > TL_MAX_SG_ELEM_LEN ?
5293 TL_MAX_SG_ELEM_LEN : thisMappingLen;
5294 bytes_to_go = bytes_to_go - thislen;
5295
5296 // we have L/A pair; L = thislen, A = physicalAddress
5297 // load into SEST...
5298
5299 total_data_len += thislen;
5300 *alPair = thislen; // bits 18-0, length
5301
5302 alPair++;
5303
5304 if ( WE_HAVE_SG_LIST )
5305 ulBuff = sg_dma_address(sgl) + offset;
5306 else
5307 ulBuff = contigaddr + offset;
5308
5309 offset += thislen;
5310
5311# if BITS_PER_LONG > 32
5312 if( ulBuff >>32 ) {
5313 printk("cqpfcTS: 2Tach DMA address %p > 32 bits\n",
5314 (void*)ulBuff );
5315 printk("%s = %p, offset = %ld\n",
5316 WE_HAVE_SG_LIST ? "ulBuff" : "contigaddr",
5317 WE_HAVE_SG_LIST ? (void *) ulBuff : (void *) contigaddr,
5318 offset);
5319 return 0;
5320 }
5321# endif
5322 *alPair++ = (ULONG)ulBuff; // lower 32 bits (31-0)
5323 thisMappingLen -= thislen;
5324 }
5325
5326 if ( WE_HAVE_SG_LIST ) ++sgl; // next S/G pair
5327 else if (bytes_to_go != 0) printk("BTG not zero!\n");
5328
5329# ifdef DBG_SEST_SGLIST
5330 printk("L=%d ", thisMappingLen);
5331 printk("btg=%d ", bytes_to_go);
5332# endif
5333
5334 }
5335 // printk("i:%d\n", *sgPairs);
5336 }
5337 else // more than 3 pairs requires Extended S/G page (Pool Allocation)
5338 {
5339 // clear out SEST DWORDs (local S/G addr) C-F (A-B set in following logic)
5340 for( i=2; i<6; i++)
5341 alPair[i] = 0;
5342
5343 PairCount = TL_EXT_SG_PAGE_COUNT; // forces initial page allocation
5344 totalsgs = 0;
5345 while( bytes_to_go )
5346 {
5347 // Per SEST format, we can support 524287 byte lengths per
5348 // S/G pair. Typical user buffers are 4k, and very rarely
5349 // exceed 12k due to fragmentation of physical memory pages.
5350 // However, on certain O/S system (not "user") buffers (on platforms
5351 // with huge memories), it's possible to exceed this
5352 // length in a single S/G address/len mapping, so we have to handle
5353 // that.
5354
5355 offset = 0L;
5356 if ( WE_HAVE_SG_LIST )
5357 thisMappingLen = sg_dma_len(sgl);
5358 else
5359 thisMappingLen = bytes_to_go;
5360
5361 while (thisMappingLen > 0)
5362 {
5363 thislen = thisMappingLen > TL_MAX_SG_ELEM_LEN ?
5364 TL_MAX_SG_ELEM_LEN : thisMappingLen;
5365 // printk("%d/%d/%d\n", thislen, thisMappingLen, bytes_to_go);
5366
5367 // should we load into "this" extended S/G page, or allocate
5368 // new page?
5369
5370 if( PairCount >= TL_EXT_SG_PAGE_COUNT )
5371 {
5372 // Now, we have to map the previous page, (triggering buffer bounce)
5373 // The first time thru the loop, there won't be a previous page.
5374 if (prev_page != NULL) // is there a prev page?
5375 {
5376 // this code is normally kind of hard to trigger,
5377 // you have to use up more than 256 scatter gather
5378 // elements to get here. Cranking down TL_MAX_SG_ELEM_LEN
5379 // to an absurdly low value (128 bytes or so) to artificially
5380 // break i/o's into a zillion pieces is how I tested it.
5381 busaddr = cpqfc_pci_map_sg_page(pcidev,
5382 ext_sg_page_phys_addr_place,
5383 prev_page->page,
5384 &prev_page->busaddr,
5385 &prev_page->maplen,
5386 PairCount);
5387 }
5388 // Allocate the TL Extended S/G list page. We have
5389 // to allocate twice what we want to ensure required TL alignment
5390 // (Tachlite TL/TS User Man. Rev 6.0, p 168)
5391 // We store the original allocated PVOID so we can free later
5392 *sgpage = kmalloc( sizeof(SGPAGES), GFP_ATOMIC);
5393 if ( ! *sgpage )
5394 {
5395 printk("cpqfc: Allocation failed @ %d S/G page allocations\n",
5396 AllocatedPages);
5397 total_data_len = 0; // failure!! Ext. S/G is All-or-none affair
5398
5399 // unmap the previous mappings, if any.
5400
5401 cpqfc_undo_SEST_mappings(pcidev, contigaddr,
5402 Cmnd->request_bufflen,
5403 scsi_to_pci_dma_dir(Cmnd->sc_data_direction),
5404 sgl, Cmnd->use_sg, sgPages_head, AllocatedPages+1);
5405
5406 // FIXME: testing shows that if we get here,
5407 // it's bad news. (this has been this way for a long
5408 // time though, AFAIK. Not that that excuses it.)
5409
5410 return 0; // give up (and probably hang the system)
5411 }
5412 // clear out memory we just allocated
5413 memset( (*sgpage)->page,0,TL_EXT_SG_PAGE_BYTELEN*2);
5414 (*sgpage)->next = NULL;
5415 (*sgpage)->busaddr = (dma_addr_t) NULL;
5416 (*sgpage)->maplen = 0L;
5417
5418 // align the memory - TL requires sizeof() Ext. S/G page alignment.
5419 // We doubled the actual required size so we could mask off LSBs
5420 // to get desired offset
5421
5422 ulBuff = (unsigned long) (*sgpage)->page;
5423 ulBuff += TL_EXT_SG_PAGE_BYTELEN;
5424 ulBuff &= ~(TL_EXT_SG_PAGE_BYTELEN -1);
5425
5426 // set pointer, in SEST if first Ext. S/G page, or in last pair
5427 // of linked Ext. S/G pages... (Only 32-bit PVOIDs, so just
5428 // load lower 32 bits)
5429 // NOTE: the Len field must be '0' if this is the first Ext. S/G
5430 // pointer in SEST, and not 0 otherwise (we know thislen != 0).
5431
5432 *alPair = (alPair != SESTalPairStart) ? thislen : 0;
5433
5434# ifdef DBG_SEST_SGLIST
5435 printk("PairCount %d @%p even %Xh, ",
5436 PairCount, alPair, *alPair);
5437# endif
5438
5439 // Save the place where we need to store the physical
5440 // address of this scatter gather page which we get when we map it
5441 // (and mapping we can do only after we fill it in.)
5442 alPair++; // next DWORD, will contain phys addr of the ext page
5443 ext_sg_page_phys_addr_place = alPair;
5444
5445 // Now, set alPair = the virtual addr of the (Extended) S/G page
5446 // which will accept the Len/ PhysicalAddress pairs
5447 alPair = (ULONG *) ulBuff;
5448
5449 AllocatedPages++;
5450 if (AllocatedPages >= ap_hi_water)
5451 {
5452 // This message should rarely, if ever, come out.
5453 // Previously (cpqfc version <= 2.0.5) the driver would
5454 // just puke if more than 4 SG pages were used, and nobody
5455 // ever complained about that. This only comes out if
5456 // more than 8 pages are used.
5457
5458 printk(KERN_WARNING
5459 "cpqfc: Possible danger. %d scatter gather pages used.\n"
5460 "cpqfc: detected seemingly extreme memory "
5461 "fragmentation or huge data transfers.\n",
5462 AllocatedPages);
5463 ap_hi_water = AllocatedPages+1;
5464 }
5465
5466 PairCount = 1; // starting new Ext. S/G page
5467 prev_page = (*sgpage); // remember this page, for next time thru
5468 sgpage = &((*sgpage)->next);
5469 } // end of new TL Ext. S/G page allocation
5470
5471 *alPair = thislen; // bits 18-0, length (range check above)
5472
5473# ifdef DBG_SEST_SGLIST
5474 printk("PairCount %d @%p, even %Xh, ", PairCount, alPair, *alPair);
5475# endif
5476
5477 alPair++; // next DWORD, physical address
5478
5479 if ( WE_HAVE_SG_LIST )
5480 ulBuff = sg_dma_address(sgl) + offset;
5481 else
5482 ulBuff = contigaddr + offset;
5483 offset += thislen;
5484
5485# if BITS_PER_LONG > 32
5486 if( ulBuff >>32 )
5487 {
5488 printk("cqpfcTS: 1Tach DMA address %p > 32 bits\n", (void*)ulBuff );
5489 printk("%s = %p, offset = %ld\n",
5490 WE_HAVE_SG_LIST ? "ulBuff" : "contigaddr",
5491 WE_HAVE_SG_LIST ? (void *) ulBuff : (void *) contigaddr,
5492 offset);
5493 return 0;
5494 }
5495# endif
5496
5497 *alPair = (ULONG) ulBuff; // lower 32 bits (31-0)
5498
5499# ifdef DBG_SEST_SGLIST
5500 printk("odd %Xh\n", *alPair);
5501# endif
5502 alPair++; // next DWORD, next address/length pair
5503
5504 PairCount++; // next Length/Address pair
5505
5506 // if (PairCount > pc_hi_water)
5507 // {
5508 // printk("pc hi = %d ", PairCount);
5509 // pc_hi_water = PairCount;
5510 // }
5511 bytes_to_go -= thislen;
5512 total_data_len += thislen;
5513 thisMappingLen -= thislen;
5514 totalsgs++;
5515 } // while (thisMappingLen > 0)
5516 if ( WE_HAVE_SG_LIST ) sgl++; // next S/G pair
5517 } // while (bytes_to_go)
5518
5519 // printk("Totalsgs=%d\n", totalsgs);
5520 *sgPairs = totalsgs;
5521
5522 // PCI map (and bounce) the last (and usually only) extended SG page
5523 busaddr = cpqfc_pci_map_sg_page(pcidev,
5524 ext_sg_page_phys_addr_place,
5525 prev_page->page,
5526 &prev_page->busaddr,
5527 &prev_page->maplen,
5528 PairCount);
5529 }
5530 return total_data_len;
5531}
5532
5533
5534
5535// The Tachlite SEST table is referenced to OX_ID (or RX_ID). To optimize
5536// performance and debuggability, we index the Exchange structure to FC X_ID
5537// This enables us to build exchanges for later en-queing to Tachyon,
5538// provided we have an open X_ID slot. At Tachyon queing time, we only
5539// need an ERQ slot; then "fix-up" references in the
5540// IRB, FCHS, etc. as needed.
5541// RETURNS:
5542// 0 if successful
5543// non-zero on error
5544//sstartex
5545ULONG cpqfcTSStartExchange(
5546 CPQFCHBA *cpqfcHBAdata,
5547 LONG ExchangeID )
5548{
5549 PTACHYON fcChip = &cpqfcHBAdata->fcChip;
5550 FC_EXCHANGES *Exchanges = fcChip->Exchanges;
5551 FC_EXCHANGE *pExchange = &Exchanges->fcExchange[ ExchangeID ]; // shorthand
5552 USHORT producer, consumer;
5553 ULONG ulStatus=0;
5554 short int ErqIndex;
5555 BOOLEAN CompleteExchange = FALSE; // e.g. ACC replies are complete
5556 BOOLEAN SestType=FALSE;
5557 ULONG InboundData=0;
5558
5559 // We will manipulate Tachlite chip registers here to successfully
5560 // start exchanges.
5561
5562 // Check that link is not down -- we can't start an exchange on a
5563 // down link!
5564
5565 if( fcChip->Registers.FMstatus.value & 0x80) // LPSM offline?
5566 {
5567printk("fcStartExchange: PSM offline (%Xh), x_ID %Xh, type %Xh, port_id %Xh\n",
5568 fcChip->Registers.FMstatus.value & 0xFF,
5569 ExchangeID,
5570 pExchange->type,
5571 pExchange->fchs.d_id);
5572
5573 if( ExchangeID >= TACH_SEST_LEN ) // Link Service Outbound frame?
5574 {
5575 // Our most popular LinkService commands are port discovery types
5576 // (PLOGI/ PDISC...), which are implicitly nullified by Link Down
5577 // events, so it makes no sense to Que them. However, ABTS should
5578 // be queued, since exchange sequences are likely destroyed by
5579 // Link Down events, and we want to notify other ports of broken
5580 // sequences by aborting the corresponding exchanges.
5581 if( pExchange->type != BLS_ABTS )
5582 {
5583 ulStatus = LNKDWN_OSLS;
5584 goto Done;
5585 // don't Que most LinkServ exchanges on LINK DOWN
5586 }
5587 }
5588
5589 printk("fcStartExchange: Que x_ID %Xh, type %Xh\n",
5590 ExchangeID, pExchange->type);
5591 pExchange->status |= EXCHANGE_QUEUED;
5592 ulStatus = EXCHANGE_QUEUED;
5593 goto Done;
5594 }
5595
5596 // Make sure ERQ has available space.
5597
5598 producer = (USHORT)fcChip->ERQ->producerIndex; // copies for logical arith.
5599 consumer = (USHORT)fcChip->ERQ->consumerIndex;
5600 producer++; // We are testing for full que by incrementing
5601
5602 if( producer >= ERQ_LEN ) // rollover condition?
5603 producer = 0;
5604 if( consumer != producer ) // ERQ not full?
5605 {
5606 // ****************** Need Atomic access to chip registers!!********
5607
5608 // remember ERQ PI for copying IRB
5609 ErqIndex = (USHORT)fcChip->ERQ->producerIndex;
5610 fcChip->ERQ->producerIndex = producer; // this is written to Tachyon
5611 // we have an ERQ slot! If SCSI command, need SEST slot
5612 // otherwise we are done.
5613
5614 // Note that Tachyon requires that bit 15 of the OX_ID or RX_ID be
5615 // set according to direction of data to/from Tachyon for SEST assists.
5616 // For consistency, enforce this rule for Link Service (non-SEST)
5617 // exchanges as well.
5618
5619 // fix-up the X_ID field in IRB
5620 pExchange->IRB.Req_A_Trans_ID = ExchangeID & 0x7FFF; // 15-bit field
5621
5622 // fix-up the X_ID field in fchs -- depends on Originator or Responder,
5623 // outgoing or incoming data?
5624 switch( pExchange->type )
5625 {
5626 // ORIGINATOR types... we're setting our OX_ID and
5627 // defaulting the responder's RX_ID to 0xFFFF
5628
5629 case SCSI_IRE:
5630 // Requirement: set MSB of x_ID for Incoming TL data
5631 // (see "Tachyon TL/TS User's Manual", Rev 6.0, Sept.'98, pg. 50)
5632 InboundData = 0x8000;
5633
5634 case SCSI_IWE:
5635 SestType = TRUE;
5636 pExchange->fchs.ox_rx_id = (ExchangeID | InboundData);
5637 pExchange->fchs.ox_rx_id <<= 16; // MSW shift
5638 pExchange->fchs.ox_rx_id |= 0xffff; // add default RX_ID
5639
5640 // now fix-up the Data HDR OX_ID (TL automatically does rx_id)
5641 // (not necessary for IRE -- data buffer unused)
5642 if( pExchange->type == SCSI_IWE)
5643 {
5644 fcChip->SEST->DataHDR[ ExchangeID ].ox_rx_id =
5645 pExchange->fchs.ox_rx_id;
5646
5647 }
5648
5649 break;
5650
5651
5652 case FCS_NSR: // ext. link service Name Service Request
5653 case ELS_SCR: // ext. link service State Change Registration
5654 case ELS_FDISC:// ext. link service login
5655 case ELS_FLOGI:// ext. link service login
5656 case ELS_LOGO: // FC-PH extended link service logout
5657 case BLS_NOP: // Basic link service No OPeration
5658 case ELS_PLOGI:// ext. link service login (PLOGI)
5659 case ELS_PDISC:// ext. link service login (PDISC)
5660 case ELS_PRLI: // ext. link service process login
5661
5662 pExchange->fchs.ox_rx_id = ExchangeID;
5663 pExchange->fchs.ox_rx_id <<= 16; // MSW shift
5664 pExchange->fchs.ox_rx_id |= 0xffff; // and RX_ID
5665
5666 break;
5667
5668
5669
5670
5671 // RESPONDER types... we must set our RX_ID while preserving
5672 // sender's OX_ID
5673 // outgoing (or no) data
5674 case ELS_RJT: // extended link service reject
5675 case ELS_LOGO_ACC: // FC-PH extended link service logout accept
5676 case ELS_ACC: // ext. generic link service accept
5677 case ELS_PLOGI_ACC:// ext. link service login accept (PLOGI or PDISC)
5678 case ELS_PRLI_ACC: // ext. link service process login accept
5679
5680 CompleteExchange = TRUE; // Reply (ACC or RJT) is end of exchange
5681 pExchange->fchs.ox_rx_id |= (ExchangeID & 0xFFFF);
5682
5683 break;
5684
5685
5686 // since we are a Responder, OX_ID should already be set by
5687 // cpqfcTSBuildExchange(). We need to -OR- in RX_ID
5688 case SCSI_TWE:
5689 SestType = TRUE;
5690 // Requirement: set MSB of x_ID for Incoming TL data
5691 // (see "Tachyon TL/TS User's Manual", Rev 6.0, Sept.'98, pg. 50)
5692
5693 pExchange->fchs.ox_rx_id &= 0xFFFF0000; // clear RX_ID
5694 // Requirement: set MSB of RX_ID for Incoming TL data
5695 // (see "Tachyon TL/TS User's Manual", Rev 6.0, Sept.'98, pg. 50)
5696 pExchange->fchs.ox_rx_id |= (ExchangeID | 0x8000);
5697 break;
5698
5699
5700 case SCSI_TRE:
5701 SestType = TRUE;
5702
5703 // there is no XRDY for SEST target read; the data
5704 // header needs to be updated. Also update the RSP
5705 // exchange IDs for the status frame, in case it is sent automatically
5706 fcChip->SEST->DataHDR[ ExchangeID ].ox_rx_id |= ExchangeID;
5707 fcChip->SEST->RspHDR[ ExchangeID ].ox_rx_id =
5708 fcChip->SEST->DataHDR[ ExchangeID ].ox_rx_id;
5709
5710 // for easier FCP response logic (works for TWE and TRE),
5711 // copy exchange IDs. (Not needed if TRE 'RSP' bit set)
5712 pExchange->fchs.ox_rx_id =
5713 fcChip->SEST->DataHDR[ ExchangeID ].ox_rx_id;
5714
5715 break;
5716
5717
5718 case FCP_RESPONSE: // using existing OX_ID/ RX_ID pair,
5719 // start SFS FCP-RESPONSE frame
5720 // OX/RX_ID should already be set! (See "fcBuild" above)
5721 CompleteExchange = TRUE; // RSP is end of FCP-SCSI exchange
5722
5723
5724 break;
5725
5726
5727 case BLS_ABTS_RJT: // uses new RX_ID, since SEST x_ID non-existent
5728 case BLS_ABTS_ACC: // using existing OX_ID/ RX_ID pair from SEST entry
5729 CompleteExchange = TRUE; // ACC or RJT marks end of FCP-SCSI exchange
5730 case BLS_ABTS: // using existing OX_ID/ RX_ID pair from SEST entry
5731
5732
5733 break;
5734
5735
5736 default:
5737 printk("Error on fcStartExchange: undefined type %Xh(%d)\n",
5738 pExchange->type, pExchange->type);
5739 return INVALID_ARGS;
5740 }
5741
5742
5743 // X_ID fields are entered -- copy IRB to Tachyon's ERQ
5744
5745
5746 memcpy(
5747 &fcChip->ERQ->QEntry[ ErqIndex ], // dest.
5748 &pExchange->IRB,
5749 32); // fixed (hardware) length!
5750
5751 PCI_TRACEO( ExchangeID, 0xA0)
5752
5753 // ACTION! May generate INT and IMQ entry
5754 writel( fcChip->ERQ->producerIndex,
5755 fcChip->Registers.ERQproducerIndex.address);
5756
5757
5758 if( ExchangeID >= TACH_SEST_LEN ) // Link Service Outbound frame?
5759 {
5760
5761 // wait for completion! (TDB -- timeout and chip reset)
5762
5763
5764 PCI_TRACEO( ExchangeID, 0xA4)
5765
5766 enable_irq( cpqfcHBAdata->HostAdapter->irq); // only way to get Sem.
5767
5768 down_interruptible( cpqfcHBAdata->TYOBcomplete);
5769
5770 disable_irq( cpqfcHBAdata->HostAdapter->irq);
5771 PCI_TRACE( 0xA4)
5772
5773 // On login exchanges, BAD_ALPA (non-existent port_id) results in
5774 // FTO (Frame Time Out) on the Outbound Completion message.
5775 // If we got an FTO status, complete the exchange (free up slot)
5776 if( CompleteExchange || // flag from Reply frames
5777 pExchange->status ) // typically, can get FRAME_TO
5778 {
5779 cpqfcTSCompleteExchange( cpqfcHBAdata->PciDev, fcChip, ExchangeID);
5780 }
5781 }
5782
5783 else // SEST Exchange
5784 {
5785 ulStatus = 0; // ship & pray success (e.g. FCP-SCSI)
5786
5787 if( CompleteExchange ) // by Type of exchange (e.g. end-of-xchng)
5788 {
5789 cpqfcTSCompleteExchange( cpqfcHBAdata->PciDev, fcChip, ExchangeID);
5790 }
5791
5792 else
5793 pExchange->status &= ~EXCHANGE_QUEUED; // clear ExchangeQueued flag
5794
5795 }
5796 }
5797
5798
5799 else // ERQ 'producer' = 'consumer' and QUE is full
5800 {
5801 ulStatus = OUTQUE_FULL; // Outbound (ERQ) Que full
5802 }
5803
5804Done:
5805 PCI_TRACE( 0xA0)
5806 return ulStatus;
5807}
5808
5809
5810
5811
5812
5813// Scan fcController->fcExchanges array for a usuable index (a "free"
5814// exchange).
5815// Inputs:
5816// fcChip - pointer to TachLite chip structure
5817// Return:
5818// index - exchange array element where exchange can be built
5819// -1 - exchange array is full
5820// REMARKS:
5821// Although this is a (yuk!) linear search, we presume
5822// that the system will complete exchanges about as quickly as
5823// they are submitted. A full Exchange array (and hence, max linear
5824// search time for free exchange slot) almost guarantees a Fibre problem
5825// of some sort.
5826// In the interest of making exchanges easier to debug, we want a LRU
5827// (Least Recently Used) scheme.
5828
5829
5830static LONG FindFreeExchange( PTACHYON fcChip, ULONG type )
5831{
5832 FC_EXCHANGES *Exchanges = fcChip->Exchanges;
5833 ULONG i;
5834 ULONG ulStatus=-1; // assume failure
5835
5836
5837 if( type == SCSI_IRE ||
5838 type == SCSI_TRE ||
5839 type == SCSI_IWE ||
5840 type == SCSI_TWE)
5841 {
5842 // SCSI type - X_IDs should be from 0 to TACH_SEST_LEN-1
5843 if( fcChip->fcSestExchangeLRU >= TACH_SEST_LEN) // rollover?
5844 fcChip->fcSestExchangeLRU = 0;
5845 i = fcChip->fcSestExchangeLRU; // typically it's already free!
5846
5847 if( Exchanges->fcExchange[i].type == 0 ) // check for "free" element
5848 {
5849 ulStatus = 0; // success!
5850 }
5851
5852 else
5853 { // YUK! we need to do a linear search for free element.
5854 // Fragmentation of the fcExchange array is due to excessively
5855 // long completions or timeouts.
5856
5857 while( TRUE )
5858 {
5859 if( ++i >= TACH_SEST_LEN ) // rollover check
5860 i = 0; // beginning of SEST X_IDs
5861
5862// printk( "looping for SCSI xchng ID: i=%d, type=%Xh\n",
5863// i, Exchanges->fcExchange[i].type);
5864
5865 if( Exchanges->fcExchange[i].type == 0 ) // "free"?
5866 {
5867 ulStatus = 0; // success!
5868 break;
5869 }
5870 if( i == fcChip->fcSestExchangeLRU ) // wrapped-around array?
5871 {
5872 printk( "SEST X_ID space full\n");
5873 break; // failed - prevent inf. loop
5874 }
5875 }
5876 }
5877 fcChip->fcSestExchangeLRU = i + 1; // next! (rollover check next pass)
5878 }
5879
5880
5881
5882 else // Link Service type - X_IDs should be from TACH_SEST_LEN
5883 // to TACH_MAX_XID
5884 {
5885 if( fcChip->fcLsExchangeLRU >= TACH_MAX_XID || // range check
5886 fcChip->fcLsExchangeLRU < TACH_SEST_LEN ) // (e.g. startup)
5887 fcChip->fcLsExchangeLRU = TACH_SEST_LEN;
5888
5889 i = fcChip->fcLsExchangeLRU; // typically it's already free!
5890 if( Exchanges->fcExchange[i].type == 0 ) // check for "free" element
5891 {
5892 ulStatus = 0; // success!
5893 }
5894
5895 else
5896 { // YUK! we need to do a linear search for free element
5897 // Fragmentation of the fcExchange array is due to excessively
5898 // long completions or timeouts.
5899
5900 while( TRUE )
5901 {
5902 if( ++i >= TACH_MAX_XID ) // rollover check
5903 i = TACH_SEST_LEN;// beginning of Link Service X_IDs
5904
5905// printk( "looping for xchng ID: i=%d, type=%Xh\n",
5906// i, Exchanges->fcExchange[i].type);
5907
5908 if( Exchanges->fcExchange[i].type == 0 ) // "free"?
5909 {
5910 ulStatus = 0; // success!
5911 break;
5912 }
5913 if( i == fcChip->fcLsExchangeLRU ) // wrapped-around array?
5914 {
5915 printk( "LinkService X_ID space full\n");
5916 break; // failed - prevent inf. loop
5917 }
5918 }
5919 }
5920 fcChip->fcLsExchangeLRU = i + 1; // next! (rollover check next pass)
5921
5922 }
5923
5924 if( !ulStatus ) // success?
5925 Exchanges->fcExchange[i].type = type; // allocate it.
5926
5927 else
5928 i = -1; // error - all exchanges "open"
5929
5930 return i;
5931}
5932
5933static void
5934cpqfc_pci_unmap_extended_sg(struct pci_dev *pcidev,
5935 PTACHYON fcChip,
5936 ULONG x_ID)
5937{
5938 // Unmaps the memory regions used to hold the scatter gather lists
5939
5940 PSGPAGES i;
5941
5942 // Were there any such regions needing unmapping?
5943 if (! USES_EXTENDED_SGLIST(fcChip->SEST, x_ID))
5944 return; // No such regions, we're outta here.
5945
5946 // for each extended scatter gather region needing unmapping...
5947 for (i=fcChip->SEST->sgPages[x_ID] ; i != NULL ; i = i->next)
5948 pci_unmap_single(pcidev, i->busaddr, i->maplen,
5949 scsi_to_pci_dma_dir(PCI_DMA_TODEVICE));
5950}
5951
5952// Called also from cpqfcTScontrol.o, so can't be static
5953void
5954cpqfc_pci_unmap(struct pci_dev *pcidev,
5955 Scsi_Cmnd *cmd,
5956 PTACHYON fcChip,
5957 ULONG x_ID)
5958{
5959 // Undo the DMA mappings
5960 if (cmd->use_sg) { // Used scatter gather list for data buffer?
5961 cpqfc_pci_unmap_extended_sg(pcidev, fcChip, x_ID);
5962 pci_unmap_sg(pcidev, cmd->buffer, cmd->use_sg,
5963 scsi_to_pci_dma_dir(cmd->sc_data_direction));
5964 // printk("umsg %d\n", cmd->use_sg);
5965 }
5966 else if (cmd->request_bufflen) {
5967 // printk("ums %p ", fcChip->SEST->u[ x_ID ].IWE.GAddr1);
5968 pci_unmap_single(pcidev, fcChip->SEST->u[ x_ID ].IWE.GAddr1,
5969 cmd->request_bufflen,
5970 scsi_to_pci_dma_dir(cmd->sc_data_direction));
5971 }
5972}
5973
5974// We call this routine to free an Exchange for any reason:
5975// completed successfully, completed with error, aborted, etc.
5976
5977// returns FALSE if Exchange failed and "retry" is acceptable
5978// returns TRUE if Exchange was successful, or retry is impossible
5979// (e.g. port/device gone).
5980//scompleteexchange
5981
5982void cpqfcTSCompleteExchange(
5983 struct pci_dev *pcidev,
5984 PTACHYON fcChip,
5985 ULONG x_ID)
5986{
5987 FC_EXCHANGES *Exchanges = fcChip->Exchanges;
5988 int already_unmapped = 0;
5989
5990 if( x_ID < TACH_SEST_LEN ) // SEST-based (or LinkServ for FCP exchange)
5991 {
5992 if( Exchanges->fcExchange[ x_ID ].Cmnd == NULL ) // what#@!
5993 {
5994// TriggerHBA( fcChip->Registers.ReMapMemBase, 0);
5995 printk(" x_ID %Xh, type %Xh, NULL ptr!\n", x_ID,
5996 Exchanges->fcExchange[ x_ID ].type);
5997
5998 goto CleanUpSestResources; // this path should be very rare.
5999 }
6000
6001 // we have Linux Scsi Cmnd ptr..., now check our Exchange status
6002 // to decide how to complete this SEST FCP exchange
6003
6004 if( Exchanges->fcExchange[ x_ID ].status ) // perhaps a Tach indicated problem,
6005 // or abnormal exchange completion
6006 {
6007 // set FCP Link statistics
6008
6009 if( Exchanges->fcExchange[ x_ID ].status & FC2_TIMEOUT)
6010 fcChip->fcStats.timeouts++;
6011 if( Exchanges->fcExchange[ x_ID ].status & INITIATOR_ABORT)
6012 fcChip->fcStats.FC4aborted++;
6013 if( Exchanges->fcExchange[ x_ID ].status & COUNT_ERROR)
6014 fcChip->fcStats.CntErrors++;
6015 if( Exchanges->fcExchange[ x_ID ].status & LINKFAIL_TX)
6016 fcChip->fcStats.linkFailTX++;
6017 if( Exchanges->fcExchange[ x_ID ].status & LINKFAIL_RX)
6018 fcChip->fcStats.linkFailRX++;
6019 if( Exchanges->fcExchange[ x_ID ].status & OVERFLOW)
6020 fcChip->fcStats.CntErrors++;
6021
6022 // First, see if the Scsi upper level initiated an ABORT on this
6023 // exchange...
6024 if( Exchanges->fcExchange[ x_ID ].status == INITIATOR_ABORT )
6025 {
6026 printk(" DID_ABORT, x_ID %Xh, Cmnd %p ",
6027 x_ID, Exchanges->fcExchange[ x_ID ].Cmnd);
6028 goto CleanUpSestResources; // (we don't expect Linux _aborts)
6029 }
6030
6031 // Did our driver timeout the Exchange, or did Tachyon indicate
6032 // a failure during transmission? Ask for retry with "SOFT_ERROR"
6033 else if( Exchanges->fcExchange[ x_ID ].status & FC2_TIMEOUT)
6034 {
6035// printk("result DID_SOFT_ERROR, x_ID %Xh, Cmnd %p\n",
6036// x_ID, Exchanges->fcExchange[ x_ID ].Cmnd);
6037 Exchanges->fcExchange[ x_ID ].Cmnd->result = (DID_SOFT_ERROR <<16);
6038 }
6039
6040 // Did frame(s) for an open exchange arrive in the SFQ,
6041 // meaning the SEST was unable to process them?
6042 else if( Exchanges->fcExchange[ x_ID ].status & SFQ_FRAME)
6043 {
6044// printk("result DID_SOFT_ERROR, x_ID %Xh, Cmnd %p\n",
6045// x_ID, Exchanges->fcExchange[ x_ID ].Cmnd);
6046 Exchanges->fcExchange[ x_ID ].Cmnd->result = (DID_SOFT_ERROR <<16);
6047 }
6048
6049 // Did our driver timeout the Exchange, or did Tachyon indicate
6050 // a failure during transmission? Ask for retry with "SOFT_ERROR"
6051 else if(
6052 (Exchanges->fcExchange[ x_ID ].status & LINKFAIL_TX) ||
6053 (Exchanges->fcExchange[ x_ID ].status & PORTID_CHANGED) ||
6054 (Exchanges->fcExchange[ x_ID ].status & FRAME_TO) ||
6055 (Exchanges->fcExchange[ x_ID ].status & INV_ENTRY) ||
6056 (Exchanges->fcExchange[ x_ID ].status & ABORTSEQ_NOTIFY) )
6057
6058
6059 {
6060// printk("result DID_SOFT_ERROR, x_ID %Xh, Cmnd %p\n",
6061// x_ID, Exchanges->fcExchange[ x_ID ].Cmnd);
6062 Exchanges->fcExchange[ x_ID ].Cmnd->result = (DID_SOFT_ERROR <<16);
6063
6064
6065 }
6066
6067 // e.g., a LOGOut happened, or device never logged back in.
6068 else if( Exchanges->fcExchange[ x_ID ].status & DEVICE_REMOVED)
6069 {
6070// printk(" *LOGOut or timeout on login!* ");
6071 // trigger?
6072// TriggerHBA( fcChip->Registers.ReMapMemBase, 0);
6073
6074 Exchanges->fcExchange[ x_ID ].Cmnd->result = (DID_BAD_TARGET <<16);
6075 }
6076
6077
6078 // Did Tachyon indicate a CNT error? We need further analysis
6079 // to determine if the exchange is acceptable
6080 else if( Exchanges->fcExchange[ x_ID ].status == COUNT_ERROR)
6081 {
6082 UCHAR ScsiStatus;
6083 FCP_STATUS_RESPONSE *pFcpStatus =
6084 (PFCP_STATUS_RESPONSE)&fcChip->SEST->RspHDR[ x_ID ].pl;
6085
6086 ScsiStatus = pFcpStatus->fcp_status >>24;
6087
6088 // If the command is a SCSI Read/Write type, we don't tolerate
6089 // count errors of any kind; assume the count error is due to
6090 // a dropped frame and ask for retry...
6091
6092 if(( (Exchanges->fcExchange[ x_ID ].Cmnd->cmnd[0] == 0x8) ||
6093 (Exchanges->fcExchange[ x_ID ].Cmnd->cmnd[0] == 0x28) ||
6094 (Exchanges->fcExchange[ x_ID ].Cmnd->cmnd[0] == 0xA) ||
6095 (Exchanges->fcExchange[ x_ID ].Cmnd->cmnd[0] == 0x2A) )
6096 &&
6097 ScsiStatus == 0 )
6098 {
6099 // ask for retry
6100/* printk("COUNT_ERROR retry, x_ID %Xh, status %Xh, Cmnd %p\n",
6101 x_ID, Exchanges->fcExchange[ x_ID ].status,
6102 Exchanges->fcExchange[ x_ID ].Cmnd);*/
6103 Exchanges->fcExchange[ x_ID ].Cmnd->result = (DID_SOFT_ERROR <<16);
6104 }
6105
6106 else // need more analysis
6107 {
6108 cpqfcTSCheckandSnoopFCP(fcChip, x_ID); // (will set ->result)
6109 }
6110 }
6111
6112 // default: NOTE! We don't ever want to get here. Getting here
6113 // implies something new is happening that we've never had a test
6114 // case for. Need code maintenance! Return "ERROR"
6115 else
6116 {
6117 unsigned int stat = Exchanges->fcExchange[ x_ID ].status;
6118 printk("DEFAULT result %Xh, x_ID %Xh, Cmnd %p",
6119 Exchanges->fcExchange[ x_ID ].status, x_ID,
6120 Exchanges->fcExchange[ x_ID ].Cmnd);
6121
6122 if (stat & INVALID_ARGS) printk(" INVALID_ARGS ");
6123 if (stat & LNKDWN_OSLS) printk(" LNKDWN_OSLS ");
6124 if (stat & LNKDWN_LASER) printk(" LNKDWN_LASER ");
6125 if (stat & OUTQUE_FULL) printk(" OUTQUE_FULL ");
6126 if (stat & DRIVERQ_FULL) printk(" DRIVERQ_FULL ");
6127 if (stat & SEST_FULL) printk(" SEST_FULL ");
6128 if (stat & BAD_ALPA) printk(" BAD_ALPA ");
6129 if (stat & OVERFLOW) printk(" OVERFLOW ");
6130 if (stat & COUNT_ERROR) printk(" COUNT_ERROR ");
6131 if (stat & LINKFAIL_RX) printk(" LINKFAIL_RX ");
6132 if (stat & ABORTSEQ_NOTIFY) printk(" ABORTSEQ_NOTIFY ");
6133 if (stat & LINKFAIL_TX) printk(" LINKFAIL_TX ");
6134 if (stat & HOSTPROG_ERR) printk(" HOSTPROG_ERR ");
6135 if (stat & FRAME_TO) printk(" FRAME_TO ");
6136 if (stat & INV_ENTRY) printk(" INV_ENTRY ");
6137 if (stat & SESTPROG_ERR) printk(" SESTPROG_ERR ");
6138 if (stat & OUTBOUND_TIMEOUT) printk(" OUTBOUND_TIMEOUT ");
6139 if (stat & INITIATOR_ABORT) printk(" INITIATOR_ABORT ");
6140 if (stat & MEMPOOL_FAIL) printk(" MEMPOOL_FAIL ");
6141 if (stat & FC2_TIMEOUT) printk(" FC2_TIMEOUT ");
6142 if (stat & TARGET_ABORT) printk(" TARGET_ABORT ");
6143 if (stat & EXCHANGE_QUEUED) printk(" EXCHANGE_QUEUED ");
6144 if (stat & PORTID_CHANGED) printk(" PORTID_CHANGED ");
6145 if (stat & DEVICE_REMOVED) printk(" DEVICE_REMOVED ");
6146 if (stat & SFQ_FRAME) printk(" SFQ_FRAME ");
6147 printk("\n");
6148
6149 Exchanges->fcExchange[ x_ID ].Cmnd->result = (DID_ERROR <<16);
6150 }
6151 }
6152 else // definitely no Tach problem, but perhaps an FCP problem
6153 {
6154 // set FCP Link statistic
6155 fcChip->fcStats.ok++;
6156 cpqfcTSCheckandSnoopFCP( fcChip, x_ID); // (will set ->result)
6157 }
6158
6159 cpqfc_pci_unmap(pcidev, Exchanges->fcExchange[x_ID].Cmnd,
6160 fcChip, x_ID); // undo DMA mappings.
6161 already_unmapped = 1;
6162
6163 // OK, we've set the Scsi "->result" field, so proceed with calling
6164 // Linux Scsi "done" (if not NULL), and free any kernel memory we
6165 // may have allocated for the exchange.
6166
6167 PCI_TRACEO( (ULONG)Exchanges->fcExchange[x_ID].Cmnd, 0xAC);
6168 // complete the command back to upper Scsi drivers
6169 if( Exchanges->fcExchange[ x_ID ].Cmnd->scsi_done != NULL)
6170 {
6171 // Calling "done" on an Linux _abort() aborted
6172 // Cmnd causes a kernel panic trying to re-free mem.
6173 // Actually, we shouldn't do anything with an _abort CMND
6174 if( Exchanges->fcExchange[ x_ID ].Cmnd->result != (DID_ABORT<<16) )
6175 {
6176 PCI_TRACE(0xAC)
6177 call_scsi_done(Exchanges->fcExchange[ x_ID ].Cmnd);
6178 }
6179 else
6180 {
6181// printk(" not calling scsi_done on x_ID %Xh, Cmnd %p\n",
6182// x_ID, Exchanges->fcExchange[ x_ID ].Cmnd);
6183 }
6184 }
6185 else{
6186 printk(" x_ID %Xh, type %Xh, Cdb0 %Xh\n", x_ID,
6187 Exchanges->fcExchange[ x_ID ].type,
6188 Exchanges->fcExchange[ x_ID ].Cmnd->cmnd[0]);
6189 printk(" cpqfcTS: Null scsi_done function pointer!\n");
6190 }
6191
6192
6193 // Now, clean up non-Scsi_Cmnd items...
6194CleanUpSestResources:
6195
6196 if (!already_unmapped)
6197 cpqfc_pci_unmap(pcidev, Exchanges->fcExchange[x_ID].Cmnd,
6198 fcChip, x_ID); // undo DMA mappings.
6199
6200 // Was an Extended Scatter/Gather page allocated? We know
6201 // this by checking DWORD 4, bit 31 ("LOC") of SEST entry
6202 if( !(fcChip->SEST->u[ x_ID ].IWE.Buff_Off & 0x80000000))
6203 {
6204 PSGPAGES p, next;
6205
6206 // extended S/G list was used -- Free the allocated ext. S/G pages
6207 for (p = fcChip->SEST->sgPages[x_ID]; p != NULL; p = next) {
6208 next = p->next;
6209 kfree(p);
6210 }
6211 fcChip->SEST->sgPages[x_ID] = NULL;
6212 }
6213
6214 Exchanges->fcExchange[ x_ID ].Cmnd = NULL;
6215 } // Done with FCP (SEST) exchanges
6216
6217
6218 // the remaining logic is common to ALL Exchanges:
6219 // FCP(SEST) and LinkServ.
6220
6221 Exchanges->fcExchange[ x_ID ].type = 0; // there -- FREE!
6222 Exchanges->fcExchange[ x_ID ].status = 0;
6223
6224 PCI_TRACEO( x_ID, 0xAC)
6225
6226
6227 return;
6228} // (END of CompleteExchange function)
6229
6230
6231
6232
6233// Unfortunately, we must snoop all command completions in
6234// order to manipulate certain return fields, and take note of
6235// device types, etc., to facilitate the Fibre-Channel to SCSI
6236// "mapping".
6237// (Watch for BIG Endian confusion on some payload fields)
6238void cpqfcTSCheckandSnoopFCP( PTACHYON fcChip, ULONG x_ID)
6239{
6240 FC_EXCHANGES *Exchanges = fcChip->Exchanges;
6241 Scsi_Cmnd *Cmnd = Exchanges->fcExchange[ x_ID].Cmnd;
6242 FCP_STATUS_RESPONSE *pFcpStatus =
6243 (PFCP_STATUS_RESPONSE)&fcChip->SEST->RspHDR[ x_ID ].pl;
6244 UCHAR ScsiStatus;
6245
6246 ScsiStatus = pFcpStatus->fcp_status >>24;
6247
6248#ifdef FCP_COMPLETION_DBG
6249 printk("ScsiStatus = 0x%X\n", ScsiStatus);
6250#endif
6251
6252 // First, check FCP status
6253 if( pFcpStatus->fcp_status & FCP_RSP_LEN_VALID )
6254 {
6255 // check response code (RSP_CODE) -- most popular is bad len
6256 // 1st 4 bytes of rsp info -- only byte 3 interesting
6257 if( pFcpStatus->fcp_rsp_info & FCP_DATA_LEN_NOT_BURST_LEN )
6258 {
6259
6260 // do we EVER get here?
6261 printk("cpqfcTS: FCP data len not burst len, x_ID %Xh\n", x_ID);
6262 }
6263 }
6264
6265 // for now, go by the ScsiStatus, and manipulate certain
6266 // commands when necessary...
6267 if( ScsiStatus == 0) // SCSI status byte "good"?
6268 {
6269 Cmnd->result = 0; // everything's OK
6270
6271 if( (Cmnd->cmnd[0] == INQUIRY))
6272 {
6273 UCHAR *InquiryData = Cmnd->request_buffer;
6274 PFC_LOGGEDIN_PORT pLoggedInPort;
6275
6276 // We need to manipulate INQUIRY
6277 // strings for COMPAQ RAID controllers to force
6278 // Linux to scan additional LUNs. Namely, set
6279 // the Inquiry string byte 2 (ANSI-approved version)
6280 // to 2.
6281
6282 if( !memcmp( &InquiryData[8], "COMPAQ", 6 ))
6283 {
6284 InquiryData[2] = 0x2; // claim SCSI-2 compliance,
6285 // so multiple LUNs may be scanned.
6286 // (no SCSI-2 problems known in CPQ)
6287 }
6288
6289 // snoop the Inquiry to detect Disk, Tape, etc. type
6290 // (search linked list for the port_id we sent INQUIRY to)
6291 pLoggedInPort = fcFindLoggedInPort( fcChip,
6292 NULL, // DON'T search Scsi Nexus (we will set it)
6293 Exchanges->fcExchange[ x_ID].fchs.d_id & 0xFFFFFF,
6294 NULL, // DON'T search linked list for FC WWN
6295 NULL); // DON'T care about end of list
6296
6297 if( pLoggedInPort )
6298 {
6299 pLoggedInPort->ScsiNexus.InqDeviceType = InquiryData[0];
6300 }
6301 else
6302 {
6303 printk("cpqfcTS: can't find LoggedIn FC port %06X for INQUIRY\n",
6304 Exchanges->fcExchange[ x_ID].fchs.d_id & 0xFFFFFF);
6305 }
6306 }
6307 }
6308
6309
6310 // Scsi Status not good -- pass it back to caller
6311
6312 else
6313 {
6314 Cmnd->result = ScsiStatus; // SCSI status byte is 1st
6315
6316 // check for valid "sense" data
6317
6318 if( pFcpStatus->fcp_status & FCP_SNS_LEN_VALID )
6319 { // limit Scsi Sense field length!
6320 int SenseLen = pFcpStatus->fcp_sns_len >>24; // (BigEndian) lower byte
6321
6322 SenseLen = SenseLen > sizeof( Cmnd->sense_buffer) ?
6323 sizeof( Cmnd->sense_buffer) : SenseLen;
6324
6325
6326#ifdef FCP_COMPLETION_DBG
6327 printk("copy sense_buffer %p, len %d, result %Xh\n",
6328 Cmnd->sense_buffer, SenseLen, Cmnd->result);
6329#endif
6330
6331 // NOTE: There is some dispute over the FCP response
6332 // format. Most FC devices assume that FCP_RSP_INFO
6333 // is 8 bytes long, in spite of the fact that FCP_RSP_LEN
6334 // is (virtually) always 0 and the field is "invalid".
6335 // Some other devices assume that
6336 // the FCP_SNS_INFO begins after FCP_RSP_LEN bytes (i.e. 0)
6337 // when the FCP_RSP is invalid (this almost appears to be
6338 // one of those "religious" issues).
6339 // Consequently, we test the usual position of FCP_SNS_INFO
6340 // for 7Xh, since the SCSI sense format says the first
6341 // byte ("error code") should be 0x70 or 0x71. In practice,
6342 // we find that every device does in fact have 0x70 or 0x71
6343 // in the first byte position, so this test works for all
6344 // FC devices.
6345 // (This logic is especially effective for the CPQ/DEC HSG80
6346 // & HSG60 controllers).
6347
6348 if( (pFcpStatus->fcp_sns_info[0] & 0x70) == 0x70 )
6349 memcpy( Cmnd->sense_buffer,
6350 &pFcpStatus->fcp_sns_info[0], SenseLen);
6351 else
6352 {
6353 unsigned char *sbPtr =
6354 (unsigned char *)&pFcpStatus->fcp_sns_info[0];
6355 sbPtr -= 8; // back up 8 bytes hoping to find the
6356 // start of the sense buffer
6357 memcpy( Cmnd->sense_buffer, sbPtr, SenseLen);
6358 }
6359
6360 // in the special case of Device Reset, tell upper layer
6361 // to immediately retry (with SOFT_ERROR status)
6362 // look for Sense Key Unit Attention (0x6) with ASC Device
6363 // Reset (0x29)
6364 // printk("SenseLen %d, Key = 0x%X, ASC = 0x%X\n",
6365 // SenseLen, Cmnd->sense_buffer[2],
6366 // Cmnd->sense_buffer[12]);
6367 if( ((Cmnd->sense_buffer[2] & 0xF) == 0x6) &&
6368 (Cmnd->sense_buffer[12] == 0x29) ) // Sense Code "reset"
6369 {
6370 Cmnd->result |= (DID_SOFT_ERROR << 16); // "Host" status byte 3rd
6371 }
6372
6373 // check for SenseKey "HARDWARE ERROR", ASC InternalTargetFailure
6374 else if( ((Cmnd->sense_buffer[2] & 0xF) == 0x4) && // "hardware error"
6375 (Cmnd->sense_buffer[12] == 0x44) ) // Addtl. Sense Code
6376 {
6377// printk("HARDWARE_ERROR, Channel/Target/Lun %d/%d/%d\n",
6378// Cmnd->channel, Cmnd->target, Cmnd->lun);
6379 Cmnd->result |= (DID_ERROR << 16); // "Host" status byte 3rd
6380 }
6381
6382 } // (end of sense len valid)
6383
6384 // there is no sense data to help out Linux's Scsi layers...
6385 // We'll just return the Scsi status and hope he will "do the
6386 // right thing"
6387 else
6388 {
6389 // as far as we know, the Scsi status is sufficient
6390 Cmnd->result |= (DID_OK << 16); // "Host" status byte 3rd
6391 }
6392 }
6393}
6394
6395
6396
6397//PPPPPPPPPPPPPPPPPPPPPPPPP PAYLOAD PPPPPPPPP
6398// build data PAYLOAD; SCSI FCP_CMND I.U.
6399// remember BIG ENDIAN payload - DWord values must be byte-reversed
6400// (hence the affinity for byte pointer building).
6401
6402static int build_FCP_payload( Scsi_Cmnd *Cmnd,
6403 UCHAR* payload, ULONG type, ULONG fcp_dl )
6404{
6405 int i;
6406
6407
6408 switch( type)
6409 {
6410
6411 case SCSI_IWE:
6412 case SCSI_IRE:
6413 // 8 bytes FCP_LUN
6414 // Peripheral Device or Volume Set addressing, and LUN mapping
6415 // When the FC port was looked up, we copied address mode
6416 // and any LUN mask to the scratch pad SCp.phase & .mode
6417
6418 *payload++ = (UCHAR)Cmnd->SCp.phase;
6419
6420 // Now, because of "lun masking"
6421 // (aka selective storage presentation),
6422 // the contiguous Linux Scsi lun number may not match the
6423 // device's lun number, so we may have to "map".
6424
6425 *payload++ = (UCHAR)Cmnd->SCp.have_data_in;
6426
6427 // We don't know of anyone in the FC business using these
6428 // extra "levels" of addressing. In fact, confusion still exists
6429 // just using the FIRST level... ;-)
6430
6431 *payload++ = 0; // 2nd level addressing
6432 *payload++ = 0;
6433 *payload++ = 0; // 3rd level addressing
6434 *payload++ = 0;
6435 *payload++ = 0; // 4th level addressing
6436 *payload++ = 0;
6437
6438 // 4 bytes Control Field FCP_CNTL
6439 *payload++ = 0; // byte 0: (MSB) reserved
6440 *payload++ = 0; // byte 1: task codes
6441
6442 // byte 2: task management flags
6443 // another "use" of the spare field to accomplish TDR
6444 // note combination needed
6445 if( (Cmnd->cmnd[0] == RELEASE) &&
6446 (Cmnd->SCp.buffers_residual == FCP_TARGET_RESET) )
6447 {
6448 Cmnd->cmnd[0] = 0; // issue "Test Unit Ready" for TDR
6449 *payload++ = 0x20; // target device reset bit
6450 }
6451 else
6452 *payload++ = 0; // no TDR
6453 // byte 3: (LSB) execution management codes
6454 // bit 0 write, bit 1 read (don't set together)
6455
6456 if( fcp_dl != 0 )
6457 {
6458 if( type == SCSI_IWE ) // WRITE
6459 *payload++ = 1;
6460 else // READ
6461 *payload++ = 2;
6462 }
6463 else
6464 {
6465 // On some devices, if RD or WR bits are set,
6466 // and fcp_dl is 0, they will generate an error on the command.
6467 // (i.e., if direction is specified, they insist on a length).
6468 *payload++ = 0; // no data (necessary for CPQ)
6469 }
6470
6471
6472 // NOTE: clean this up if/when MAX_COMMAND_SIZE is increased to 16
6473 // FCP_CDB allows 16 byte SCSI command descriptor blk;
6474 // Linux SCSI CDB array is MAX_COMMAND_SIZE (12 at this time...)
6475 for( i=0; (i < Cmnd->cmd_len) && i < MAX_COMMAND_SIZE; i++)
6476 *payload++ = Cmnd->cmnd[i];
6477
6478 // if( Cmnd->cmd_len == 16 )
6479 // {
6480 // memcpy( payload, &Cmnd->SCp.buffers_residual, 4);
6481 // }
6482 payload+= (16 - i);
6483
6484 // FCP_DL is largest number of expected data bytes
6485 // per CDB (i.e. read/write command)
6486 *payload++ = (UCHAR)(fcp_dl >>24); // (MSB) 8 bytes data len FCP_DL
6487 *payload++ = (UCHAR)(fcp_dl >>16);
6488 *payload++ = (UCHAR)(fcp_dl >>8);
6489 *payload++ = (UCHAR)fcp_dl; // (LSB)
6490 break;
6491
6492 case SCSI_TWE: // need FCP_XFER_RDY
6493 *payload++ = 0; // (4 bytes) DATA_RO (MSB byte 0)
6494 *payload++ = 0;
6495 *payload++ = 0;
6496 *payload++ = 0; // LSB (byte 3)
6497 // (4 bytes) BURST_LEN
6498 // size of following FCP_DATA payload
6499 *payload++ = (UCHAR)(fcp_dl >>24); // (MSB) 8 bytes data len FCP_DL
6500 *payload++ = (UCHAR)(fcp_dl >>16);
6501 *payload++ = (UCHAR)(fcp_dl >>8);
6502 *payload++ = (UCHAR)fcp_dl; // (LSB)
6503 // 4 bytes RESERVED
6504 *payload++ = 0;
6505 *payload++ = 0;
6506 *payload++ = 0;
6507 *payload++ = 0;
6508 break;
6509
6510 default:
6511 break;
6512 }
6513
6514 return 0;
6515}
6516
generated by cgit v1.2.2 (git 2.25.0) at 2024-12-11 18:46:18 -0500