开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
cpqfcTSinit.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：60k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

cpqfcTSinit.c：源码内容
  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.  * IOCTL and procfs added by Jouke Numan
  21.  * SMP testing by Chel Van Gennip
  22.  *
  23.  * portions copied from:
  24.  * QLogic CPQFCTS SCSI-FCP
  25.  * Written by Erik H. Moe, ehm@cris.com
  26.  * Copyright 1995, Erik H. Moe
  27.  * Renamed and updated to 1.3.x by Michael Griffith <grif@cs.ucr.edu> 
  28.  * Chris Loveland <cwl@iol.unh.edu> to support the isp2100 and isp2200
  29. */
  32. #define LinuxVersionCode(v, p, s) (((v)<<16)+((p)<<8)+(s))
  34. #include <linux/blk.h>
  35. #include <linux/kernel.h>
  36. #include <linux/string.h>
  37. #include <linux/sched.h>
  38. #include <linux/types.h>
  39. #include <linux/pci.h>
  40. #include <linux/delay.h>
  41. #include <linux/timer.h>
  42. #include <linux/ioport.h>  // request_region() prototype
  43. #include <linux/vmalloc.h> // ioremap()
  44. #if LINUX_VERSION_CODE >= LinuxVersionCode(2,4,7)
  45. #include <linux/completion.h>
  46. #endif
  47. #ifdef __alpha__
  48. #define __KERNEL_SYSCALLS__
  49. #endif
  50. #include <asm/unistd.h>
  51. #include <asm/io.h>
  52. #include <asm/uaccess.h>   // ioctl related
  53. #include <asm/irq.h>
  54. #include <linux/spinlock.h>
  55. #include "sd.h"
  56. #include <scsi/scsi_ioctl.h>
  57. #include "hosts.h"
  58. #include "cpqfcTSchip.h"
  59. #include "cpqfcTSstructs.h"
  60. #include "cpqfcTStrigger.h"
  62. #include "cpqfcTS.h"
  64. #include <linux/config.h>  
  65. #include <linux/module.h>
  66. #include <linux/version.h> 
  68. /* Embedded module documentation macros - see module.h */
  69. MODULE_AUTHOR("Compaq Computer Corporation");
  70. MODULE_DESCRIPTION("Driver for Compaq 64-bit/66Mhz PCI Fibre Channel HBA v. 2.1.1");
  71. MODULE_LICENSE("GPL");
  72.   
  73. int cpqfcTS_TargetDeviceReset( Scsi_Device *ScsiDev, unsigned int reset_flags);
  75. // This struct was originally defined in 
  76. // /usr/src/linux/include/linux/proc_fs.h
  77. // since it's only partially implemented, we only use first
  78. // few fields...
  79. // NOTE: proc_fs changes in 2.4 kernel
  81. #if LINUX_VERSION_CODE < LinuxVersionCode(2,3,27)
  82. static struct proc_dir_entry proc_scsi_cpqfcTS =
  83. {
  84.   PROC_SCSI_CPQFCTS,           // ushort low_ino (enumerated list)
  85.   7,                           // ushort namelen
  86.   DEV_NAME,                    // const char* name
  87.   S_IFDIR | S_IRUGO | S_IXUGO, // mode_t mode
  88.   2                            // nlink_t nlink
  89.                        // etc. ...
  90. };
  93. #endif
  95. #if LINUX_VERSION_CODE >= LinuxVersionCode(2,4,7)
  96. #  define CPQFC_DECLARE_COMPLETION(x) DECLARE_COMPLETION(x)
  97. #  define CPQFC_WAITING waiting
  98. #  define CPQFC_COMPLETE(x) complete(x)
  99. #  define CPQFC_WAIT_FOR_COMPLETION(x) wait_for_completion(x);
  100. #else
  101. #  define CPQFC_DECLARE_COMPLETION(x) DECLARE_MUTEX_LOCKED(x)
  102. #  define CPQFC_WAITING sem
  103. #  define CPQFC_COMPLETE(x) up(x)
  104. #  define CPQFC_WAIT_FOR_COMPLETION(x) down(x)
  105. #endif
  107. /* local function to load our per-HBA (local) data for chip
  108.    registers, FC link state, all FC exchanges, etc.
  110.    We allocate space and compute address offsets for the
  111.    most frequently accessed addresses; others (like World Wide
  112.    Name) are not necessary.
  113.    
  114. */
  115. static void Cpqfc_initHBAdata( CPQFCHBA *cpqfcHBAdata, struct pci_dev *PciDev )
  116. {
  117.              
  118.   cpqfcHBAdata->PciDev = PciDev; // copy PCI info ptr
  120.   // since x86 port space is 64k, we only need the lower 16 bits
  121.   cpqfcHBAdata->fcChip.Registers.IOBaseL = 
  122.     PciDev->resource[1].start & PCI_BASE_ADDRESS_IO_MASK;
  123.   
  124.   cpqfcHBAdata->fcChip.Registers.IOBaseU = 
  125.     PciDev->resource[2].start & PCI_BASE_ADDRESS_IO_MASK;
  126.   
  127.   // 32-bit memory addresses
  128.   cpqfcHBAdata->fcChip.Registers.MemBase = 
  129.     PciDev->resource[3].start & PCI_BASE_ADDRESS_MEM_MASK;
  131.   cpqfcHBAdata->fcChip.Registers.ReMapMemBase = 
  132.     ioremap( PciDev->resource[3].start & PCI_BASE_ADDRESS_MEM_MASK,
  133.              0x200);
  134.   
  135.   cpqfcHBAdata->fcChip.Registers.RAMBase = 
  136.     PciDev->resource[4].start;
  137.   
  138.   cpqfcHBAdata->fcChip.Registers.SROMBase =  // NULL for HP TS adapter
  139.     PciDev->resource[5].start;
  140.   
  141.   // now the Tachlite chip registers
  142.   // the REGISTER struct holds both the physical address & last
  143.   // written value (some TL registers are WRITE ONLY)
  145.   cpqfcHBAdata->fcChip.Registers.SFQconsumerIndex.address = 
  146.         cpqfcHBAdata->fcChip.Registers.ReMapMemBase + TL_MEM_SFQ_CONSUMER_INDEX;
  148.   cpqfcHBAdata->fcChip.Registers.ERQproducerIndex.address = 
  149.         cpqfcHBAdata->fcChip.Registers.ReMapMemBase + TL_MEM_ERQ_PRODUCER_INDEX;
  150.       
  151.   // TL Frame Manager
  152.   cpqfcHBAdata->fcChip.Registers.FMconfig.address = 
  153.         cpqfcHBAdata->fcChip.Registers.ReMapMemBase + TL_MEM_FM_CONFIG;
  154.   cpqfcHBAdata->fcChip.Registers.FMcontrol.address = 
  155.         cpqfcHBAdata->fcChip.Registers.ReMapMemBase + TL_MEM_FM_CONTROL;
  156.   cpqfcHBAdata->fcChip.Registers.FMstatus.address = 
  157.         cpqfcHBAdata->fcChip.Registers.ReMapMemBase + TL_MEM_FM_STATUS;
  158.   cpqfcHBAdata->fcChip.Registers.FMLinkStatus1.address = 
  159.         cpqfcHBAdata->fcChip.Registers.ReMapMemBase + TL_MEM_FM_LINK_STAT1;
  160.   cpqfcHBAdata->fcChip.Registers.FMLinkStatus2.address = 
  161.         cpqfcHBAdata->fcChip.Registers.ReMapMemBase + TL_MEM_FM_LINK_STAT2;
  162.   cpqfcHBAdata->fcChip.Registers.FMBB_CreditZero.address = 
  163.         cpqfcHBAdata->fcChip.Registers.ReMapMemBase + TL_MEM_FM_BB_CREDIT0;
  164.       
  165.       // TL Control Regs
  166.   cpqfcHBAdata->fcChip.Registers.TYconfig.address = 
  167.         cpqfcHBAdata->fcChip.Registers.ReMapMemBase + TL_MEM_TACH_CONFIG;
  168.   cpqfcHBAdata->fcChip.Registers.TYcontrol.address = 
  169.         cpqfcHBAdata->fcChip.Registers.ReMapMemBase + TL_MEM_TACH_CONTROL;
  170.   cpqfcHBAdata->fcChip.Registers.TYstatus.address = 
  171.         cpqfcHBAdata->fcChip.Registers.ReMapMemBase + TL_MEM_TACH_STATUS;
  172.   cpqfcHBAdata->fcChip.Registers.rcv_al_pa.address = 
  173.         cpqfcHBAdata->fcChip.Registers.ReMapMemBase + TL_MEM_FM_RCV_AL_PA;
  174.   cpqfcHBAdata->fcChip.Registers.ed_tov.address = 
  175.         cpqfcHBAdata->fcChip.Registers.ReMapMemBase + TL_MEM_FM_ED_TOV;
  178.   cpqfcHBAdata->fcChip.Registers.INTEN.address = 
  179.         cpqfcHBAdata->fcChip.Registers.ReMapMemBase + IINTEN;
  180.   cpqfcHBAdata->fcChip.Registers.INTPEND.address = 
  181.         cpqfcHBAdata->fcChip.Registers.ReMapMemBase + IINTPEND;
  182.   cpqfcHBAdata->fcChip.Registers.INTSTAT.address = 
  183.         cpqfcHBAdata->fcChip.Registers.ReMapMemBase + IINTSTAT;
  185.   DEBUG_PCI(printk("  cpqfcHBAdata->fcChip.Registers. :n"));
  186.   DEBUG_PCI(printk("    IOBaseL = %xn", 
  187.     cpqfcHBAdata->fcChip.Registers.IOBaseL));
  188.   DEBUG_PCI(printk("    IOBaseU = %xn", 
  189.     cpqfcHBAdata->fcChip.Registers.IOBaseU));
  190.   
  191.   printk(" ioremap'd Membase: %pn", cpqfcHBAdata->fcChip.Registers.ReMapMemBase);
  192.   
  193.   DEBUG_PCI(printk("    SFQconsumerIndex.address = %pn", 
  194.     cpqfcHBAdata->fcChip.Registers.SFQconsumerIndex.address));
  195.   DEBUG_PCI(printk("    ERQproducerIndex.address = %pn", 
  196.     cpqfcHBAdata->fcChip.Registers.ERQproducerIndex.address));
  197.   DEBUG_PCI(printk("    TYconfig.address = %pn", 
  198.     cpqfcHBAdata->fcChip.Registers.TYconfig.address));
  199.   DEBUG_PCI(printk("    FMconfig.address = %pn", 
  200.     cpqfcHBAdata->fcChip.Registers.FMconfig.address));
  201.   DEBUG_PCI(printk("    FMcontrol.address = %pn", 
  202.     cpqfcHBAdata->fcChip.Registers.FMcontrol.address));
  204.   // set default options for FC controller (chip)
  205.   cpqfcHBAdata->fcChip.Options.initiator = 1;  // default: SCSI initiator
  206.   cpqfcHBAdata->fcChip.Options.target = 0;     // default: SCSI target
  207.   cpqfcHBAdata->fcChip.Options.extLoopback = 0;// default: no loopback @GBIC
  208.   cpqfcHBAdata->fcChip.Options.intLoopback = 0;// default: no loopback inside chip
  210.   // set highest and lowest FC-PH version the adapter/driver supports
  211.   // (NOT strict compliance)
  212.   cpqfcHBAdata->fcChip.highest_FCPH_ver = FC_PH3;
  213.   cpqfcHBAdata->fcChip.lowest_FCPH_ver = FC_PH43;
  215.   // set function points for this controller / adapter
  216.   cpqfcHBAdata->fcChip.ResetTachyon = CpqTsResetTachLite;
  217.   cpqfcHBAdata->fcChip.FreezeTachyon = CpqTsFreezeTachlite;
  218.   cpqfcHBAdata->fcChip.UnFreezeTachyon = CpqTsUnFreezeTachlite;
  219.   cpqfcHBAdata->fcChip.CreateTachyonQues = CpqTsCreateTachLiteQues;
  220.   cpqfcHBAdata->fcChip.DestroyTachyonQues = CpqTsDestroyTachLiteQues;
  221.   cpqfcHBAdata->fcChip.InitializeTachyon = CpqTsInitializeTachLite;  
  222.   cpqfcHBAdata->fcChip.LaserControl = CpqTsLaserControl;  
  223.   cpqfcHBAdata->fcChip.ProcessIMQEntry = CpqTsProcessIMQEntry;
  224.   cpqfcHBAdata->fcChip.InitializeFrameManager = CpqTsInitializeFrameManager;;  
  225.   cpqfcHBAdata->fcChip.ReadWriteWWN = CpqTsReadWriteWWN;
  226.   cpqfcHBAdata->fcChip.ReadWriteNVRAM = CpqTsReadWriteNVRAM;
  228.  
  230. }
  233. /* (borrowed from linux/drivers/scsi/hosts.c) */
  234. static void launch_FCworker_thread(struct Scsi_Host *HostAdapter)
  235. {
  236.   DECLARE_MUTEX_LOCKED(sem);
  238.   CPQFCHBA *cpqfcHBAdata = (CPQFCHBA *)HostAdapter->hostdata;
  240.   ENTER("launch_FC_worker_thread");
  241.              
  242.   cpqfcHBAdata->notify_wt = &sem;
  244.   /* must unlock before kernel_thread(), for it may cause a reschedule. */
  245.   spin_unlock_irq(&io_request_lock);
  246.   kernel_thread((int (*)(void *))cpqfcTSWorkerThread, 
  247.                           (void *) HostAdapter, 0);
  248.   /*
  249.    * Now wait for the kernel error thread to initialize itself
  251.    */
  252.   down (&sem);
  253.   spin_lock_irq(&io_request_lock);
  254.   cpqfcHBAdata->notify_wt = NULL;
  256.   LEAVE("launch_FC_worker_thread");
  257.  
  258. }
  261. /* "Entry" point to discover if any supported PCI 
  262.    bus adapter can be found
  263. */
  264. // We're supporting:
  265. // Compaq 64-bit, 66MHz HBA with Tachyon TS
  266. // Agilent XL2 
  267. #define HBA_TYPES 2
  270. int cpqfcTS_detect(Scsi_Host_Template *ScsiHostTemplate)
  271. {
  272.   int NumberOfAdapters=0; // how many of our PCI adapters are found?
  273.   struct pci_dev *PciDev = NULL;
  274.   struct Scsi_Host *HostAdapter = NULL;
  275.   CPQFCHBA *cpqfcHBAdata = NULL; 
  276.   struct timer_list *cpqfcTStimer = NULL;
  277.   SupportedPCIcards PCIids[HBA_TYPES];
  278.   int i;
  279.   
  280.   ENTER("cpqfcTS_detect");
  281.   
  282. #if LINUX_VERSION_CODE < LinuxVersionCode(2,3,27)
  283.   ScsiHostTemplate->proc_dir = &proc_scsi_cpqfcTS;
  284. #else
  285.   ScsiHostTemplate->proc_name = "cpqfcTS";
  286. #endif
  287.   
  288.   if( pci_present() == 0) // no PCI busses?
  289.   {
  290.     printk( "  no PCI bus?@#!n");
  291.     return NumberOfAdapters;
  292.   }
  294.   // what HBA adapters are we supporting?
  295.   PCIids[0].vendor_id = PCI_VENDOR_ID_COMPAQ;
  296.   PCIids[0].device_id = CPQ_DEVICE_ID;
  297.   PCIids[1].vendor_id = PCI_VENDOR_ID_HP; // i.e. 103Ch (Agilent == HP for now)
  298.   PCIids[1].device_id = AGILENT_XL2_ID;   // i.e. 1029h
  300.   for( i=0; i < HBA_TYPES; i++)
  301.   {
  302.     // look for all HBAs of each type
  304.     while( (PciDev =
  305.       pci_find_device( PCIids[i].vendor_id, PCIids[i].device_id, PciDev) ))
  306.     {
  308.       if (pci_set_dma_mask(PciDev, CPQFCTS_DMA_MASK) != 0) {
  309. printk(KERN_WARNING 
  310. "cpqfc: HBA cannot support required DMA mask, skipping.n");
  311. continue;
  312.       }
  314.       // NOTE: (kernel 2.2.12-32) limits allocation to 128k bytes...
  315.       printk(" scsi_register allocating %d bytes for FC HBAn",
  316.       (ULONG)sizeof(CPQFCHBA));
  318.       HostAdapter = scsi_register( ScsiHostTemplate, sizeof( CPQFCHBA ) );
  319.       
  320.       if(HostAdapter == NULL)
  321.        continue;
  322.       DEBUG_PCI( printk("  HBA found!n"));
  323.       DEBUG_PCI( printk("  HostAdapter->PciDev->irq = %un", PciDev->irq) );
  324.       DEBUG_PCI(printk("  PciDev->baseaddress[0]= %lxn", 
  325. PciDev->resource[0].start));
  326.       DEBUG_PCI(printk("  PciDev->baseaddress[1]= %lxn", 
  327. PciDev->resource[1].start));
  328.       DEBUG_PCI(printk("  PciDev->baseaddress[2]= %lxn", 
  329. PciDev->resource[2].start));
  330.       DEBUG_PCI(printk("  PciDev->baseaddress[3]= %lxn", 
  331. PciDev->resource[3].start));
  333.       scsi_set_pci_device(HostAdapter, PciDev);      
  334.       HostAdapter->irq = PciDev->irq;  // copy for Scsi layers
  335.       
  336.       // HP Tachlite uses two (255-byte) ranges of Port I/O (lower & upper),
  337.       // for a total I/O port address space of 512 bytes.
  338.       // mask out the I/O port address (lower) & record
  339.       HostAdapter->io_port = (unsigned int)
  340.      PciDev->resource[1].start & PCI_BASE_ADDRESS_IO_MASK;
  341.       HostAdapter->n_io_port = 0xff;
  342.       
  343.       // i.e., expect 128 targets (arbitrary number), while the
  344.       //  RA-4000 supports 32 LUNs
  345.       HostAdapter->max_id =  0;   // incremented as devices log in    
  346.       HostAdapter->max_lun = CPQFCTS_MAX_LUN;         // LUNs per FC device
  347.       HostAdapter->max_channel = CPQFCTS_MAX_CHANNEL; // multiple busses?
  348.       
  349.       // get the pointer to our HBA specific data... (one for
  350.       // each HBA on the PCI bus(ses)).
  351.       cpqfcHBAdata = (CPQFCHBA *)HostAdapter->hostdata;
  352.       
  353.       // make certain our data struct is clear
  354.       memset( cpqfcHBAdata, 0, sizeof( CPQFCHBA ) );
  357.       // initialize our HBA info
  358.       cpqfcHBAdata->HBAnum = NumberOfAdapters;
  360.       cpqfcHBAdata->HostAdapter = HostAdapter; // back ptr
  361.       Cpqfc_initHBAdata( cpqfcHBAdata, PciDev ); // fill MOST fields
  362.      
  363.       cpqfcHBAdata->HBAnum = NumberOfAdapters;
  364.       cpqfcHBAdata->hba_spinlock = SPIN_LOCK_UNLOCKED;
  366.       // request necessary resources and check for conflicts
  367.       if( request_irq( HostAdapter->irq,
  368.        cpqfcTS_intr_handler,
  369.                SA_INTERRUPT | SA_SHIRQ,
  370.                DEV_NAME,
  371.        HostAdapter) )
  372.       {
  373. printk(" IRQ %u already usedn", HostAdapter->irq);
  374.         scsi_unregister( HostAdapter);
  375. continue;
  376.       }
  378.       // Since we have two 256-byte I/O port ranges (upper
  379.       // and lower), check them both
  380.       if( check_region( cpqfcHBAdata->fcChip.Registers.IOBaseU, 0xff) )
  381.       {
  382. printk("  cpqfcTS address in use: %xn", 
  383. cpqfcHBAdata->fcChip.Registers.IOBaseU);
  384. free_irq( HostAdapter->irq, HostAdapter);
  385.         scsi_unregister( HostAdapter);
  386. continue;
  387.       }
  388.       
  389.       if( check_region( cpqfcHBAdata->fcChip.Registers.IOBaseL, 0xff) )
  390.       {
  391.    printk("  cpqfcTS address in use: %xn", 
  392.        cpqfcHBAdata->fcChip.Registers.IOBaseL);
  393. free_irq( HostAdapter->irq, HostAdapter);
  394.         scsi_unregister( HostAdapter);
  395. continue;
  396.       }
  397.       
  398.       // OK, we should be able to grab everything we need now.
  399.       request_region( cpqfcHBAdata->fcChip.Registers.IOBaseL, 0xff, DEV_NAME);
  400.       request_region( cpqfcHBAdata->fcChip.Registers.IOBaseU, 0xff, DEV_NAME);
  401.       DEBUG_PCI(printk("  Requesting 255 I/O addresses @ %xn",
  402.         cpqfcHBAdata->fcChip.Registers.IOBaseL ));
  403.       DEBUG_PCI(printk("  Requesting 255 I/O addresses @ %xn",
  404.         cpqfcHBAdata->fcChip.Registers.IOBaseU ));
  406.       
  407.       // start our kernel worker thread
  409.       launch_FCworker_thread(HostAdapter);
  412.       // start our TimerTask...
  414.       cpqfcTStimer = &cpqfcHBAdata->cpqfcTStimer;
  416.       init_timer( cpqfcTStimer); // Linux clears next/prev values
  417.       cpqfcTStimer->expires = jiffies + HZ; // one second
  418.       cpqfcTStimer->data = (unsigned long)cpqfcHBAdata; // this adapter
  419.       cpqfcTStimer->function = cpqfcTSheartbeat; // handles timeouts, housekeeping
  421.       add_timer( cpqfcTStimer);  // give it to Linux
  424.       // now initialize our hardware...
  425.       if (cpqfcHBAdata->fcChip.InitializeTachyon( cpqfcHBAdata, 1,1)) {
  426. printk(KERN_WARNING "cpqfc: initialization of HBA hardware failed.n");
  427. // FIXME: might want to do something better than nothing here.
  428.       }
  430.       cpqfcHBAdata->fcStatsTime = jiffies;  // (for FC Statistics delta)
  431.       
  432.       // give our HBA time to initialize and login current devices...
  433.       {
  434. // The Brocade switch (e.g. 2400, 2010, etc.) as of March 2000,
  435. // has the following algorithm for FL_Port startup:
  436. // Time(sec) Action
  437. // 0:        Device Plugin and LIP(F7,F7) transmission
  438. // 1.0       LIP incoming
  439.         // 1.027     LISA incoming, no CLS! (link not up)
  440. // 1.028     NOS incoming (switch test for N_Port)
  441.         // 1.577     ED_TOV expired, transmit LIPs again
  442. // 3.0       LIP(F8,F7) incoming (switch passes Tach Prim.Sig)
  443. // 3.028     LILP received, link up, FLOGI starts
  444. // slowest(worst) case, measured on 1Gb Finisar GT analyzer
  446. unsigned long stop_time;
  448.         spin_unlock_irq(&io_request_lock);
  449. stop_time = jiffies + 4*HZ;
  450.         while ( time_before(jiffies, stop_time) ) 
  451.    schedule();  // (our worker task needs to run)
  453. spin_lock_irq(&io_request_lock);
  454.       }
  455.       
  456.       NumberOfAdapters++; 
  457.     } // end of while()
  458.   }
  460.   LEAVE("cpqfcTS_detect");
  461.  
  462.   return NumberOfAdapters;
  463. }
  465. static void my_ioctl_done (Scsi_Cmnd * SCpnt)
  466. {
  467.     struct request * req;
  468.     
  469.     req = &SCpnt->request;
  470.     req->rq_status = RQ_SCSI_DONE; /* Busy, but indicate request done */
  471.   
  472.     if (req->CPQFC_WAITING != NULL)
  473. CPQFC_COMPLETE(req->CPQFC_WAITING);
  474. }   
  478. int cpqfcTS_ioctl( Scsi_Device *ScsiDev, int Cmnd, void *arg)
  479. {
  480.   int result = 0;
  481.   struct Scsi_Host *HostAdapter = ScsiDev->host;
  482.   CPQFCHBA *cpqfcHBAdata = (CPQFCHBA *)HostAdapter->hostdata;
  483.   PTACHYON fcChip = &cpqfcHBAdata->fcChip;
  484.   PFC_LOGGEDIN_PORT pLoggedInPort;
  485.   Scsi_Cmnd DumCmnd;
  486.   int i, j;
  487.   VENDOR_IOCTL_REQ ioc;
  488.   cpqfc_passthru_t *vendor_cmd;
  489.   Scsi_Device *SDpnt;
  490.   Scsi_Cmnd *ScsiPassThruCmnd;
  492.   ENTER("cpqfcTS_ioctl ");
  493.   
  494.   // can we find an FC device mapping to this SCSI target?
  495.   DumCmnd.channel = ScsiDev->channel; // For searching
  496.   DumCmnd.target  = ScsiDev->id;
  497.   pLoggedInPort = fcFindLoggedInPort( fcChip,
  498.     &DumCmnd, // search Scsi Nexus
  499.     0,        // DON'T search linked list for FC port id
  500.     NULL,     // DON'T search linked list for FC WWN
  501.     NULL);    // DON'T care about end of list
  502.  
  503.   if( pLoggedInPort == NULL )      // not found!
  504.   {
  505.     result = -ENXIO;
  506.   }
  507.  
  508.   else  // we know what FC device to operate on...
  509.   {
  510. // printk("ioctl CMND %d", Cmnd);
  511.     switch (Cmnd) 
  512.     {
  513.       // Passthrough provides a mechanism to bypass the RAID
  514.       // or other controller and talk directly to the devices
  515.       // (e.g. physical disk drive)
  516.       // Passthrough commands, unfortunately, tend to be vendor
  517.       // specific; this is tailored to COMPAQ's RAID (RA4x00)
  518.       case CPQFCTS_SCSI_PASSTHRU:
  519.       {
  520. void *buf = NULL; // for kernel space buffer for user data
  522. if( !arg)
  523.   return -EINVAL;
  525. // must be super user to send stuff directly to the
  526. // controller and/or physical drives...
  527. if( !suser() )
  528.   return -EPERM;
  530. // copy the caller's struct to our space.
  531.         if( copy_from_user( &ioc, arg, sizeof( VENDOR_IOCTL_REQ)))
  532. return( -EFAULT);
  534. vendor_cmd = ioc.argp;  // i.e., CPQ specific command struct
  536. // If necessary, grab a kernel/DMA buffer
  537. if( vendor_cmd->len)
  538. {
  539.      buf = kmalloc( vendor_cmd->len, GFP_KERNEL);
  540.   if( !buf)
  541.     return -ENOMEM;
  542. }
  544.         // Now build a SCSI_CMND to pass down...
  545. // This function allocates and sets Scsi_Cmnd ptrs such as
  546. //  ->channel, ->target, ->host
  547.         ScsiPassThruCmnd = scsi_allocate_device(ScsiDev, 1, 1);
  549.         // Need data from user?
  550. // make sure caller's buffer is in kernel space.
  551. if( (vendor_cmd->rw_flag == VENDOR_WRITE_OPCODE) &&
  552.     vendor_cmd->len)
  553.         if(  copy_from_user( buf, vendor_cmd->bufp, vendor_cmd->len))
  554. return( -EFAULT);
  555.     
  556. // copy the CDB (if/when MAX_COMMAND_SIZE is 16, remove copy below)
  557.         memcpy( &ScsiPassThruCmnd->cmnd[0], 
  558. &vendor_cmd->cdb[0], 
  559. MAX_COMMAND_SIZE);  
  560.         // we want to copy all 16 bytes into the FCP-SCSI CDB,
  561. // although the actual passthru only uses up to the
  562. // first 12.
  564. ScsiPassThruCmnd->cmd_len = 16; // sizeof FCP-SCSI CDB
  566. // Unfortunately, the SCSI command cmnd[] field has only
  567. // 12 bytes.  Ideally the MAX_COMMAND_SIZE should be increased
  568. // to 16 for newer Fibre Channel and SCSI-3 larger CDBs.
  569. // However, to avoid a mandatory kernel rebuild, we use the SCp
  570. // spare field to store the extra 4 bytes ( ugly :-(
  572. if( MAX_COMMAND_SIZE < 16)
  573. {
  574.           memcpy( &ScsiPassThruCmnd->SCp.buffers_residual,
  575.   &vendor_cmd->cdb[12], 4);
  576. }   
  577.                   
  579.         ScsiPassThruCmnd->SCp.sent_command = 1; // PASSTHRU!
  580.                                         // suppress LUN masking
  581.                                         // and VSA logic
  583. // Use spare fields to copy FCP-SCSI LUN address info...
  584.         ScsiPassThruCmnd->SCp.phase = vendor_cmd->bus;
  585. ScsiPassThruCmnd->SCp.have_data_in = vendor_cmd->pdrive;
  587.         // We copy the scheme used by scsi.c to submit commands
  588. // to our own HBA.  We do this in order to stall the
  589. // thread calling the IOCTL until it completes, and use
  590. // the same "_quecommand" function for synchronizing
  591. // FC Link events with our "worker thread".
  593.         {
  594.           CPQFC_DECLARE_COMPLETION(wait);
  595.           ScsiPassThruCmnd->request.CPQFC_WAITING = &wait;
  596.           // eventually gets us to our own _quecommand routine
  597.           scsi_do_cmd( ScsiPassThruCmnd, &vendor_cmd->cdb[0], 
  598.        buf, 
  599.        vendor_cmd->len, 
  600.        my_ioctl_done, 
  601.        10*HZ, 1);// timeout,retries
  602.           // Other I/Os can now resume; we wait for our ioctl
  603.   // command to complete
  604.   CPQFC_WAIT_FOR_COMPLETION(&wait);
  605.           ScsiPassThruCmnd->request.CPQFC_WAITING = NULL;
  606.         }
  608.         result = ScsiPassThruCmnd->result;
  610.         // copy any sense data back to caller
  611.         if( result != 0 )
  612. {
  613.   memcpy( vendor_cmd->sense_data, // see struct def - size=40
  614.   ScsiPassThruCmnd->sense_buffer, 
  615.   sizeof(ScsiPassThruCmnd->sense_buffer)); 
  616. }
  617.         SDpnt = ScsiPassThruCmnd->device;
  618.         scsi_release_command(ScsiPassThruCmnd); // "de-allocate"
  619.         ScsiPassThruCmnd = NULL;
  621.         // if (!SDpnt->was_reset && SDpnt->scsi_request_fn)
  622.         //  (*SDpnt->scsi_request_fn)();
  624.         wake_up(&SDpnt->scpnt_wait);
  626. // need to pass data back to user (space)?
  627. if( (vendor_cmd->rw_flag == VENDOR_READ_OPCODE) &&
  628.      vendor_cmd->len )
  629.         if(  copy_to_user( vendor_cmd->bufp, buf, vendor_cmd->len))
  630. return( -EFAULT);
  632.         if( buf) 
  633.   kfree( buf);
  635.         return result;
  636.       }
  637.       
  638.       case CPQFCTS_GETPCIINFO:
  639.       {
  640. cpqfc_pci_info_struct pciinfo;
  642. if( !arg)
  643.   return -EINVAL;
  645.          
  647.         pciinfo.bus = cpqfcHBAdata->PciDev->bus->number;
  648.         pciinfo.dev_fn = cpqfcHBAdata->PciDev->devfn;  
  649. pciinfo.board_id = cpqfcHBAdata->PciDev->device |
  650.   (cpqfcHBAdata->PciDev->vendor <<16); 
  651.       
  652.         if(copy_to_user( arg, &pciinfo, sizeof(cpqfc_pci_info_struct)))
  653. return( -EFAULT);
  654.         return 0;
  655.       }
  657.       case CPQFCTS_GETDRIVVER:
  658.       {
  659. DriverVer_type DriverVer = 
  660. CPQFCTS_DRIVER_VER( VER_MAJOR,VER_MINOR,VER_SUBMINOR);
  662. if( !arg)
  663.   return -EINVAL;
  665.         if(copy_to_user( arg, &DriverVer, sizeof(DriverVer)))
  666. return( -EFAULT);
  667.         return 0;
  668.       }
  672.       case CPQFC_IOCTL_FC_TARGET_ADDRESS:
  673.       result = 
  674.         verify_area(VERIFY_WRITE, arg, sizeof(Scsi_FCTargAddress));
  675.       if (result) 
  676. break;
  677.  
  678.       put_user(pLoggedInPort->port_id,
  679. &((Scsi_FCTargAddress *) arg)->host_port_id);
  680.  
  681.       for( i=3,j=0; i>=0; i--)    // copy the LOGIN port's WWN
  682.         put_user(pLoggedInPort->u.ucWWN[i], 
  683. &((Scsi_FCTargAddress *) arg)->host_wwn[j++]);
  684.       for( i=7; i>3; i--) // copy the LOGIN port's WWN
  685.         put_user(pLoggedInPort->u.ucWWN[i], 
  686. &((Scsi_FCTargAddress *) arg)->host_wwn[j++]);
  687.         break;
  690.       case CPQFC_IOCTL_FC_TDR:
  691.           
  692.         result = cpqfcTS_TargetDeviceReset( ScsiDev, 0);
  694.         break;
  699.     default:
  700.       result = -EINVAL;
  701.       break;
  702.     }
  703.   }
  705.   LEAVE("cpqfcTS_ioctl");
  706.   return result;
  707. }
  710. /* "Release" the Host Bus Adapter...
  711.    disable interrupts, stop the HBA, release the interrupt,
  712.    and free all resources */
  714. int cpqfcTS_release(struct Scsi_Host *HostAdapter)
  715. {
  716.   CPQFCHBA *cpqfcHBAdata = (CPQFCHBA *)HostAdapter->hostdata; 
  719.   ENTER("cpqfcTS_release");
  721.   DEBUG_PCI( printk(" cpqfcTS: delete timer...n"));
  722.   del_timer( &cpqfcHBAdata->cpqfcTStimer);  
  723.     
  724.   // disable the hardware...
  725.   DEBUG_PCI( printk(" disable hardware, destroy queues, free memn"));
  726.   cpqfcHBAdata->fcChip.ResetTachyon( cpqfcHBAdata, CLEAR_FCPORTS);
  728.   // kill kernel thread
  729.   if( cpqfcHBAdata->worker_thread ) // (only if exists)
  730.   {
  731.     DECLARE_MUTEX_LOCKED(sem);  // synchronize thread kill
  733.     cpqfcHBAdata->notify_wt = &sem;
  734.     DEBUG_PCI( printk(" killing kernel threadn"));
  735.     send_sig( SIGKILL, cpqfcHBAdata->worker_thread, 1);
  736.     down( &sem);
  737.     cpqfcHBAdata->notify_wt = NULL;
  738.     
  739.   }
  741.   // free Linux resources
  742.   DEBUG_PCI( printk(" cpqfcTS: freeing resources...n"));
  743.   free_irq( HostAdapter->irq, HostAdapter);
  744.   scsi_unregister( HostAdapter);
  745.   release_region( cpqfcHBAdata->fcChip.Registers.IOBaseL, 0xff);
  746.   release_region( cpqfcHBAdata->fcChip.Registers.IOBaseU, 0xff);
  747.  /* we get "vfree: bad address" executing this - need to investigate... 
  748.   if( (void*)((unsigned long)cpqfcHBAdata->fcChip.Registers.MemBase) !=
  749.       cpqfcHBAdata->fcChip.Registers.ReMapMemBase)
  750.     vfree( cpqfcHBAdata->fcChip.Registers.ReMapMemBase);
  751. */
  753.   LEAVE("cpqfcTS_release");
  754.   return 0;
  755. }
  758. const char * cpqfcTS_info(struct Scsi_Host *HostAdapter)
  759. {
  760.   static char buf[300];
  761.   CPQFCHBA *cpqfcHBA;
  762.   int BusSpeed, BusWidth;
  763.   
  764.   // get the pointer to our Scsi layer HBA buffer  
  765.   cpqfcHBA = (CPQFCHBA *)HostAdapter->hostdata;
  767.   BusWidth = (cpqfcHBA->fcChip.Registers.PCIMCTR &0x4) > 0 ?
  768.                64 : 32;
  770.   if( cpqfcHBA->fcChip.Registers.TYconfig.value & 0x80000000)
  771.     BusSpeed = 66;
  772.   else
  773.     BusSpeed = 33;
  775.   sprintf(buf, 
  776. "%s: WWN %08X%08Xn on PCI bus %d device 0x%02x irq %d IObaseL 0x%x, MEMBASE 0x%xnPCI bus width %d bits, bus speed %d MHznFCP-SCSI Driver v%d.%d.%d",
  777.       cpqfcHBA->fcChip.Name, 
  778.       cpqfcHBA->fcChip.Registers.wwn_hi,
  779.       cpqfcHBA->fcChip.Registers.wwn_lo,
  780.       cpqfcHBA->PciDev->bus->number,
  781.       cpqfcHBA->PciDev->device,  
  782.       HostAdapter->irq,
  783.       cpqfcHBA->fcChip.Registers.IOBaseL,
  784.       cpqfcHBA->fcChip.Registers.MemBase,
  785.       BusWidth,
  786.       BusSpeed,
  787.       VER_MAJOR, VER_MINOR, VER_SUBMINOR
  788. );
  790.   
  791.   cpqfcTSDecodeGBICtype( &cpqfcHBA->fcChip, &buf[ strlen(buf)]);
  792.   cpqfcTSGetLPSM( &cpqfcHBA->fcChip, &buf[ strlen(buf)]);
  793.   return buf;
  794. }
  796. //
  797. // /proc/scsi support. The following routines allow us to do 'normal'
  798. // sprintf like calls to return the currently requested piece (buflenght
  799. // chars, starting at bufoffset) of the file. Although procfs allows for
  800. // a 1 Kb bytes overflow after te supplied buffer, I consider it bad 
  801. // programming to use it to make programming a little simpler. This piece
  802. // of coding is borrowed from ncr53c8xx.c with some modifications 
  803. //
  804. struct info_str
  805. {
  806.         char *buffer; // Pointer to output buffer
  807.         int buflength; // It's length
  808.         int bufoffset; // File offset corresponding with buf[0]
  809. int buffillen; // Current filled length 
  810.         int filpos; // Current file offset
  811. };
  813. static void copy_mem_info(struct info_str *info, char *data, int datalen)
  814. {
  816.   if (info->filpos < info->bufoffset) { // Current offset before buffer offset
  817.     if (info->filpos + datalen <= info->bufoffset) {
  818.       info->filpos += datalen;  // Discard if completely before buffer
  819.       return;
  820.     } else { // Partial copy, set to begin
  821.       data += (info->bufoffset - info->filpos);
  822.       datalen  -= (info->bufoffset - info->filpos);
  823.       info->filpos = info->bufoffset;
  824.     }
  825.   }
  827.   info->filpos += datalen; // Update current offset
  829.   if (info->buffillen == info->buflength) // Buffer full, discard
  830.     return;
  832.   if (info->buflength - info->buffillen < datalen)  // Overflows buffer ?
  833.     datalen = info->buflength - info->buffillen;
  835.   memcpy(info->buffer + info->buffillen, data, datalen);
  836.   info->buffillen += datalen;
  837. }
  839. static int copy_info(struct info_str *info, char *fmt, ...)
  840. {
  841.         va_list args;
  842.         char buf[400];
  843.         int len;
  845.         va_start(args, fmt);
  846.         len = vsprintf(buf, fmt, args);
  847.         va_end(args);
  849.         copy_mem_info(info, buf, len);
  850.         return len;
  851. }
  854. // Routine to get data for /proc RAM filesystem
  855. //
  856. int cpqfcTS_proc_info (char *buffer, char **start, off_t offset, int length, 
  857.        int hostno, int inout)
  858. {
  859.   struct Scsi_Host *host;
  860.   Scsi_Cmnd DumCmnd;
  861.   int Chan, Targ, i;
  862.   struct info_str info;
  863.   CPQFCHBA *cpqfcHBA;
  864.   PTACHYON fcChip;
  865.   PFC_LOGGEDIN_PORT pLoggedInPort;
  866.   char buf[81];
  868.   // Search the Scsi host list for our controller
  869.   for (host=scsi_hostlist; host; host=host->next)
  870.     if (host->host_no == hostno)
  871.       break;
  873.   if (!host) return -ESRCH;
  875.   if (inout) return -EINVAL;
  877.   // get the pointer to our Scsi layer HBA buffer  
  878.   cpqfcHBA = (CPQFCHBA *)host->hostdata;
  879.   fcChip = &cpqfcHBA->fcChip;
  880.   
  881.   *start    = buffer;
  883.   info.buffer     = buffer;
  884.   info.buflength  = length;
  885.   info.bufoffset  = offset;
  886.   info.filpos     = 0;
  887.   info.buffillen  = 0;
  888.   copy_info(&info, "Driver version = %d.%d.%d", VER_MAJOR, VER_MINOR, VER_SUBMINOR); 
  889.   cpqfcTSDecodeGBICtype( &cpqfcHBA->fcChip, &buf[0]);
  890.   cpqfcTSGetLPSM( &cpqfcHBA->fcChip, &buf[ strlen(buf)]);
  891.   copy_info(&info, "%sn", buf); 
  893. #define DISPLAY_WWN_INFO
  894. #ifdef DISPLAY_WWN_INFO
  895.   copy_info(&info, "WWN database: ("port_id: 000000" means disconnected)n");
  896.   for ( Chan=0; Chan <= host->max_channel; Chan++) {
  897.     DumCmnd.channel = Chan;
  898.     for (Targ=0; Targ <= host->max_id; Targ++) {
  899.       DumCmnd.target = Targ;
  900.       if ((pLoggedInPort = fcFindLoggedInPort( fcChip,
  901.      &DumCmnd, // search Scsi Nexus
  902.      0,        // DON'T search list for FC port id
  903.      NULL,     // DON'T search list for FC WWN
  904.      NULL))){   // DON'T care about end of list
  905. copy_info(&info, "Host: scsi%d Channel: %02d TargetId: %02d -> WWN: ",
  906.    hostno, Chan, Targ);
  907.         for( i=3; i>=0; i--)        // copy the LOGIN port's WWN
  908.           copy_info(&info, "%02X", pLoggedInPort->u.ucWWN[i]);
  909.         for( i=7; i>3; i--)             // copy the LOGIN port's WWN
  910.           copy_info(&info, "%02X", pLoggedInPort->u.ucWWN[i]);
  911. copy_info(&info, " port_id: %06Xn", pLoggedInPort->port_id); 
  912.       }
  913.     }
  914.   }
  915. #endif
  919.   
  920.   
  921. // Unfortunately, the proc_info buffer isn't big enough
  922. // for everything we would like...
  923. // For FC stats, compile this and turn off WWN stuff above  
  924. //#define DISPLAY_FC_STATS
  925. #ifdef DISPLAY_FC_STATS
  926. // get the Fibre Channel statistics
  927.   {
  928.     int DeltaSecs = (jiffies - cpqfcHBA->fcStatsTime) / HZ;
  929.     int days,hours,minutes,secs;
  930.     
  931.     days = DeltaSecs / (3600*24); // days
  932.     hours = (DeltaSecs% (3600*24)) / 3600; // hours
  933.     minutes = (DeltaSecs%3600 /60); // minutes
  934.     secs =  DeltaSecs%60;  // secs
  935. copy_info( &info, "Fibre Channel Stats (time dd:hh:mm:ss %02u:%02u:%02u:%02un",
  936.       days, hours, minutes, secs);
  937.   }
  938.     
  939.   cpqfcHBA->fcStatsTime = jiffies;  // (for next delta)
  941.   copy_info( &info, "  LinkUp           %9u     LinkDown      %un",
  942.         fcChip->fcStats.linkUp, fcChip->fcStats.linkDown);
  943.         
  944.   copy_info( &info, "  Loss of Signal   %9u     Loss of Sync  %un",
  945.     fcChip->fcStats.LossofSignal, fcChip->fcStats.LossofSync);
  946.   
  947.   copy_info( &info, "  Discarded Frames %9u     Bad CRC Frame %un",
  948.     fcChip->fcStats.Dis_Frm, fcChip->fcStats.Bad_CRC);
  950.   copy_info( &info, "  TACH LinkFailTX  %9u     TACH LinkFailRX     %un",
  951.     fcChip->fcStats.linkFailTX, fcChip->fcStats.linkFailRX);
  952.   
  953.   copy_info( &info, "  TACH RxEOFa      %9u     TACH Elastic Store  %un",
  954.     fcChip->fcStats.Rx_EOFa, fcChip->fcStats.e_stores);
  956.   copy_info( &info, "  BufferCreditWait %9uus   TACH FM Inits %un",
  957.     fcChip->fcStats.BB0_Timer*10, fcChip->fcStats.FMinits );
  959.   copy_info( &info, "  FC-2 Timeouts    %9u     FC-2 Logouts  %un",
  960.     fcChip->fcStats.timeouts, fcChip->fcStats.logouts); 
  961.         
  962.   copy_info( &info, "  FC-2 Aborts      %9u     FC-4 Aborts   %un",
  963.     fcChip->fcStats.FC2aborted, fcChip->fcStats.FC4aborted);
  964.    
  965.   // clear the counters
  966.   cpqfcTSClearLinkStatusCounters( fcChip);
  967. #endif
  969.   return info.buffillen;
  970. }
  973. #if DEBUG_CMND
  975. UCHAR *ScsiToAscii( UCHAR ScsiCommand)
  976. {
  978. /*++
  980. Routine Description:
  982.    Converts a SCSI command to a text string for debugging purposes.
  985. Arguments:
  987.    ScsiCommand -- hex value SCSI Command
  990. Return Value:
  992.    An ASCII, null-terminated string if found, else returns NULL.
  994. Original code from M. McGowen, Compaq
  995. --*/
  998.    switch (ScsiCommand)
  999.    {
  1000.       case 0x00:
  1001.          return( "Test Unit Ready" );
  1003.       case 0x01:
  1004.          return( "Rezero Unit or Rewind" );
  1006.       case 0x02:
  1007.          return( "Request Block Address" );
  1009.       case 0x03:
  1010.          return( "Requese Sense" );
  1012.       case 0x04:
  1013.          return( "Format Unit" );
  1015.       case 0x05:
  1016.          return( "Read Block Limits" );
  1018.       case 0x07:
  1019.          return( "Reassign Blocks" );
  1021.       case 0x08:
  1022.          return( "Read (6)" );
  1024.       case 0x0a:
  1025.          return( "Write (6)" );
  1027.       case 0x0b:
  1028.          return( "Seek (6)" );
  1030.       case 0x12:
  1031.          return( "Inquiry" );
  1033.       case 0x15:
  1034.          return( "Mode Select (6)" );
  1036.       case 0x16:
  1037.          return( "Reserve" );
  1039.       case 0x17:
  1040.          return( "Release" );
  1042.       case 0x1a:
  1043.          return( "ModeSen(6)" );
  1045.       case 0x1b:
  1046.          return( "Start/Stop Unit" );
  1048.       case 0x1c:
  1049.          return( "Receive Diagnostic Results" );
  1051.       case 0x1d:
  1052.          return( "Send Diagnostic" );
  1054.       case 0x25:
  1055.          return( "Read Capacity" );
  1057.       case 0x28:
  1058.          return( "Read (10)" );
  1060.       case 0x2a:
  1061.          return( "Write (10)" );
  1063.       case 0x2b:
  1064.          return( "Seek (10)" );
  1066.       case 0x2e:
  1067.          return( "Write and Verify" );
  1069.       case 0x2f:
  1070.          return( "Verify" );
  1072.       case 0x34:
  1073.          return( "Pre-Fetch" );
  1075.       case 0x35:
  1076.          return( "Synchronize Cache" );
  1078.       case 0x37:
  1079.          return( "Read Defect Data (10)" );
  1081.       case 0x3b:
  1082.          return( "Write Buffer" );
  1084.       case 0x3c:
  1085.          return( "Read Buffer" );
  1087.       case 0x3e:
  1088.          return( "Read Long" );
  1090.       case 0x3f:
  1091.          return( "Write Long" );
  1093.       case 0x41:
  1094.          return( "Write Same" );
  1096.       case 0x4c:
  1097.          return( "Log Select" );
  1099.       case 0x4d:
  1100.          return( "Log Sense" );
  1102.       case 0x56:
  1103.          return( "Reserve (10)" );
  1105.       case 0x57:
  1106.          return( "Release (10)" );
  1108.       case 0xa0:
  1109.          return( "ReportLuns" );
  1111.       case 0xb7:
  1112.          return( "Read Defect Data (12)" );
  1114.       case 0xca:
  1115.          return( "Peripheral Device Addressing SCSI Passthrough" );
  1117.       case 0xcb:
  1118.          return( "Compaq Array Firmware Passthrough" );
  1120.       default:
  1121.          return( NULL );
  1122.    }
  1124. } // end ScsiToAscii()
  1126. void cpqfcTS_print_scsi_cmd(Scsi_Cmnd * cmd)
  1127. {
  1129. printk("cpqfcTS: (%s) chnl 0x%02x, trgt = 0x%02x, lun = 0x%02x, cmd_len = 0x%02xn", 
  1130.     ScsiToAscii( cmd->cmnd[0]), cmd->channel, cmd->target, cmd->lun, cmd->cmd_len);
  1132. if( cmd->cmnd[0] == 0)   // Test Unit Ready?
  1133. {
  1134.   int i;
  1136.   printk("Cmnd->request_bufflen = 0x%X, ->use_sg = %d, ->bufflen = %dn",
  1137.     cmd->request_bufflen, cmd->use_sg, cmd->bufflen);
  1138.   printk("Cmnd->request_buffer = %p, ->sglist_len = %d, ->buffer = %pn",
  1139.     cmd->request_buffer, cmd->sglist_len, cmd->buffer);
  1140.   for (i = 0; i < cmd->cmd_len; i++)
  1141.     printk("0x%02x ", cmd->cmnd[i]);
  1142.   printk("n");
  1143. }
  1145. }
  1147. #endif /* DEBUG_CMND */
  1152. static void QueCmndOnBoardLock( CPQFCHBA *cpqfcHBAdata, Scsi_Cmnd *Cmnd)
  1153. {
  1154.   int i;
  1156.   for( i=0; i< CPQFCTS_REQ_QUEUE_LEN; i++)
  1157.   {    // find spare slot
  1158.     if( cpqfcHBAdata->BoardLockCmnd[i] == NULL )
  1159.     {
  1160.       cpqfcHBAdata->BoardLockCmnd[i] = Cmnd;
  1161. //      printk(" BoardLockCmnd[%d] %p Queued, chnl/target/lun %d/%d/%dn",
  1162. //        i,Cmnd, Cmnd->channel, Cmnd->target, Cmnd->lun);
  1163.       break;
  1164.     }
  1165.   }
  1166.   if( i >= CPQFCTS_REQ_QUEUE_LEN)
  1167.   {
  1168.     printk(" cpqfcTS WARNING: Lost Cmnd %p on BoardLock Q full!", Cmnd);
  1169.   }
  1171. }
  1174. static void QueLinkDownCmnd( CPQFCHBA *cpqfcHBAdata, Scsi_Cmnd *Cmnd)
  1175. {
  1176.   int indx;
  1178.   // Remember the command ptr so we can return; we'll complete when
  1179.   // the device comes back, causing immediate retry
  1180.   for( indx=0; indx < CPQFCTS_REQ_QUEUE_LEN; indx++)//, SCptr++)
  1181.   {
  1182.     if( cpqfcHBAdata->LinkDnCmnd[indx] == NULL ) // available?
  1183.     {
  1184. #ifdef DUMMYCMND_DBG
  1185.       printk(" @add Cmnd %p to LnkDnCmnd[%d]@ ", Cmnd,indx);
  1186. #endif
  1187.       cpqfcHBAdata->LinkDnCmnd[indx] = Cmnd;
  1188.       break;
  1189.     }
  1190.   }
  1192.   if( indx >= CPQFCTS_REQ_QUEUE_LEN ) // no space for Cmnd??
  1193.   {
  1194.     // this will result in an _abort call later (with possible trouble)
  1195.     printk("no buffer for LinkDnCmnd!! %pn", Cmnd);
  1196.   }
  1197. }
  1203. // The file "hosts.h" says not to call scsi_done from
  1204. // inside _queuecommand, so we'll do it from the heartbeat timer
  1205. // (clarification: Turns out it's ok to call scsi_done from queuecommand 
  1206. // for cases that don't go to the hardware like scsi cmds destined
  1207. // for LUNs we know don't exist, so this code might be simplified...)
  1209. static void QueBadTargetCmnd( CPQFCHBA *cpqfcHBAdata, Scsi_Cmnd *Cmnd)
  1210. {
  1211.   int i;
  1212.     //    printk(" can't find target %dn", Cmnd->target);
  1214.   for( i=0; i< CPQFCTS_MAX_TARGET_ID; i++)
  1215.   {    // find spare slot
  1216.     if( cpqfcHBAdata->BadTargetCmnd[i] == NULL )
  1217.     {
  1218.       cpqfcHBAdata->BadTargetCmnd[i] = Cmnd;
  1219. //      printk(" BadTargetCmnd[%d] %p Queued, chnl/target/lun %d/%d/%dn",
  1220. //          i,Cmnd, Cmnd->channel, Cmnd->target, Cmnd->lun);
  1221.       break;
  1222.     }
  1223.   }
  1224. }
  1227. // This is the "main" entry point for Linux Scsi commands --
  1228. // it all starts here.
  1230. int cpqfcTS_queuecommand(Scsi_Cmnd *Cmnd, void (* done)(Scsi_Cmnd *))
  1231. {
  1232.   struct Scsi_Host *HostAdapter = Cmnd->host;
  1233.   CPQFCHBA *cpqfcHBAdata = (CPQFCHBA *)HostAdapter->hostdata;
  1234.   PTACHYON fcChip = &cpqfcHBAdata->fcChip;
  1235.   TachFCHDR_GCMND fchs;  // only use for FC destination id field  
  1236.   PFC_LOGGEDIN_PORT pLoggedInPort;
  1237.   ULONG ulStatus, SESTtype;
  1238.   LONG ExchangeID;
  1243.   ENTER("cpqfcTS_queuecommand");
  1244.       
  1245.   PCI_TRACEO( (ULONG)Cmnd, 0x98)
  1246.       
  1247.   
  1248.   Cmnd->scsi_done = done;
  1249. #ifdef DEBUG_CMND  
  1250.   cpqfcTS_print_scsi_cmd( Cmnd);
  1251. #endif
  1253.   // prevent board contention with kernel thread...  
  1254.   
  1255.    if( cpqfcHBAdata->BoardLock )
  1256.   {
  1257. //    printk(" @BrdLck Hld@ ");
  1258.     QueCmndOnBoardLock( cpqfcHBAdata, Cmnd);
  1259.   }
  1260.   
  1261.   else
  1262.   {
  1264.     // in the current system (2.2.12), this routine is called
  1265.     // after spin_lock_irqsave(), so INTs are disabled. However,
  1266.     // we might have something pending in the LinkQ, which
  1267.     // might cause the WorkerTask to run.  In case that
  1268.     // happens, make sure we lock it out.
  1269.     
  1270.     
  1271.     
  1272.     PCI_TRACE( 0x98) 
  1273.     CPQ_SPINLOCK_HBA( cpqfcHBAdata)
  1274.     PCI_TRACE( 0x98) 
  1275.     
  1276.   // can we find an FC device mapping to this SCSI target?
  1277.     pLoggedInPort = fcFindLoggedInPort( fcChip,
  1278.       Cmnd,     // search Scsi Nexus
  1279.       0,        // DON'T search linked list for FC port id
  1280.       NULL,     // DON'T search linked list for FC WWN
  1281.       NULL);    // DON'T care about end of list
  1282.  
  1283.     if( pLoggedInPort == NULL )      // not found!
  1284.     {
  1285. //    printk(" @Q bad targ cmnd %p@ ", Cmnd);
  1286.       QueBadTargetCmnd( cpqfcHBAdata, Cmnd);
  1287.     }
  1288.     else if (Cmnd->lun >= CPQFCTS_MAX_LUN)
  1289.     {
  1290.       printk(KERN_WARNING "cpqfc: Invalid LUN: %dn", Cmnd->lun);
  1291.       QueBadTargetCmnd( cpqfcHBAdata, Cmnd);
  1292.     } 
  1294.     else  // we know what FC device to send to...
  1295.     {
  1297.       // does this device support FCP target functions?
  1298.       // (determined by PRLI field)
  1300.       if( !(pLoggedInPort->fcp_info & TARGET_FUNCTION) )
  1301.       {
  1302.         printk(" Doesn't support TARGET functions port_id %Xhn",
  1303.           pLoggedInPort->port_id );
  1304.         QueBadTargetCmnd( cpqfcHBAdata, Cmnd);
  1305.       }
  1307.     // In this case (previous login OK), the device is temporarily
  1308.     // unavailable waiting for re-login, in which case we expect it
  1309.     // to be back in between 25 - 500ms.  
  1310.     // If the FC port doesn't log back in within several seconds
  1311.     // (i.e. implicit "logout"), or we get an explicit logout,
  1312.     // we set "device_blocked" in Scsi_Device struct; in this
  1313.     // case 30 seconds will elapse before Linux/Scsi sends another
  1314.     // command to the device.
  1315.       else if( pLoggedInPort->prli != TRUE )
  1316.       {
  1317. //      printk("Device (Chnl/Target %d/%d) invalid PRLI, port_id %06lXhn",
  1318. //        Cmnd->channel, Cmnd->target, pLoggedInPort->port_id);
  1319.         QueLinkDownCmnd( cpqfcHBAdata, Cmnd);
  1320. //    Need to use "blocked" flag??   
  1321. // Cmnd->device->device_blocked = TRUE; // just let it timeout
  1322.       }
  1323.       else  // device supports TARGET functions, and is logged in...
  1324.       {
  1325.       // (context of fchs is to "reply" to...)
  1326.         fchs.s_id = pLoggedInPort->port_id; // destination FC address
  1328.       // what is the data direction?  For data TO the device,
  1329.       // we need IWE (Intiator Write Entry).  Otherwise, IRE.
  1331.         if( Cmnd->cmnd[0] == WRITE_10 ||
  1332.      Cmnd->cmnd[0] == WRITE_6 ||
  1333.   Cmnd->cmnd[0] == WRITE_BUFFER ||      
  1334.   Cmnd->cmnd[0] == VENDOR_WRITE_OPCODE ||  // CPQ specific 
  1335.   Cmnd->cmnd[0] == MODE_SELECT )
  1336.         {
  1337.           SESTtype = SCSI_IWE; // data from HBA to Device
  1338.         }
  1339.         else
  1340.           SESTtype = SCSI_IRE; // data from Device to HBA
  1341.        
  1342.         ulStatus = cpqfcTSBuildExchange(
  1343.           cpqfcHBAdata,
  1344.           SESTtype,     // e.g. Initiator Read Entry (IRE)
  1345.           &fchs,        // we are originator; only use d_id
  1346.           Cmnd,         // Linux SCSI command (with scatter/gather list)
  1347.           &ExchangeID );// fcController->fcExchanges index, -1 if failed
  1349.         if( !ulStatus ) // Exchange setup?
  1350.    
  1351.         {
  1352.           if( cpqfcHBAdata->BoardLock )
  1353.           {
  1354.     TriggerHBA( fcChip->Registers.ReMapMemBase, 0);
  1355.     printk(" @bl! %d, xID %Xh@ ", current->pid, ExchangeID);
  1356.           }
  1358.   ulStatus = cpqfcTSStartExchange( cpqfcHBAdata, ExchangeID );
  1359.   if( !ulStatus )
  1360.           {
  1361.             PCI_TRACEO( ExchangeID, 0xB8) 
  1362.           // submitted to Tach's Outbound Que (ERQ PI incremented)
  1363.           // waited for completion for ELS type (Login frames issued
  1364.           // synchronously)
  1365.   }
  1366.           else
  1367.             // check reason for Exchange not being started - we might
  1368.             // want to Queue and start later, or fail with error
  1369.           {
  1370.             printk("quecommand: cpqfcTSStartExchange failed: %Xhn", ulStatus );
  1371.           }
  1372.         }            // end good BuildExchange status
  1373.         
  1374.         else  // SEST table probably full  -- why? hardware hang?
  1375.         {
  1376.   printk("quecommand: cpqfcTSBuildExchange faild: %Xhn", ulStatus);
  1377.         }
  1378.       }  // end can't do FCP-SCSI target functions
  1379.     } // end can't find target (FC device)
  1381.     CPQ_SPINUNLOCK_HBA( cpqfcHBAdata)
  1382.   }
  1384.   PCI_TRACEO( (ULONG)Cmnd, 0x9C) 
  1385.   LEAVE("cpqfcTS_queuecommand");
  1386.   return 0;
  1387. }    
  1390. // Entry point for upper Scsi layer intiated abort.  Typically
  1391. // this is called if the command (for hard disk) fails to complete
  1392. // in 30 seconds.  This driver intends to complete all disk commands
  1393. // within Exchange ".timeOut" seconds (now 7) with target status, or
  1394. // in case of ".timeOut" expiration, a DID_SOFT_ERROR which causes
  1395. // immediate retry.
  1396. // If any disk commands get the _abort call, except for the case that
  1397. // the physical device was removed or unavailable due to hardware
  1398. // errors, it should be considered a driver error and reported to
  1399. // the author.
  1401. int cpqfcTS_abort(Scsi_Cmnd *Cmnd)
  1402. {
  1403. // printk(" cpqfcTS_abort called?? n");
  1404.   return 0;
  1405. }
  1406.  
  1407. int cpqfcTS_eh_abort(Scsi_Cmnd *Cmnd)
  1408. {
  1410.   struct Scsi_Host *HostAdapter = Cmnd->host;
  1411.   // get the pointer to our Scsi layer HBA buffer  
  1412.   CPQFCHBA *cpqfcHBAdata = (CPQFCHBA *)HostAdapter->hostdata;
  1413.   PTACHYON fcChip = &cpqfcHBAdata->fcChip;
  1414.   FC_EXCHANGES *Exchanges = fcChip->Exchanges;
  1415.   int i;
  1416.   ENTER("cpqfcTS_eh_abort");
  1418.   Cmnd->result = DID_ABORT <<16;  // assume we'll find it
  1420.   printk(" @Linux _abort Scsi_Cmnd %p ", Cmnd);
  1421.   // See if we can find a Cmnd pointer that matches...
  1422.   // The most likely case is we accepted the command
  1423.   // from Linux Scsi (e.g. ceated a SEST entry) and it
  1424.   // got lost somehow.  If we can't find any reference
  1425.   // to the passed pointer, we can only presume it
  1426.   // got completed as far as our driver is concerned.
  1427.   // If we found it, we will try to abort it through
  1428.   // common mechanism.  If FC ABTS is successful (ACC)
  1429.   // or is rejected (RJT) by target, we will call
  1430.   // Scsi "done" quickly.  Otherwise, the ABTS will timeout
  1431.   // and we'll call "done" later.
  1433.   // Search the SEST exchanges for a matching Cmnd ptr.
  1434.   for( i=0; i< TACH_SEST_LEN; i++)
  1435.   {
  1436.     if( Exchanges->fcExchange[i].Cmnd == Cmnd )
  1437.     {
  1438.       
  1439.       // found it!
  1440.       printk(" x_ID %Xh, type %Xhn", i, Exchanges->fcExchange[i].type);
  1442.       Exchanges->fcExchange[i].status = INITIATOR_ABORT; // seconds default
  1443.       Exchanges->fcExchange[i].timeOut = 10; // seconds default (changed later)
  1445.       // Since we need to immediately return the aborted Cmnd to Scsi 
  1446.       // upper layers, we can't make future reference to any of it's 
  1447.       // fields (e.g the Nexus).
  1449.       cpqfcTSPutLinkQue( cpqfcHBAdata, BLS_ABTS, &i);
  1451.       break;
  1452.     }
  1453.   }
  1455.   if( i >= TACH_SEST_LEN ) // didn't find Cmnd ptr in chip's SEST?
  1456.   {
  1457.     // now search our non-SEST buffers (i.e. Cmnd waiting to
  1458.     // start on the HBA or waiting to complete with error for retry).
  1459.     
  1460.     // first check BadTargetCmnd
  1461.     for( i=0; i< CPQFCTS_MAX_TARGET_ID; i++)
  1462.     { 
  1463.       if( cpqfcHBAdata->BadTargetCmnd[i] == Cmnd )
  1464.       {
  1465.         cpqfcHBAdata->BadTargetCmnd[i] = NULL;
  1466. printk("in BadTargetCmnd Qn");
  1467. goto Done; // exit
  1468.       }
  1469.     }
  1471.     // if not found above...
  1473.     for( i=0; i < CPQFCTS_REQ_QUEUE_LEN; i++)
  1474.     {
  1475.       if( cpqfcHBAdata->LinkDnCmnd[i] == Cmnd ) 
  1476.       {
  1477. cpqfcHBAdata->LinkDnCmnd[i] = NULL;
  1478. printk("in LinkDnCmnd Qn");
  1479. goto Done;
  1480.       }
  1481.     }
  1484.     for( i=0; i< CPQFCTS_REQ_QUEUE_LEN; i++)
  1485.     {    // find spare slot
  1486.       if( cpqfcHBAdata->BoardLockCmnd[i] == Cmnd )
  1487.       {
  1488.         cpqfcHBAdata->BoardLockCmnd[i] = NULL;
  1489. printk("in BoardLockCmnd Qn");
  1490. goto Done;
  1491.       }
  1492.     }
  1493.     
  1494.     Cmnd->result = DID_ERROR <<16;  // Hmmm...
  1495.     printk("Not found! ");
  1496. //    panic("_abort");
  1497.   }
  1498.   
  1499. Done:
  1500.   
  1501. //    panic("_abort");
  1502.   LEAVE("cpqfcTS_eh_abort");
  1503.   return 0;  // (see scsi.h)
  1504. }    
  1507. // FCP-SCSI Target Device Reset
  1508. // See dpANS Fibre Channel Protocol for SCSI
  1509. // X3.269-199X revision 12, pg 25
  1511. int cpqfcTS_TargetDeviceReset( Scsi_Device *ScsiDev, 
  1512.                                unsigned int reset_flags)
  1513. {
  1514.   int timeout = 10*HZ;
  1515.   int retries = 1;
  1516.   char scsi_cdb[12];
  1517.   int result;
  1518.   Scsi_Cmnd * SCpnt;
  1519.   Scsi_Device * SDpnt;
  1522.   // printk("   ENTERING cpqfcTS_TargetDeviceReset() - flag=%d n",reset_flags);
  1524.   if (ScsiDev->host->eh_active) return FAILED;
  1526.   memset( scsi_cdb, 0, sizeof( scsi_cdb));
  1528.   scsi_cdb[0] = RELEASE;
  1530.   // allocate with wait = true, interruptible = false 
  1531.   SCpnt = scsi_allocate_device(ScsiDev, 1, 0);
  1532.   {
  1533.     CPQFC_DECLARE_COMPLETION(wait);
  1534.         
  1535.     SCpnt->SCp.buffers_residual = FCP_TARGET_RESET;
  1537. SCpnt->request.CPQFC_WAITING = &wait;
  1538. scsi_do_cmd(SCpnt,  scsi_cdb, NULL,  0, my_ioctl_done,  timeout, retries);
  1539. CPQFC_WAIT_FOR_COMPLETION(&wait);
  1540. SCpnt->request.CPQFC_WAITING = NULL;
  1541.   }
  1542.     
  1543. /*
  1544.       if(driver_byte(SCpnt->result) != 0)
  1545.   switch(SCpnt->sense_buffer[2] & 0xf) {
  1546. case ILLEGAL_REQUEST:
  1547.     if(cmd[0] == ALLOW_MEDIUM_REMOVAL) dev->lockable = 0;
  1548.     else printk("SCSI device (ioctl) reports ILLEGAL REQUEST.n");
  1549.     break;
  1550. case NOT_READY: // This happens if there is no disc in drive 
  1551.     if(dev->removable && (cmd[0] != TEST_UNIT_READY)){
  1552. printk(KERN_INFO "Device not ready.  Make sure there is a disc in the drive.n");
  1553. break;
  1554.     }
  1555. case UNIT_ATTENTION:
  1556.     if (dev->removable){
  1557. dev->changed = 1;
  1558. SCpnt->result = 0; // This is no longer considered an error
  1559. // gag this error, VFS will log it anyway /axboe 
  1560. // printk(KERN_INFO "Disc change detected.n"); 
  1561. break;
  1562.     };
  1563. default: // Fall through for non-removable media
  1564.     printk("SCSI error: host %d id %d lun %d return code = %xn",
  1565.    dev->host->host_no,
  1566.    dev->id,
  1567.    dev->lun,
  1568.    SCpnt->result);
  1569.     printk("tSense class %x, sense error %x, extended sense %xn",
  1570.    sense_class(SCpnt->sense_buffer[0]),
  1571.    sense_error(SCpnt->sense_buffer[0]),
  1572.    SCpnt->sense_buffer[2] & 0xf);
  1573.     
  1574.       };
  1575. */    
  1576.   result = SCpnt->result;
  1578.   SDpnt = SCpnt->device;
  1579.   scsi_release_command(SCpnt);
  1580.   SCpnt = NULL;
  1582.   // if (!SDpnt->was_reset && SDpnt->scsi_request_fn)
  1583.   //  (*SDpnt->scsi_request_fn)();
  1585.   wake_up(&SDpnt->scpnt_wait);
  1586.   // printk("   LEAVING cpqfcTS_TargetDeviceReset() - return SUCCESS n");
  1587.   return SUCCESS;
  1588. }
  1591. int cpqfcTS_eh_device_reset(Scsi_Cmnd *Cmnd)
  1592. {
  1593.   int retval;
  1594.   Scsi_Device *SDpnt = Cmnd->device;
  1595.   // printk("   ENTERING cpqfcTS_eh_device_reset() n");
  1596.   spin_unlock_irq(&io_request_lock);
  1597.   retval = cpqfcTS_TargetDeviceReset( SDpnt, 0);
  1598.   spin_lock_irq(&io_request_lock);
  1599.   return retval;
  1600. }
  1603. int cpqfcTS_reset(Scsi_Cmnd *Cmnd, unsigned int reset_flags)
  1604. {
  1606.   ENTER("cpqfcTS_reset");
  1608.   LEAVE("cpqfcTS_reset");
  1609.   return SCSI_RESET_ERROR;      /* Bus Reset Not supported */
  1610. }
  1612. /* This function determines the bios parameters for a given
  1613.    harddisk. These tend to be numbers that are made up by the
  1614.    host adapter.  Parameters:
  1615.    size, device number, list (heads, sectors,cylinders).
  1616.    (from hosts.h)
  1617. */
  1619. int cpqfcTS_biosparam(Disk *disk, kdev_t n, int ip[])
  1620. {
  1621.   int size = disk->capacity;
  1622.   
  1623.   ENTER("cpqfcTS_biosparam");
  1624.   ip[0] = 64;
  1625.   ip[1] = 32;
  1626.   ip[2] = size >> 11;
  1627.   
  1628.   if( ip[2] > 1024 )
  1629.   {
  1630.     ip[0] = 255;
  1631.     ip[1] = 63;
  1632.     ip[2] = size / (ip[0] * ip[1]);
  1633.   }
  1635.   LEAVE("cpqfcTS_biosparam");
  1636.   return 0;
  1637. }    
  1641. void cpqfcTS_intr_handler( int irq, 
  1642. void *dev_id, 
  1643. struct pt_regs *regs)
  1644. {
  1646.   unsigned long flags, InfLoopBrk=0;
  1647.   struct Scsi_Host *HostAdapter = dev_id;
  1648.   CPQFCHBA *cpqfcHBA = (CPQFCHBA *)HostAdapter->hostdata;
  1649.   int MoreMessages = 1; // assume we have something to do
  1650.   UCHAR IntPending;
  1651.   
  1652.   ENTER("intr_handler");
  1654.   spin_lock_irqsave( &io_request_lock, flags);
  1655.   // is this our INT?
  1656.   IntPending = readb( cpqfcHBA->fcChip.Registers.INTPEND.address);
  1658.   // broken boards can generate messages forever, so
  1659.   // prevent the infinite loop
  1660. #define INFINITE_IMQ_BREAK 10000
  1661.   if( IntPending )
  1662.   {
  1663.     
  1664.     // mask our HBA interrupts until we handle it...
  1665.     writeb( 0, cpqfcHBA->fcChip.Registers.INTEN.address);
  1667.     if( IntPending & 0x4) // "INT" - Tach wrote to IMQ
  1668.     {
  1669.       while( (++InfLoopBrk < INFINITE_IMQ_BREAK) && (MoreMessages ==1) ) 
  1670.       {
  1671.         MoreMessages = CpqTsProcessIMQEntry( HostAdapter); // ret 0 when done
  1672.       }
  1673.       if( InfLoopBrk >= INFINITE_IMQ_BREAK )
  1674.       {
  1675.         printk("WARNING: Compaq FC adapter generating excessive INTs -REPLACEn");
  1676.         printk("or investigate alternate causes (e.g. physical FC layer)n");
  1677.       }
  1679.       else  // working normally - re-enable INTs and continue
  1680.         writeb( 0x1F, cpqfcHBA->fcChip.Registers.INTEN.address);
  1681.     
  1682.     }  // (...ProcessIMQEntry() clears INT by writing IMQ consumer)
  1683.     else  // indications of errors or problems...
  1684.           // these usually indicate critical system hardware problems.
  1685.     {
  1686.       if( IntPending & 0x10 )
  1687.    printk(" cpqfcTS adapter external memory parity error detectedn");
  1688.       if( IntPending & 0x8 )
  1689.    printk(" cpqfcTS adapter PCI master address crossed 45-bit boundaryn");
  1690.       if( IntPending & 0x2 )
  1691. printk(" cpqfcTS adapter DMA error detectedn");
  1692.       if( IntPending & 0x1 ) {
  1693.    UCHAR IntStat;
  1694.    printk(" cpqfcTS adapter PCI error detectedn");
  1695.    IntStat = readb( cpqfcHBA->fcChip.Registers.INTSTAT.address);
  1696. if (IntStat & 0x4) printk("(INT)n");
  1697. if (IntStat & 0x8) 
  1698. printk("CRS: PCI master address crossed 46 bit bouandaryn");
  1699. if (IntStat & 0x10) printk("MRE: external memory parity error.n");
  1700.       }
  1701.     }      
  1702.   }
  1703.   spin_unlock_irqrestore( &io_request_lock, flags);
  1704.   LEAVE("intr_handler");
  1705. }
  1710. int cpqfcTSDecodeGBICtype( PTACHYON fcChip, char cErrorString[])
  1711. {
  1712.         // Verify GBIC type (if any) and correct Tachyon Port State Machine
  1713.         // (GBIC) module definition is:
  1714.         // GPIO1, GPIO0, GPIO4 for MD2, MD1, MD0.  The input states appear
  1715.         // to be inverted -- i.e., a setting of 111 is read when there is NO
  1716.         // GBIC present.  The Module Def (MD) spec says 000 is "no GBIC"
  1717.         // Hard code the bit states to detect Copper, 
  1718.         // Long wave (single mode), Short wave (multi-mode), and absent GBIC
  1720.   ULONG ulBuff;
  1722.   sprintf( cErrorString, "nGBIC detected: ");
  1724.   ulBuff = fcChip->Registers.TYstatus.value & 0x13; 
  1725.   switch( ulBuff )
  1726.   {
  1727.   case 0x13:  // GPIO4, GPIO1, GPIO0 = 111; no GBIC!
  1728.     sprintf( &cErrorString[ strlen( cErrorString)],
  1729.             "NONE! ");
  1730.     return FALSE;          
  1731.           
  1732.        
  1733.   case 0x11:   // Copper GBIC detected
  1734.     sprintf( &cErrorString[ strlen( cErrorString)],
  1735.             "Copper. ");
  1736.     break;
  1738.   case 0x10:   // Long-wave (single mode) GBIC detected
  1739.     sprintf( &cErrorString[ strlen( cErrorString)],
  1740.         "Long-wave. ");
  1741.     break;
  1742.   case 0x1:    // Short-wave (multi mode) GBIC detected
  1743.     sprintf( &cErrorString[ strlen( cErrorString)],
  1744.         "Short-wave. ");
  1745.     break;
  1746.   default:     // unknown GBIC - presumably it will work (?)
  1747.     sprintf( &cErrorString[ strlen( cErrorString)],
  1748.             "Unknown. ");
  1749.           
  1750.     break;
  1751.   }  // end switch GBIC detection
  1753.   return TRUE;
  1754. }
  1761. int cpqfcTSGetLPSM( PTACHYON fcChip, char cErrorString[])
  1762. {
  1763.   // Tachyon's Frame Manager LPSM in LinkDown state?
  1764.   // (For non-loop port, check PSM instead.)
  1765.   // return string with state and FALSE is Link Down
  1767.   int LinkUp;
  1769.   if( fcChip->Registers.FMstatus.value & 0x80 ) 
  1770.     LinkUp = FALSE;
  1771.   else
  1772.     LinkUp = TRUE;
  1774.   sprintf( &cErrorString[ strlen( cErrorString)],
  1775.     " LPSM %Xh ", 
  1776.      (fcChip->Registers.FMstatus.value >>4) & 0xf );
  1779.   switch( fcChip->Registers.FMstatus.value & 0xF0)
  1780.   {
  1781.                     // bits set in LPSM
  1782.     case 0x10:
  1783.       sprintf( &cErrorString[ strlen( cErrorString)], "ARB");
  1784.       break;
  1785.     case 0x20:
  1786.       sprintf( &cErrorString[ strlen( cErrorString)], "ARBwon");
  1787.       break;
  1788.     case 0x30:
  1789.       sprintf( &cErrorString[ strlen( cErrorString)], "OPEN");
  1790.       break;
  1791.     case 0x40:
  1792.       sprintf( &cErrorString[ strlen( cErrorString)], "OPENed");
  1793.       break;
  1794.     case 0x50:
  1795.       sprintf( &cErrorString[ strlen( cErrorString)], "XmitCLS");
  1796.       break;
  1797.     case 0x60:
  1798.       sprintf( &cErrorString[ strlen( cErrorString)], "RxCLS");
  1799.       break;
  1800.     case 0x70:
  1801.       sprintf( &cErrorString[ strlen( cErrorString)], "Xfer");
  1802.       break;
  1803.     case 0x80:
  1804.       sprintf( &cErrorString[ strlen( cErrorString)], "Init");
  1805.       break;
  1806.     case 0x90:
  1807.       sprintf( &cErrorString[ strlen( cErrorString)], "O-IInitFin");
  1808.       break;
  1809.     case 0xa0:
  1810.       sprintf( &cErrorString[ strlen( cErrorString)], "O-IProtocol");
  1811.       break;
  1812.     case 0xb0:
  1813.       sprintf( &cErrorString[ strlen( cErrorString)], "O-ILipRcvd");
  1814.       break;
  1815.     case 0xc0:
  1816.       sprintf( &cErrorString[ strlen( cErrorString)], "HostControl");
  1817.       break;
  1818.     case 0xd0:
  1819.       sprintf( &cErrorString[ strlen( cErrorString)], "LoopFail");
  1820.       break;
  1821.     case 0xe0:
  1822.       sprintf( &cErrorString[ strlen( cErrorString)], "Offline");
  1823.       break;
  1824.     case 0xf0:
  1825.       sprintf( &cErrorString[ strlen( cErrorString)], "OldPort");
  1826.       break;
  1827.     case 0:
  1828.     default:
  1829.       sprintf( &cErrorString[ strlen( cErrorString)], "Monitor");
  1830.       break;
  1832.   }
  1834.   return LinkUp;
  1835. }
  1840. #include "linux/slab.h"
  1842. // Dynamic memory allocation alignment routines
  1843. // HP's Tachyon Fibre Channel Controller chips require
  1844. // certain memory queues and register pointers to be aligned
  1845. // on various boundaries, usually the size of the Queue in question.
  1846. // Alignment might be on 2, 4, 8, ... or even 512 byte boundaries.
  1847. // Since most O/Ss don't allow this (usually only Cache aligned -
  1848. // 32-byte boundary), these routines provide generic alignment (after
  1849. // O/S allocation) at any boundary, and store the original allocated
  1850. // pointer for deletion (O/S free function).  Typically, we expect
  1851. // these functions to only be called at HBA initialization and
  1852. // removal time (load and unload times)
  1853. // ALGORITHM notes:
  1854. // Memory allocation varies by compiler and platform.  In the worst case,
  1855. // we are only assured BYTE alignment, but in the best case, we can
  1856. // request allocation on any desired boundary.  Our strategy: pad the
  1857. // allocation request size (i.e. waste memory) so that we are assured
  1858. // of passing desired boundary near beginning of contiguous space, then
  1859. // mask out lower address bits.
  1860. // We define the following algorithm:
  1861. //   allocBoundary - compiler/platform specific address alignment
  1862. //                   in number of bytes (default is single byte; i.e. 1)
  1863. //   n_alloc       - number of bytes application wants @ aligned address
  1864. //   ab            - alignment boundary, in bytes (e.g. 4, 32, ...)
  1865. //   t_alloc       - total allocation needed to ensure desired boundary
  1866. //   mask          - to clear least significant address bits for boundary
  1867. //   Compute:
  1868. //   t_alloc = n_alloc + (ab - allocBoundary)
  1869. //   allocate t_alloc bytes @ alloc_address
  1870. //   mask =  NOT (ab - 1)
  1871. //       (e.g. if ab=32  _0001 1111  -> _1110 0000
  1872. //   aligned_address = alloc_address & mask
  1873. //   set n_alloc bytes to 0
  1874. //   return aligned_address (NULL if failed)
  1875. //
  1876. // If u32_AlignedAddress is non-zero, then search for BaseAddress (stored
  1877. // from previous allocation).  If found, invoke call to FREE the memory.
  1878. // Return NULL if BaseAddress not found
  1880. // we need about 8 allocations per HBA.  Figuring at most 10 HBAs per server
  1881. // size the dynamic_mem array at 80.
  1883. void* fcMemManager( struct pci_dev *pdev, ALIGNED_MEM *dynamic_mem, 
  1884.    ULONG n_alloc, ULONG ab, ULONG u32_AlignedAddress,
  1885. dma_addr_t *dma_handle)
  1886. {
  1887.   USHORT allocBoundary=1;   // compiler specific - worst case 1
  1888.                                   // best case - replace malloc() call
  1889.                                   // with function that allocates exactly
  1890.                                   // at desired boundary
  1892.   unsigned long ulAddress;
  1893.   ULONG t_alloc, i;
  1894.   void *alloc_address = 0;  // def. error code / address not found
  1895.   LONG mask;                // must be 32-bits wide!
  1897.   ENTER("fcMemManager");
  1898.   if( u32_AlignedAddress )          // are we freeing existing memory?
  1899.   {
  1900. //    printk(" freeing AlignedAddress %Xhn", u32_AlignedAddress);
  1901.     for( i=0; i<DYNAMIC_ALLOCATIONS; i++) // look for the base address
  1902.     {
  1903. //    printk("dynamic_mem[%u].AlignedAddress %lXn", i, dynamic_mem[i].AlignedAddress);
  1904.       if( dynamic_mem[i].AlignedAddress == u32_AlignedAddress )
  1905.       {
  1906.         alloc_address = dynamic_mem[i].BaseAllocated; // 'success' status
  1907. pci_free_consistent(pdev,dynamic_mem[i].size, 
  1908. alloc_address, 
  1909. dynamic_mem[i].dma_handle);
  1910.         dynamic_mem[i].BaseAllocated = 0;   // clear for next use
  1911.         dynamic_mem[i].AlignedAddress = 0;
  1912.         dynamic_mem[i].size = 0;
  1913.         break;                        // quit for loop; done
  1914.       }
  1915.     }
  1916.   }
  1917.   else if( n_alloc )                   // want new memory?
  1918.   {
  1919.     dma_addr_t handle;
  1920.     t_alloc = n_alloc + (ab - allocBoundary); // pad bytes for alignment
  1921. //    printk("pci_alloc_consistent() for Tach alignment: %ld bytesn", t_alloc);
  1923. // (would like to) allow thread block to free pages 
  1924.     alloc_address =                  // total bytes (NumberOfBytes)
  1925.       pci_alloc_consistent(pdev, t_alloc, &handle); 
  1927.                                   // now mask off least sig. bits of address
  1928.     if( alloc_address )           // (only if non-NULL)
  1929.     {
  1930.                                   // find place to store ptr, so we
  1931.                                   // can free it later...
  1933.       mask = (LONG)(ab - 1);            // mask all low-order bits
  1934.       mask = ~mask;                            // invert bits
  1935.       for( i=0; i<DYNAMIC_ALLOCATIONS; i++) // look for free slot
  1936.       {
  1937.         if( dynamic_mem[i].BaseAllocated == 0) // take 1st available
  1938.         {
  1939.           dynamic_mem[i].BaseAllocated = alloc_address;// address from O/S
  1940.           dynamic_mem[i].dma_handle = handle;
  1941.   if (dma_handle != NULL) 
  1942.   {
  1943. //             printk("handle = %p, ab=%d, boundary = %d, mask=0x%08xn", 
  1944. // handle, ab, allocBoundary, mask);
  1945.     *dma_handle = (dma_addr_t) 
  1946. ((((ULONG)handle) + (ab - allocBoundary)) & mask);
  1947.   }
  1948.           dynamic_mem[i].size = t_alloc;
  1949.           break;
  1950.         }
  1951.       }
  1952.       ulAddress = (unsigned long)alloc_address;
  1953.       
  1954.       ulAddress += (ab - allocBoundary);    // add the alignment bytes-
  1955.                                             // then truncate address...
  1956.       alloc_address = (void*)(ulAddress & mask);
  1957.       
  1958.       dynamic_mem[i].AlignedAddress = 
  1959. (ULONG)(ulAddress & mask); // 32bit Tach address
  1960.       memset( alloc_address, 0, n_alloc );  // clear new memory
  1961.     }
  1962.     else  // O/S dynamic mem alloc failed!
  1963.       alloc_address = 0;  // (for debugging breakpt)
  1965.   }
  1967.   LEAVE("fcMemManager");
  1968.   return alloc_address;  // good (or NULL) address
  1969. }
  1972. static Scsi_Host_Template driver_template = CPQFCTS;
  1974. #include "scsi_module.c"