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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
ips.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：274k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

ips.c：源码内容
  1. /*****************************************************************************/
  2. /* ips.c -- driver for the IBM ServeRAID controller                          */
  3. /*                                                                           */
  4. /* Written By: Keith Mitchell, IBM Corporation                               */
  5. /*             Jack Hammer, Adaptec, Inc.                                    */
  6. /*             David Jeffery, Adaptec, Inc.                                  */
  7. /*                                                                           */
  8. /* Copyright (C) 2000 IBM Corporation                                        */
  9. /*                                                                           */
  10. /* This program is free software; you can redistribute it and/or modify      */
  11. /* it under the terms of the GNU General Public License as published by      */
  12. /* the Free Software Foundation; either version 2 of the License, or         */
  13. /* (at your option) any later version.                                       */
  14. /*                                                                           */
  15. /* This program is distributed in the hope that it will be useful,           */
  16. /* but WITHOUT ANY WARRANTY; without even the implied warranty of            */
  17. /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             */
  18. /* GNU General Public License for more details.                              */
  19. /*                                                                           */
  20. /* NO WARRANTY                                                               */
  21. /* THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR        */
  22. /* CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT      */
  23. /* LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,      */
  24. /* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is    */
  25. /* solely responsible for determining the appropriateness of using and       */
  26. /* distributing the Program and assumes all risks associated with its        */
  27. /* exercise of rights under this Agreement, including but not limited to     */
  28. /* the risks and costs of program errors, damage to or loss of data,         */
  29. /* programs or equipment, and unavailability or interruption of operations.  */
  30. /*                                                                           */
  31. /* DISCLAIMER OF LIABILITY                                                   */
  32. /* NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY   */
  33. /* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL        */
  34. /* DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND   */
  35. /* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR     */
  36. /* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE    */
  37. /* USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED  */
  38. /* HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES             */
  39. /*                                                                           */
  40. /* You should have received a copy of the GNU General Public License         */
  41. /* along with this program; if not, write to the Free Software               */
  42. /* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  43. /*                                                                           */
  44. /* Bugs/Comments/Suggestions about this driver should be mailed to:          */
  45. /*      ipslinux@adaptec.com                                               */
  46. /*                                                                           */
  47. /* For system support issues, contact your local IBM Customer support.       */
  48. /* Directions to find IBM Customer Support for each country can be found at: */
  49. /*      http://www.ibm.com/planetwide/                                       */
  50. /*                                                                           */
  51. /*****************************************************************************/
  53. /*****************************************************************************/
  54. /* Change Log                                                                */
  55. /*                                                                           */
  56. /* 0.99.02  - Breakup commands that are bigger than 8 * the stripe size      */
  57. /* 0.99.03  - Make interrupt routine handle all completed request on the     */
  58. /*            adapter not just the first one                                 */
  59. /*          - Make sure passthru commands get woken up if we run out of      */
  60. /*            SCBs                                                           */
  61. /*          - Send all of the commands on the queue at once rather than      */
  62. /*            one at a time since the card will support it.                  */
  63. /* 0.99.04  - Fix race condition in the passthru mechanism -- this required  */
  64. /*            the interface to the utilities to change                       */
  65. /*          - Fix error recovery code                                        */
  66. /* 0.99.05  - Fix an oops when we get certain passthru commands              */
  67. /* 1.00.00  - Initial Public Release                                         */
  68. /*            Functionally equivalent to 0.99.05                             */
  69. /* 3.60.00  - Bump max commands to 128 for use with ServeRAID firmware 3.60  */
  70. /*          - Change version to 3.60 to coincide with ServeRAID release      */
  71. /*            numbering.                                                     */
  72. /* 3.60.01  - Remove bogus error check in passthru routine                   */
  73. /* 3.60.02  - Make DCDB direction based on lookup table                      */
  74. /*          - Only allow one DCDB command to a SCSI ID at a time             */
  75. /* 4.00.00  - Add support for ServeRAID 4                                    */
  76. /* 4.00.01  - Add support for First Failure Data Capture                     */
  77. /* 4.00.02  - Fix problem with PT DCDB with no buffer                        */
  78. /* 4.00.03  - Add alternative passthru interface                             */
  79. /*          - Add ability to flash ServeRAID BIOS                            */
  80. /* 4.00.04  - Rename structures/constants to be prefixed with IPS_           */
  81. /* 4.00.05  - Remove wish_block from init routine                            */
  82. /*          - Use linux/spinlock.h instead of asm/spinlock.h for kernels     */
  83. /*            2.3.18 and later                                               */
  84. /*          - Sync with other changes from the 2.3 kernels                   */
  85. /* 4.00.06  - Fix timeout with initial FFDC command                          */
  86. /* 4.00.06a - Port to 2.4 (trivial) -- Christoph Hellwig <hch@caldera.de>    */
  87. /* 4.10.00  - Add support for ServeRAID 4M/4L                                */
  88. /* 4.10.13  - Fix for dynamic unload and proc file system                    */
  89. /* 4.20.03  - Rename version to coincide with new release schedules          */
  90. /*            Performance fixes                                              */
  91. /*            Fix truncation of /proc files with cat                         */
  92. /*            Merge in changes through kernel 2.4.0test1ac21                 */
  93. /* 4.20.13  - Fix some failure cases / reset code                            */
  94. /*          - Hook into the reboot_notifier to flush the controller cache    */
  95. /* 4.50.01  - Fix problem when there is a hole in logical drive numbering    */
  96. /* 4.70.09  - Use a Common ( Large Buffer ) for Flashing from the JCRM CD    */
  97. /*          - Add IPSSEND Flash Support                                      */
  98. /*          - Set Sense Data for Unknown SCSI Command                        */
  99. /*          - Use Slot Number from NVRAM Page 5                              */
  100. /*          - Restore caller's DCDB Structure                                */
  101. /* 4.70.12  - Corrective actions for bad controller ( during initialization )*/
  102. /* 4.70.13  - Don't Send CDB's if we already know the device is not present  */
  103. /*          - Don't release HA Lock in ips_next() until SC taken off queue   */
  104. /*          - Unregister SCSI device in ips_release()                        */
  105. /* 4.70.15  - Fix Breakup for very large ( non-SG ) requests in ips_done()   */
  106. /* 4.71.00  - Change all memory allocations to not use GFP_DMA flag          */
  107. /*            Code Clean-Up for 2.4.x kernel                                 */
  108. /* 4.72.00  - Allow for a Scatter-Gather Element to exceed MAX_XFER Size     */
  109. /* 4.72.01  - I/O Mapped Memory release ( so "insmod ips" does not Fail )    */
  110. /*          - Don't Issue Internal FFDC Command if there are Active Commands */
  111. /*          - Close Window for getting too many IOCTL's active               */
  112. /* 4.80.00  - Make ia64 Safe                                                 */
  113. /* 4.80.04  - Eliminate calls to strtok() if 2.4.x or greater                */
  114. /*          - Adjustments to Device Queue Depth                              */
  115. /* 4.80.14  - Take all semaphores off stack                                  */
  116. /*          - Clean Up New_IOCTL path                                        */
  117. /* 4.80.20  - Set max_sectors in Scsi_Host structure ( if >= 2.4.7 kernel )  */
  118. /*          - 5 second delay needed after resetting an i960 adapter          */
  119. /* 4.80.26  - Clean up potential code problems ( Arjan's recommendations )   */
  120. /* 4.90.01  - Version Matching for FirmWare, BIOS, and Driver                */
  121. /* 4.90.05  - Use New PCI Architecture to facilitate Hot Plug Development    */
  122. /* 4.90.08  - Increase Delays in Flashing ( Trombone Only - 4H )             */
  123. /* 4.90.08  - Data Corruption if First Scatter Gather Element is > 64K       */
  124. /* 4.90.11  - Don't actually RESET unless it's physically required           */
  125. /*          - Remove unused compile options                                  */
  126. /* 5.00.01  - Sarasota ( 5i ) adapters must always be scanned first          */
  127. /*          - Get rid on IOCTL_NEW_COMMAND code                              */
  128. /*          - Add Extended DCDB Commands for Tape Support in 5I              */
  129. /*****************************************************************************/
  131. /*
  132.  * Conditional Compilation directives for this driver:
  133.  *
  134.  * IPS_DEBUG            - Turn on debugging info
  135.  *
  136.  * Parameters:
  137.  *
  138.  * debug:<number>       - Set debug level to <number>
  139.  *                        NOTE: only works when IPS_DEBUG compile directive is used.
  140.  *       1              - Normal debug messages
  141.  *       2              - Verbose debug messages
  142.  *       11             - Method trace (non interrupt)
  143.  *       12             - Method trace (includes interrupt)
  144.  *
  145.  * noi2o                - Don't use I2O Queues (ServeRAID 4 only)
  146.  * nommap               - Don't use memory mapped I/O
  147.  * ioctlsize            - Initial size of the IOCTL buffer
  148.  */
  149.  
  150. #include <asm/io.h>
  151. #include <asm/byteorder.h>
  152. #include <asm/page.h>
  153. #include <linux/stddef.h>
  154. #include <linux/version.h>
  155. #include <linux/string.h>
  156. #include <linux/errno.h>
  157. #include <linux/kernel.h>
  158. #include <linux/ioport.h>
  159. #include <linux/slab.h>
  160. #include <linux/vmalloc.h>
  161. #include <linux/delay.h>
  162. #include <linux/sched.h>
  163. #include <linux/pci.h>
  164. #include <linux/proc_fs.h>
  165. #include <linux/reboot.h>
  166. #include <linux/tqueue.h>
  167. #include <linux/interrupt.h>
  169. #include <linux/blk.h>
  170. #include <linux/types.h>
  172. #include <scsi/sg.h>
  174. #include "sd.h"
  175. #include "scsi.h"
  176. #include "hosts.h"
  177. #include "ips.h"
  179. #include <linux/module.h>
  181. #include <linux/stat.h>
  182. #include <linux/config.h>
  184. #if LINUX_VERSION_CODE >= LinuxVersionCode(2,4,0)
  185.   #include <linux/spinlock.h>
  186.   #include <linux/init.h>
  187. #else
  188.   #include <asm/spinlock.h>
  189. #endif
  191. #include <linux/smp.h>
  193. #ifdef MODULE
  194.    static char *ips = NULL;
  195.    MODULE_PARM(ips, "s");
  196. #endif
  198. /*
  199.  * DRIVER_VER
  200.  */
  201. #define IPS_VERSION_HIGH        "5.10"
  202. #define IPS_VERSION_LOW         ".21 "
  205. #if LINUX_VERSION_CODE < LinuxVersionCode(2,4,0)
  206. struct proc_dir_entry proc_scsi_ips = {
  207.    0,
  208.    3, "ips",
  209.    S_IFDIR | S_IRUGO | S_IXUGO, 2
  210. };
  211. #endif
  213. #if !defined(__i386__) && !defined(__ia64__)
  214.    #error "This driver has only been tested on the x86/ia64 platforms"
  215. #endif
  217. #if LINUX_VERSION_CODE < LinuxVersionCode(2,2,0)
  218.    #error "This driver only works with kernel 2.2.0 and later"
  219. #elif LINUX_VERSION_CODE <= LinuxVersionCode(2,3,18)
  220.     #define dma_addr_t uint32_t
  221.     
  222.     static inline void *pci_alloc_consistent(struct pci_dev *dev,int size,
  223.                                              dma_addr_t *dmahandle) {
  224.        void * ptr = kmalloc(size, GFP_ATOMIC); 
  225.        if(ptr){     
  226.           *dmahandle = VIRT_TO_BUS(ptr);
  227.        }
  228.        return ptr;
  229.     }
  230.     
  231.     #define pci_free_consistent(a,size,address,dmahandle) kfree(address)
  232.     
  233.     #define pci_map_sg(a,b,n,z)       (n)
  234.     #define pci_unmap_sg(a,b,c,d)     
  235.     #define pci_map_single(a,b,c,d)   (VIRT_TO_BUS(b))
  236.     #define pci_unmap_single(a,b,c,d) 
  237.     #ifndef sg_dma_address
  238.       #define sg_dma_address(x)         (VIRT_TO_BUS((x)->address))
  239.       #define sg_dma_len(x)             ((x)->length)
  240.     #endif
  241.     #define pci_unregister_driver(x)
  242. #endif
  244. #ifdef IPS_DEBUG
  245.    #define METHOD_TRACE(s, i)    if (ips_debug >= (i+10)) printk(KERN_NOTICE s "n");
  246.    #define DEBUG(i, s)           if (ips_debug >= i) printk(KERN_NOTICE s "n");
  247.    #define DEBUG_VAR(i, s, v...) if (ips_debug >= i) printk(KERN_NOTICE s "n", v);
  248. #else
  249.    #define METHOD_TRACE(s, i)
  250.    #define DEBUG(i, s)
  251.    #define DEBUG_VAR(i, s, v...)
  252. #endif
  254. /*
  255.  * global variables
  256.  */
  257. static const char   ips_name[] = "ips";
  258. static struct Scsi_Host *ips_sh[IPS_MAX_ADAPTERS];   /* Array of host controller structures */
  259. static ips_ha_t    *ips_ha[IPS_MAX_ADAPTERS];        /* Array of HA structures */
  260. static unsigned int ips_next_controller = 0;
  261. static unsigned int ips_num_controllers = 0;
  262. static unsigned int ips_released_controllers = 0;
  263. static int          ips_cmd_timeout = 60;
  264. static int          ips_reset_timeout = 60 * 5;
  265. static int          ips_force_memio = 1;             /* Always use Memory Mapped I/O    */
  266. static int          ips_force_i2o = 1;               /* Always use I2O command delivery */
  267. static int          ips_ioctlsize = IPS_IOCTL_SIZE;  /* Size of the ioctl buffer        */
  268. static int          ips_cd_boot = 0;                 /* Booting from ServeRAID Manager CD */
  269. static char        *ips_FlashData = NULL;            /* CD Boot - Flash Data Buffer      */
  270. static int          ips_FlashDataInUse = 0;          /* CD Boot - Flash Data In Use Flag */
  271. static uint32_t     MaxLiteCmds = 32;                /* Max Active Cmds for a Lite Adapter */  
  273. IPS_DEFINE_COMPAT_TABLE( Compatable );               /* Version Compatability Table      */
  276. #if LINUX_VERSION_CODE >= LinuxVersionCode(2,4,0)
  277.    /* This table describes any / all ServeRAID Adapters */
  278.    static struct  pci_device_id  ips_pci_table[]  __devinitdata = {
  279.            { 0x1014, 0x002E, PCI_ANY_ID, PCI_ANY_ID, 0, 0 },
  280.            { 0x1014, 0x01BD, PCI_ANY_ID, PCI_ANY_ID, 0, 0 },
  281.            { 0, }
  282.    };
  284.    /* This table describes only Sarasota ( ServeRAID 5i ) Adapters */
  285.    static struct  pci_device_id  ips_pci_table_5i[]  __devinitdata = {
  286.                    { 0x1014, 0x01BD, PCI_ANY_ID, 0x259, 0, 0 },
  287.                    { 0x1014, 0x01BD, PCI_ANY_ID, 0x258, 0, 0 },
  288.                    { 0, }
  289.                    };   
  290.     
  291.    /* This table describes all i960 Adapters */
  292.    static struct  pci_device_id  ips_pci_table_i960[]  __devinitdata = {
  293.                    { 0x1014, 0x01BD, PCI_ANY_ID, PCI_ANY_ID, 0, 0 },
  294.                    { 0, }
  295.                    };   
  297.    MODULE_DEVICE_TABLE( pci, ips_pci_table );
  299.    static char ips_hot_plug_name[] = "ips";
  300.    
  301.    static int __devinit  ips_insert_device(struct pci_dev *pci_dev, const struct pci_device_id *ent);
  302.    static void __devexit ips_remove_device(struct pci_dev *pci_dev);
  303.    
  304.    struct pci_driver ips_pci_driver = {
  305.        name: ips_hot_plug_name,
  306.        id_table: ips_pci_table,
  307.        probe: ips_insert_device,
  308.        remove: __devexit_p(ips_remove_device),
  309.    }; 
  310.            
  311.    struct pci_driver ips_pci_driver_5i = {
  312.        name: ips_hot_plug_name,
  313.        id_table: ips_pci_table_5i,
  314.        probe: ips_insert_device,
  315.        remove: __devexit_p(ips_remove_device),
  316.    };
  318.    struct pci_driver ips_pci_driver_i960 = {
  319.        name: ips_hot_plug_name,
  320.        id_table: ips_pci_table_i960,
  321.        probe: ips_insert_device,
  322.        remove: __devexit_p(ips_remove_device),
  323.    };
  325. #endif
  327. /*
  328.  * Necessary forward function protoypes
  329.  */
  330. static int ips_halt(struct notifier_block *nb, ulong event, void *buf);
  332. #define MAX_ADAPTER_NAME 11
  334. static char ips_adapter_name[][30] = {
  335.    "ServeRAID",
  336.    "ServeRAID II",
  337.    "ServeRAID on motherboard",
  338.    "ServeRAID on motherboard",
  339.    "ServeRAID 3H",
  340.    "ServeRAID 3L",
  341.    "ServeRAID 4H",
  342.    "ServeRAID 4M",
  343.    "ServeRAID 4L",
  344.    "ServeRAID 4Mx",
  345.    "ServeRAID 4Lx",
  346.    "ServeRAID 5i",
  347.    "ServeRAID 5i"
  348. };
  350. static struct notifier_block ips_notifier = {
  351.    ips_halt, NULL, 0
  352. };
  354. /*
  355.  * Direction table
  356.  */
  357. static char ips_command_direction[] = {
  358. IPS_DATA_NONE, IPS_DATA_NONE, IPS_DATA_IN,   IPS_DATA_IN,   IPS_DATA_OUT,
  359. IPS_DATA_IN,   IPS_DATA_IN,   IPS_DATA_OUT,  IPS_DATA_IN,   IPS_DATA_UNK,
  360. IPS_DATA_OUT,  IPS_DATA_OUT,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,
  361. IPS_DATA_IN,   IPS_DATA_NONE, IPS_DATA_NONE, IPS_DATA_IN,   IPS_DATA_OUT,
  362. IPS_DATA_IN,   IPS_DATA_OUT,  IPS_DATA_NONE, IPS_DATA_NONE, IPS_DATA_OUT,
  363. IPS_DATA_NONE, IPS_DATA_IN,   IPS_DATA_NONE, IPS_DATA_IN,   IPS_DATA_OUT,
  364. IPS_DATA_NONE, IPS_DATA_UNK,  IPS_DATA_IN,   IPS_DATA_UNK,  IPS_DATA_IN,
  365. IPS_DATA_UNK,  IPS_DATA_OUT,  IPS_DATA_IN,   IPS_DATA_UNK,  IPS_DATA_UNK,
  366. IPS_DATA_IN,   IPS_DATA_IN,   IPS_DATA_OUT,  IPS_DATA_NONE, IPS_DATA_UNK,
  367. IPS_DATA_IN,   IPS_DATA_OUT,  IPS_DATA_OUT,  IPS_DATA_OUT,  IPS_DATA_OUT,
  368. IPS_DATA_OUT,  IPS_DATA_NONE, IPS_DATA_IN,   IPS_DATA_NONE, IPS_DATA_NONE,
  369. IPS_DATA_IN,   IPS_DATA_OUT,  IPS_DATA_OUT,  IPS_DATA_OUT,  IPS_DATA_OUT,
  370. IPS_DATA_IN,   IPS_DATA_OUT,  IPS_DATA_IN,   IPS_DATA_OUT,  IPS_DATA_OUT,
  371. IPS_DATA_OUT,  IPS_DATA_IN,   IPS_DATA_IN,   IPS_DATA_IN,   IPS_DATA_NONE,
  372. IPS_DATA_UNK,  IPS_DATA_NONE, IPS_DATA_NONE, IPS_DATA_NONE, IPS_DATA_UNK,
  373. IPS_DATA_NONE, IPS_DATA_OUT,  IPS_DATA_IN,   IPS_DATA_UNK,  IPS_DATA_UNK,
  374. IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,
  375. IPS_DATA_OUT,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,
  376. IPS_DATA_IN,   IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,
  377. IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,
  378. IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,
  379. IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,
  380. IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,
  381. IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,
  382. IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,
  383. IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,
  384. IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,
  385. IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,
  386. IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,
  387. IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,
  388. IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,
  389. IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,
  390. IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,
  391. IPS_DATA_NONE, IPS_DATA_NONE, IPS_DATA_UNK,  IPS_DATA_IN,   IPS_DATA_NONE,
  392. IPS_DATA_OUT,  IPS_DATA_UNK,  IPS_DATA_NONE, IPS_DATA_UNK,  IPS_DATA_OUT,
  393. IPS_DATA_OUT,  IPS_DATA_OUT,  IPS_DATA_OUT,  IPS_DATA_OUT,  IPS_DATA_NONE,
  394. IPS_DATA_UNK,  IPS_DATA_IN,   IPS_DATA_OUT,  IPS_DATA_IN,   IPS_DATA_IN,
  395. IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,
  396. IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,
  397. IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,
  398. IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,
  399. IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,
  400. IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,
  401. IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,
  402. IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,
  403. IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,
  404. IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_OUT,
  405. IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,
  406. IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,
  407. IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,
  408. IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK
  409. };
  411. /*
  412.  * Function prototypes
  413.  */
  414. int ips_detect(Scsi_Host_Template *);
  415. int ips_release(struct Scsi_Host *);
  416. int ips_eh_abort(Scsi_Cmnd *);
  417. int ips_eh_reset(Scsi_Cmnd *);
  418. int ips_queue(Scsi_Cmnd *, void (*) (Scsi_Cmnd *));
  419. int ips_biosparam(Disk *, kdev_t, int *);
  420. const char * ips_info(struct Scsi_Host *);
  421. void do_ipsintr(int, void *, struct pt_regs *);
  422. static int ips_hainit(ips_ha_t *);
  423. static int ips_map_status(ips_ha_t *, ips_scb_t *, ips_stat_t *);
  424. static int ips_send_wait(ips_ha_t *, ips_scb_t *, int, int);
  425. static int ips_send_cmd(ips_ha_t *, ips_scb_t *);
  426. static int ips_online(ips_ha_t *, ips_scb_t *);
  427. static int ips_inquiry(ips_ha_t *, ips_scb_t *);
  428. static int ips_rdcap(ips_ha_t *, ips_scb_t *);
  429. static int ips_msense(ips_ha_t *, ips_scb_t *);
  430. static int ips_reqsen(ips_ha_t *, ips_scb_t *);
  431. static int ips_deallocatescbs(ips_ha_t *, int);
  432. static int ips_allocatescbs(ips_ha_t *);
  433. static int ips_reset_copperhead(ips_ha_t *);
  434. static int ips_reset_copperhead_memio(ips_ha_t *);
  435. static int ips_reset_morpheus(ips_ha_t *);
  436. static int ips_issue_copperhead(ips_ha_t *, ips_scb_t *);
  437. static int ips_issue_copperhead_memio(ips_ha_t *, ips_scb_t *);
  438. static int ips_issue_i2o(ips_ha_t *, ips_scb_t *);
  439. static int ips_issue_i2o_memio(ips_ha_t *, ips_scb_t *);
  440. static int ips_isintr_copperhead(ips_ha_t *);
  441. static int ips_isintr_copperhead_memio(ips_ha_t *);
  442. static int ips_isintr_morpheus(ips_ha_t *);
  443. static int ips_wait(ips_ha_t *, int, int);
  444. static int ips_write_driver_status(ips_ha_t *, int);
  445. static int ips_read_adapter_status(ips_ha_t *, int);
  446. static int ips_read_subsystem_parameters(ips_ha_t *, int);
  447. static int ips_read_config(ips_ha_t *, int);
  448. static int ips_clear_adapter(ips_ha_t *, int);
  449. static int ips_readwrite_page5(ips_ha_t *, int, int);
  450. static int ips_init_copperhead(ips_ha_t *);
  451. static int ips_init_copperhead_memio(ips_ha_t *);
  452. static int ips_init_morpheus(ips_ha_t *);
  453. static int ips_isinit_copperhead(ips_ha_t *);
  454. static int ips_isinit_copperhead_memio(ips_ha_t *);
  455. static int ips_isinit_morpheus(ips_ha_t *);
  456. static int ips_erase_bios(ips_ha_t *);
  457. static int ips_program_bios(ips_ha_t *, char *, uint32_t, uint32_t);
  458. static int ips_verify_bios(ips_ha_t *, char *, uint32_t, uint32_t);
  459. static int ips_erase_bios_memio(ips_ha_t *);
  460. static int ips_program_bios_memio(ips_ha_t *, char *, uint32_t, uint32_t);
  461. static int ips_verify_bios_memio(ips_ha_t *, char *, uint32_t, uint32_t);
  462. static int ips_flash_copperhead(ips_ha_t *, ips_passthru_t *, ips_scb_t *);
  463. static int ips_flash_bios(ips_ha_t *, ips_passthru_t *, ips_scb_t *);
  464. static int ips_flash_firmware(ips_ha_t *, ips_passthru_t *, ips_scb_t *);
  465. static void ips_free_flash_copperhead(ips_ha_t *ha);
  466. static void ips_get_bios_version(ips_ha_t *, int);
  467. static void ips_identify_controller(ips_ha_t *);
  468. static void ips_select_queue_depth(struct Scsi_Host *, Scsi_Device *);
  469. static void ips_chkstatus(ips_ha_t *, IPS_STATUS *);
  470. static void ips_enable_int_copperhead(ips_ha_t *);
  471. static void ips_enable_int_copperhead_memio(ips_ha_t *);
  472. static void ips_enable_int_morpheus(ips_ha_t *);
  473. static void ips_intr_copperhead(ips_ha_t *);
  474. static void ips_intr_morpheus(ips_ha_t *);
  475. static void ips_next(ips_ha_t *, int);
  476. static void ipsintr_blocking(ips_ha_t *, struct ips_scb *);
  477. static void ipsintr_done(ips_ha_t *, struct ips_scb *);
  478. static void ips_done(ips_ha_t *, ips_scb_t *);
  479. static void ips_free(ips_ha_t *);
  480. static void ips_init_scb(ips_ha_t *, ips_scb_t *);
  481. static void ips_freescb(ips_ha_t *, ips_scb_t *);
  482. static void ips_statinit(ips_ha_t *);
  483. static void ips_statinit_memio(ips_ha_t *);
  484. static void ips_fix_ffdc_time(ips_ha_t *, ips_scb_t *, time_t);
  485. static void ips_ffdc_reset(ips_ha_t *, int);
  486. static void ips_ffdc_time(ips_ha_t *);
  487. static uint32_t ips_statupd_copperhead(ips_ha_t *);
  488. static uint32_t ips_statupd_copperhead_memio(ips_ha_t *);
  489. static uint32_t ips_statupd_morpheus(ips_ha_t *);
  490. static ips_scb_t * ips_getscb(ips_ha_t *);
  491. static inline void ips_putq_scb_head(ips_scb_queue_t *, ips_scb_t *);
  492. static inline void ips_putq_scb_tail(ips_scb_queue_t *, ips_scb_t *);
  493. static inline void ips_putq_wait_head(ips_wait_queue_t *, Scsi_Cmnd *);
  494. static inline void ips_putq_wait_tail(ips_wait_queue_t *, Scsi_Cmnd *);
  495. static inline void ips_putq_copp_head(ips_copp_queue_t *, ips_copp_wait_item_t *);
  496. static inline void ips_putq_copp_tail(ips_copp_queue_t *, ips_copp_wait_item_t *);
  497. static inline ips_scb_t * ips_removeq_scb_head(ips_scb_queue_t *);
  498. static inline ips_scb_t * ips_removeq_scb(ips_scb_queue_t *, ips_scb_t *);
  499. static inline Scsi_Cmnd * ips_removeq_wait_head(ips_wait_queue_t *);
  500. static inline Scsi_Cmnd * ips_removeq_wait(ips_wait_queue_t *, Scsi_Cmnd *);
  501. static inline ips_copp_wait_item_t * ips_removeq_copp(ips_copp_queue_t *, ips_copp_wait_item_t *);
  502. static inline ips_copp_wait_item_t * ips_removeq_copp_head(ips_copp_queue_t *);
  504. static int ips_is_passthru(Scsi_Cmnd *);
  505. static int ips_make_passthru(ips_ha_t *, Scsi_Cmnd *, ips_scb_t *, int);
  506. static int ips_usrcmd(ips_ha_t *, ips_passthru_t *, ips_scb_t *);
  507. static void ips_cleanup_passthru(ips_ha_t *, ips_scb_t *);
  509. int  ips_proc_info(char *, char **, off_t, int, int, int);
  510. static int ips_host_info(ips_ha_t *, char *, off_t, int);
  511. static void copy_mem_info(IPS_INFOSTR *, char *, int);
  512. static int copy_info(IPS_INFOSTR *, char *, ...);
  513. static int ips_get_version_info(ips_ha_t *ha, IPS_VERSION_DATA *Buffer, int intr );
  514. static void ips_version_check(ips_ha_t *ha, int intr);
  515. static int ips_init_phase2( int index );
  517. #if LINUX_VERSION_CODE >= LinuxVersionCode(2,4,0)
  518. static int ips_init_phase1( struct pci_dev *pci_dev, int *indexPtr );
  519. #endif
  521. /*--------------------------------------------------------------------------*/
  522. /* Exported Functions                                                       */
  523. /*--------------------------------------------------------------------------*/
  525. /****************************************************************************/
  526. /*                                                                          */
  527. /* Routine Name: ips_setup                                                  */
  528. /*                                                                          */
  529. /* Routine Description:                                                     */
  530. /*                                                                          */
  531. /*   setup parameters to the driver                                         */
  532. /*                                                                          */
  533. /****************************************************************************/
  534. #if LINUX_VERSION_CODE >= LinuxVersionCode(2,4,0)
  535. static int
  536. ips_setup(char *ips_str) {
  537. #else
  538. void
  539. ips_setup(char *ips_str, int *dummy) {
  540. #endif
  542.    int        i;
  543.    char      *key;
  544.    char      *value;
  545.    IPS_OPTION options[] = {
  546.       {"noi2o", &ips_force_i2o, 0},
  547.       {"nommap", &ips_force_memio, 0},
  548.       {"ioctlsize", &ips_ioctlsize, IPS_IOCTL_SIZE},
  549.       {"cdboot", &ips_cd_boot, 0},
  550.       {"maxcmds", &MaxLiteCmds, 32},
  551.    };
  552.     
  553.    /* Don't use strtok() anymore ( if 2.4 Kernel or beyond ) */
  554. #if LINUX_VERSION_CODE >= LinuxVersionCode(2,4,0)
  555.    /* Search for value */
  556.    while ((key = strsep(&ips_str, ",."))) {
  557.       if (!*key)
  558.          continue;
  559.       value = strchr(key, ':');
  560.       if (value)
  561.          *value++ = '';
  562.      /*
  563.       * We now have key/value pairs.
  564.       * Update the variables
  565.       */
  566.       for (i = 0; i < (sizeof(options) / sizeof(options[0])); i++) {
  567.         if (strnicmp(key, options[i].option_name, strlen(options[i].option_name)) == 0) {
  568.            if (value)
  569.               *options[i].option_flag = simple_strtoul(value, NULL, 0);
  570.            else
  571.               *options[i].option_flag = options[i].option_value;
  572.            break;
  573.         }
  574.       }
  575.    }
  577.    return (1);
  579. #else
  581.   char      *p;
  582.    char       tokens[3] = {',', '.', 0};
  584.    for (key = strtok(ips_str, tokens); key; key = strtok(NULL, tokens)) {
  585.       p = key;
  587.       /* Search for value */
  588.       while ((p) && (*p != ':'))
  589.          p++;
  591.       if (p) {
  592.          *p = '';
  593.          value = p+1;
  594.       } else
  595.          value = NULL;
  597.       /*
  598.        * We now have key/value pairs.
  599.        * Update the variables
  600.        */
  601.       for (i = 0; i < (sizeof(options) / sizeof(options[0])); i++) {
  602.          if (strnicmp(key, options[i].option_name, strlen(ips_str)) == 0) {
  603.             if (value)
  604.                *options[i].option_flag = simple_strtoul(value, NULL, 0);
  605.             else
  606.                *options[i].option_flag = options[i].option_value;
  608.             break;
  609.          }
  610.       }
  611.    }
  613. #endif
  615. }
  617. #if LINUX_VERSION_CODE >= LinuxVersionCode(2,4,0)
  618. __setup("ips=", ips_setup);
  619. #endif
  621. /****************************************************************************/
  622. /*                                                                          */
  623. /* Routine Name: ips_detect                                                 */
  624. /*                                                                          */
  625. /* Routine Description:                                                     */
  626. /*                                                                          */
  627. /*   Detect and initialize the driver                                       */
  628. /*                                                                          */
  629. /* NOTE: this routine is called under the io_request_lock spinlock          */
  630. /*                                                                          */
  631. /****************************************************************************/
  632. int
  633. ips_detect(Scsi_Host_Template *SHT) {
  634.    struct Scsi_Host *sh;
  635.    ips_ha_t         *ha;
  636.    uint32_t          io_addr;
  637.    uint32_t          mem_addr;
  638.    uint32_t          io_len;
  639.    uint32_t          mem_len;
  640.    uint16_t          planer;
  641.    uint8_t           revision_id;
  642.    uint8_t           bus;
  643.    uint8_t           func;
  644.    uint8_t           irq;
  645.    uint16_t          deviceID[2];
  646.    uint16_t          subdevice_id;
  647.    int               i;
  648.    int               j;
  649.    uint32_t          count;
  650.    char             *ioremap_ptr;
  651.    char             *mem_ptr;
  652.    struct pci_dev   *dev[2];
  653.    struct pci_dev   *morpheus = NULL;
  654.    struct pci_dev   *trombone = NULL;
  655. #if LINUX_VERSION_CODE < LinuxVersionCode(2,4,0)
  656.    uint32_t          currbar;
  657.    uint32_t          maskbar;
  658.    uint8_t           barnum;
  659. #endif
  660.    uint32_t          IsDead;
  662.    METHOD_TRACE("ips_detect", 1);
  664. #ifdef MODULE
  665.    if (ips)
  666. #if LINUX_VERSION_CODE >= LinuxVersionCode(2,4,0)
  667.       ips_setup(ips);
  668. #else
  669.       ips_setup(ips, NULL);
  670. #endif
  671. #endif
  673.    /* If Booting from the ServeRAID Manager CD, Allocate a large Flash  */
  674.    /* Buffer ( so we won't need to allocate one for each adapter ).     */
  675.     if ( ips_cd_boot ) {            
  676.       ips_FlashData = ( char * ) __get_free_pages( GFP_KERNEL, 7 );   
  677.       if (ips_FlashData == NULL) {
  678.          /* The validity of this pointer is checked in ips_make_passthru() before it is used */
  679.          printk( KERN_WARNING "ERROR: Can't Allocate Large Buffer for Flashingn" );
  680.       }
  681.    }                                                                               
  683.    SHT->proc_info = ips_proc_info;
  684. #if LINUX_VERSION_CODE < LinuxVersionCode(2,4,0)
  685.    SHT->proc_dir = &proc_scsi_ips;
  686. #else
  687.    SHT->proc_name = "ips";
  688. #endif
  690. #if defined(CONFIG_PCI)
  692.    /* initalize number of controllers */
  693.    ips_num_controllers = 0;
  694.    ips_next_controller = 0;
  695.    ips_released_controllers = 0;
  697.    if (!pci_present())
  698.       return (0);
  700.    morpheus = pci_find_device(IPS_VENDORID, IPS_DEVICEID_MORPHEUS, morpheus);
  701.    trombone = pci_find_device(IPS_VENDORID, IPS_DEVICEID_COPPERHEAD, trombone);
  703.    /* determine which controller to probe first */
  704.    if (!morpheus) {
  705.       /* we only have trombone */
  706.       dev[0] = trombone;
  707.       dev[1] = NULL;
  708.       deviceID[0] = IPS_DEVICEID_COPPERHEAD;
  709.    } else if (!trombone) {
  710.       /* we only have morpheus */
  711.       dev[0] = morpheus;
  712.       dev[1] = NULL;
  713.       deviceID[0] = IPS_DEVICEID_MORPHEUS;
  714.    } else {
  715.       /* we have both in the system */
  716.       if (trombone->bus->number < morpheus->bus->number) {
  717.          dev[0] = trombone;
  718.          dev[1] = morpheus;
  719.          deviceID[0] = IPS_DEVICEID_COPPERHEAD;
  720.          deviceID[1] = IPS_DEVICEID_MORPHEUS;
  721.       } else if (trombone->bus->number > morpheus->bus->number) {
  722.          dev[0] = morpheus;
  723.          dev[1] = trombone;
  724.          deviceID[0] = IPS_DEVICEID_MORPHEUS;
  725.          deviceID[1] = IPS_DEVICEID_COPPERHEAD;
  726.       } else {
  727.          /* further detection required */
  728.          if (trombone->devfn < morpheus->devfn) {
  729.             dev[0] = trombone;
  730.             dev[1] = morpheus;
  731.             deviceID[0] = IPS_DEVICEID_COPPERHEAD;
  732.             deviceID[1] = IPS_DEVICEID_MORPHEUS;
  733.          } else {
  734.             dev[0] = morpheus;
  735.             dev[1] = trombone;
  736.             deviceID[0] = IPS_DEVICEID_MORPHEUS;
  737.             deviceID[1] = IPS_DEVICEID_COPPERHEAD;
  738.          }
  739.       }
  740.    }
  742. /**********************************************************************************/
  743. /* For Kernel Versions 2.4 or greater, use new PCI ( Hot Pluggable ) architecture */
  744. /**********************************************************************************/
  746. #if LINUX_VERSION_CODE >= LinuxVersionCode(2,4,0)
  747.    spin_unlock_irq(&io_request_lock);
  749.    /* By definition, a Sarasota ( 5i ) Adapter MUST be enumerated first or the */
  750.    /* server may not boot properly. The adapters must be enumerated in exactly */
  751.    /* the same order as ServeRAID BIOS for the machine to come up properly.    */
  753.    pci_module_init(&ips_pci_driver_5i);          /* Ask for 5i Adapters First  */
  754.    if (ips_num_controllers)                      /* If there is a 5i Adapter   */
  755.       pci_module_init(&ips_pci_driver_i960);     /*    Get all i960's next     */
  756.    pci_module_init(&ips_pci_driver);             /* Get all remaining Adapters */
  757.                                                  /*  ( in normal BUS order )   */
  758.    spin_lock_irq(&io_request_lock);
  759.    if (ips_num_controllers > 0) 
  760.       register_reboot_notifier(&ips_notifier);
  762.    return (ips_num_controllers);
  763. #endif
  765.    /* Now scan the controllers */
  766.    for (i = 0; i < 2; i++) {
  767.       if (!dev[i])
  768.          break;
  770.       do {
  771.          if (ips_next_controller >= IPS_MAX_ADAPTERS)
  772.             break;
  774. #if LINUX_VERSION_CODE >= LinuxVersionCode(2,4,0)
  775.          if (pci_enable_device(dev[i]))
  776.             break;
  777. #endif
  779.          /* stuff that we get in dev */
  780.          irq = dev[i]->irq;
  781.          bus = dev[i]->bus->number;
  782.          func = dev[i]->devfn;
  784.          /* Init MEM/IO addresses to 0 */
  785.          mem_addr = 0;
  786.          io_addr = 0;
  787.          mem_len = 0;
  788.          io_len = 0;
  790.          for (j = 0; j < 2; j++) {
  791. #if LINUX_VERSION_CODE >= LinuxVersionCode(2,4,0)
  792.             if (!pci_resource_start(dev[i], j))
  793.                break;
  795.             if (pci_resource_flags(dev[i], j) & IORESOURCE_IO) {
  796.                io_addr = pci_resource_start(dev[i], j);
  797.                io_len = pci_resource_len(dev[i], j);
  798.             } else {
  799.                mem_addr = pci_resource_start(dev[i], j);
  800.                mem_len = pci_resource_len(dev[i], j);
  801.             }
  802. #else
  803.             if (!dev[i]->base_address[j])
  804.                break;
  806.             if ((dev[i]->base_address[j] & PCI_BASE_ADDRESS_SPACE) == PCI_BASE_ADDRESS_SPACE_IO) {
  807.                barnum = PCI_BASE_ADDRESS_0 + (j * 4);
  808.                io_addr = dev[i]->base_address[j] & PCI_BASE_ADDRESS_IO_MASK;
  810.                /* Get Size */
  811.                pci_read_config_dword(dev[i], barnum, &currbar);
  812.                pci_write_config_dword(dev[i], barnum, ~0);
  813.                pci_read_config_dword(dev[i], barnum, &maskbar);
  814.                pci_write_config_dword(dev[i], barnum, currbar);
  816.                io_len = ~(maskbar & PCI_BASE_ADDRESS_IO_MASK) + 1;
  817.             } else {
  818.                barnum = PCI_BASE_ADDRESS_0 + (j * 4);
  819.                mem_addr = dev[i]->base_address[j] & PCI_BASE_ADDRESS_MEM_MASK;
  821.                /* Get Size */
  822.                pci_read_config_dword(dev[i], barnum, &currbar);
  823.                pci_write_config_dword(dev[i], barnum, ~0);
  824.                pci_read_config_dword(dev[i], barnum, &maskbar);
  825.                pci_write_config_dword(dev[i], barnum, currbar);
  827.                mem_len = ~(maskbar & PCI_BASE_ADDRESS_MEM_MASK) + 1;
  828.             }
  829. #endif
  830.          }
  832.          /* setup memory mapped area (if applicable) */
  833.          if (mem_addr) {
  834.             uint32_t base;
  835.             uint32_t offs;
  837.             DEBUG_VAR(1, "(%s%d) detect, Memory region %x, size: %d",
  838.                       ips_name, ips_next_controller, mem_addr, mem_len);
  840. #if LINUX_VERSION_CODE >= LinuxVersionCode(2,4,0)
  841.             if (check_mem_region(mem_addr, mem_len)) {
  842.                /* Couldn't allocate io space */
  843.                printk(KERN_WARNING "(%s%d) couldn't allocate IO space %x len %d.n",
  844.                       ips_name, ips_next_controller, io_addr, io_len);
  846.                ips_next_controller++;
  848.                continue;
  849.             }
  851.             request_mem_region(mem_addr, mem_len, "ips");
  852. #endif
  854.             base = mem_addr & PAGE_MASK;
  855.             offs = mem_addr - base;
  857.             ioremap_ptr = ioremap(base, PAGE_SIZE);
  858.             mem_ptr = ioremap_ptr + offs;
  859.          } else {
  860.             ioremap_ptr = NULL;
  861.             mem_ptr = NULL;
  862.          }
  864.          /* setup I/O mapped area (if applicable) */
  865.          if (io_addr) {
  866.             DEBUG_VAR(1, "(%s%d) detect, IO region %x, size: %d",
  867.                       ips_name, ips_next_controller, io_addr, io_len);
  869.             if (check_region(io_addr, io_len)) {
  870.                /* Couldn't allocate io space */
  871.                printk(KERN_WARNING "(%s%d) couldn't allocate IO space %x len %d.n",
  872.                       ips_name, ips_next_controller, io_addr, io_len);
  874.                ips_next_controller++;
  876.                continue;
  877.             }
  879.             request_region(io_addr, io_len, "ips");
  880.          }
  882.          /* get planer status */
  883.          if (pci_read_config_word(dev[i], 0x04, &planer)) {
  884.             printk(KERN_WARNING "(%s%d) can't get planer status.n",
  885.                    ips_name, ips_next_controller);
  887.             ips_next_controller++;
  889.             continue;
  890.          }
  892.          /* check to see if an onboard planer controller is disabled */
  893.          if (!(planer & 0x000C)) {
  895.             DEBUG_VAR(1, "(%s%d) detect, Onboard ServeRAID disabled by BIOS",
  896.                       ips_name, ips_next_controller);
  898.             ips_next_controller++;
  900.             continue;
  901.          }
  903.          DEBUG_VAR(1, "(%s%d) detect bus %d, func %x, irq %d, io %x, mem: %x, ptr: %p",
  904.                    ips_name, ips_next_controller, bus, func, irq, io_addr, mem_addr, mem_ptr);
  906.          /* get the revision ID */
  907.          if (pci_read_config_byte(dev[i], PCI_REVISION_ID, &revision_id)) {
  908.             printk(KERN_WARNING "(%s%d) can't get revision id.n",
  909.                    ips_name, ips_next_controller);
  911.             ips_next_controller++;
  913.             continue;
  914.          }
  916. #if LINUX_VERSION_CODE < LinuxVersionCode(2,4,0)
  917.          /* get the subdevice id */
  918.          if (pci_read_config_word(dev[i], PCI_SUBSYSTEM_ID, &subdevice_id)) {
  919.             printk(KERN_WARNING "(%s%d) can't get subdevice id.n",
  920.                    ips_name, ips_next_controller);
  922.             ips_next_controller++;
  924.             continue;
  925.          }
  926. #else
  927.          subdevice_id = dev[i]->subsystem_device;
  928. #endif
  930.          /* found a controller */
  931.          sh = scsi_register(SHT, sizeof(ips_ha_t));
  933.          if (sh == NULL) {
  934.             printk(KERN_WARNING "(%s%d) Unable to register controller with SCSI subsystem - skipping controllern",
  935.                    ips_name, ips_next_controller);
  937.             ips_next_controller++;
  939.             continue;
  940.          }
  942.          ha = IPS_HA(sh);
  943.          memset(ha, 0, sizeof(ips_ha_t));
  945.          /* Initialize spin lock */
  946.          spin_lock_init(&ha->scb_lock);
  947.          spin_lock_init(&ha->copp_lock);
  948.          spin_lock_init(&ha->ips_lock);
  949.          spin_lock_init(&ha->copp_waitlist.lock);
  950.          spin_lock_init(&ha->scb_waitlist.lock);
  951.          spin_lock_init(&ha->scb_activelist.lock);
  953.          ips_sh[ips_next_controller] = sh;
  954.          ips_ha[ips_next_controller] = ha;
  955.          ips_num_controllers++;
  956.          ha->active = 1;
  958.          ha->enq = kmalloc(sizeof(IPS_ENQ), GFP_KERNEL);
  960.          if (!ha->enq) {
  961.             printk(KERN_WARNING "(%s%d) Unable to allocate host inquiry structure - skipping contollern",
  962.                    ips_name, ips_next_controller);
  964.             ha->active = 0;
  965.             ips_free(ha);
  966.             scsi_unregister(sh);
  967.             ips_ha[ips_next_controller] = 0;
  968.             ips_sh[ips_next_controller] = 0;
  969.             ips_next_controller++;
  970.             ips_num_controllers--;
  972.             continue;
  973.          }
  975.          ha->adapt = kmalloc(sizeof(IPS_ADAPTER), GFP_KERNEL);
  977.          if (!ha->adapt) {
  978.             printk(KERN_WARNING "(%s%d) Unable to allocate host adapt structure - skipping controllern",
  979.                    ips_name, ips_next_controller);
  981.             ha->active = 0;
  982.             ips_free(ha);
  983.             scsi_unregister(sh);
  984.             ips_ha[ips_next_controller] = 0;
  985.             ips_sh[ips_next_controller] = 0;
  986.             ips_next_controller++;
  987.             ips_num_controllers--;
  989.             continue;
  990.          }
  992.          ha->conf = kmalloc(sizeof(IPS_CONF), GFP_KERNEL);
  994.          if (!ha->conf) {
  995.             printk(KERN_WARNING "(%s%d) Unable to allocate host conf structure - skipping controllern",
  996.                    ips_name, ips_next_controller);
  998.             ha->active = 0;
  999.             ips_free(ha);
  1000.             scsi_unregister(sh);
  1001.             ips_ha[ips_next_controller] = 0;
  1002.             ips_sh[ips_next_controller] = 0;
  1003.             ips_next_controller++;
  1004.             ips_num_controllers--;
  1006.             continue;
  1007.          }
  1009.          ha->nvram = kmalloc(sizeof(IPS_NVRAM_P5), GFP_KERNEL);
  1011.          if (!ha->nvram) {
  1012.             printk(KERN_WARNING "(%s%d) Unable to allocate host nvram structure - skipping controllern",
  1013.                    ips_name, ips_next_controller);
  1015.             ha->active = 0;
  1016.             ips_free(ha);
  1017.             scsi_unregister(sh);
  1018.             ips_ha[ips_next_controller] = 0;
  1019.             ips_sh[ips_next_controller] = 0;
  1020.             ips_next_controller++;
  1021.             ips_num_controllers--;
  1023.             continue;
  1024.          }
  1026.          ha->subsys = kmalloc(sizeof(IPS_SUBSYS), GFP_KERNEL);
  1028.          if (!ha->subsys) {
  1029.             printk(KERN_WARNING "(%s%d) Unable to allocate host subsystem structure - skipping controllern",
  1030.                    ips_name, ips_next_controller);
  1032.             ha->active = 0;
  1033.             ips_free(ha);
  1034.             scsi_unregister(sh);
  1035.             ips_ha[ips_next_controller] = 0;
  1036.             ips_sh[ips_next_controller] = 0;
  1037.             ips_next_controller++;
  1038.             ips_num_controllers--;
  1040.             continue;
  1041.          }
  1043.          ha->dummy = kmalloc(sizeof(IPS_IO_CMD), GFP_KERNEL);
  1045.          if (!ha->dummy) {
  1046.             printk(KERN_WARNING "(%s%d) Unable to allocate host dummy structure - skipping controllern",
  1047.                    ips_name, ips_next_controller);
  1049.             ha->active = 0;
  1050.             ips_free(ha);
  1051.             scsi_unregister(sh);
  1052.             ips_ha[ips_next_controller] = 0;
  1053.             ips_sh[ips_next_controller] = 0;
  1054.             ips_next_controller++;
  1055.             ips_num_controllers--;
  1057.             continue;
  1058.          }
  1060.          for (count = PAGE_SIZE, ha->ioctl_order = 0;
  1061.               count < ips_ioctlsize;
  1062.               ha->ioctl_order++, count <<= 1);
  1064.          ha->ioctl_data = (char *) __get_free_pages(GFP_KERNEL, ha->ioctl_order);
  1065.          ha->ioctl_datasize = count;
  1067.          if (!ha->ioctl_data) {
  1068.             printk(KERN_WARNING "(%s%d) Unable to allocate ioctl datan",
  1069.                    ips_name, ips_next_controller);
  1071.             ha->ioctl_data = NULL;
  1072.             ha->ioctl_order = 0;
  1073.             ha->ioctl_datasize = 0;
  1074.          }
  1076.          /* Store away needed values for later use */
  1077.          sh->io_port = io_addr;
  1078.          sh->n_io_port = io_addr ? 255 : 0;
  1079.          sh->unique_id = (io_addr) ? io_addr : mem_addr;
  1080.          sh->irq = irq;
  1081.          sh->select_queue_depths = ips_select_queue_depth;
  1082.          sh->sg_tablesize = sh->hostt->sg_tablesize;
  1083.          sh->can_queue = sh->hostt->can_queue;
  1084.          sh->cmd_per_lun = sh->hostt->cmd_per_lun;
  1085.          sh->unchecked_isa_dma = sh->hostt->unchecked_isa_dma;
  1086.          sh->use_clustering = sh->hostt->use_clustering;
  1088. #if LINUX_VERSION_CODE >= LinuxVersionCode(2,4,7)
  1089.          sh->max_sectors = 128;
  1090. #endif                      
  1092. #if LINUX_VERSION_CODE < LinuxVersionCode(2,4,0)
  1093.          sh->wish_block = FALSE;
  1094. #endif
  1096.          /* Store info in HA structure */
  1097.          ha->irq = irq;
  1098.          ha->io_addr = io_addr;
  1099.          ha->io_len = io_len;
  1100.          ha->mem_addr = mem_addr;
  1101.          ha->mem_len = mem_len;
  1102.          ha->mem_ptr = mem_ptr;
  1103.          ha->ioremap_ptr = ioremap_ptr;
  1104.          ha->host_num = ips_next_controller;
  1105.          ha->revision_id = revision_id;
  1106.          ha->slot_num = PCI_SLOT(dev[i]->devfn);
  1107.          ha->device_id = deviceID[i];
  1108.          ha->subdevice_id = subdevice_id;
  1109.          ha->pcidev = dev[i];
  1111.          /*
  1112.           * Setup Functions
  1113.           */
  1114.          if (IPS_IS_MORPHEUS(ha)) {
  1115.             /* morpheus */
  1116.             ha->func.isintr = ips_isintr_morpheus;
  1117.             ha->func.isinit = ips_isinit_morpheus;
  1118.             ha->func.issue = ips_issue_i2o_memio;
  1119.             ha->func.init = ips_init_morpheus;
  1120.             ha->func.statupd = ips_statupd_morpheus;
  1121.             ha->func.reset = ips_reset_morpheus;
  1122.             ha->func.intr = ips_intr_morpheus;
  1123.             ha->func.enableint = ips_enable_int_morpheus;
  1124.          } else if (IPS_USE_MEMIO(ha)) {
  1125.             /* copperhead w/MEMIO */
  1126.             ha->func.isintr = ips_isintr_copperhead_memio;
  1127.             ha->func.isinit = ips_isinit_copperhead_memio;
  1128.             ha->func.init = ips_init_copperhead_memio;
  1129.             ha->func.statupd = ips_statupd_copperhead_memio;
  1130.             ha->func.statinit = ips_statinit_memio;
  1131.             ha->func.reset = ips_reset_copperhead_memio;
  1132.             ha->func.intr = ips_intr_copperhead;
  1133.             ha->func.erasebios = ips_erase_bios_memio;
  1134.             ha->func.programbios = ips_program_bios_memio;
  1135.             ha->func.verifybios = ips_verify_bios_memio;
  1136.             ha->func.enableint = ips_enable_int_copperhead_memio;
  1138.             if (IPS_USE_I2O_DELIVER(ha))
  1139.                ha->func.issue = ips_issue_i2o_memio;
  1140.             else
  1141.                ha->func.issue = ips_issue_copperhead_memio;
  1142.          } else {
  1143.             /* copperhead */
  1144.             ha->func.isintr = ips_isintr_copperhead;
  1145.             ha->func.isinit = ips_isinit_copperhead;
  1146.             ha->func.init = ips_init_copperhead;
  1147.             ha->func.statupd = ips_statupd_copperhead;
  1148.             ha->func.statinit = ips_statinit;
  1149.             ha->func.reset = ips_reset_copperhead;
  1150.             ha->func.intr = ips_intr_copperhead;
  1151.             ha->func.erasebios = ips_erase_bios;
  1152.             ha->func.programbios = ips_program_bios;
  1153.             ha->func.verifybios = ips_verify_bios;
  1154.             ha->func.enableint = ips_enable_int_copperhead;
  1156.             if (IPS_USE_I2O_DELIVER(ha))
  1157.                ha->func.issue = ips_issue_i2o;
  1158.             else
  1159.                ha->func.issue = ips_issue_copperhead;
  1160.          }
  1161.             
  1162.          /* If Morpheus appears dead, reset it */
  1163.          if ( IPS_IS_MORPHEUS( ha ) ) {
  1164.              IsDead = readl( ha->mem_ptr + IPS_REG_I960_MSG1 );
  1165.              if ( IsDead == 0xDEADBEEF ) {
  1166.                  ips_reset_morpheus( ha );
  1167.              }
  1168.          }
  1170.          /*
  1171.           * Initialize the card if it isn't already
  1172.           */
  1174.          if (!(*ha->func.isinit)(ha)) {
  1175.             if (!(*ha->func.init)(ha)) {
  1176.                /*
  1177.                 * Initialization failed
  1178.                 */
  1179.                printk(KERN_WARNING "(%s%d) unable to initialize controller - skipping controllern",
  1180.                       ips_name, ips_next_controller);
  1182.                ha->active = 0;
  1183.                ips_free(ha);
  1184.                scsi_unregister(sh);
  1185.                ips_ha[ips_next_controller] = 0;
  1186.                ips_sh[ips_next_controller] = 0;
  1187.                ips_next_controller++;
  1188.                ips_num_controllers--;
  1190.                continue;
  1191.             }
  1192.          }
  1194.          /* install the interrupt handler */
  1195.          if (request_irq(irq, do_ipsintr, SA_SHIRQ, ips_name, ha)) {
  1196.             printk(KERN_WARNING "(%s%d) unable to install interrupt handler - skipping controllern",
  1197.                    ips_name, ips_next_controller);
  1199.             ha->active = 0;
  1200.             ips_free(ha);
  1201.             scsi_unregister(sh);
  1202.             ips_ha[ips_next_controller] = 0;
  1203.             ips_sh[ips_next_controller] = 0;
  1204.             ips_next_controller++;
  1205.             ips_num_controllers--;
  1207.             continue;
  1208.          }
  1210.          /*
  1211.           * Allocate a temporary SCB for initialization
  1212.           */
  1213.          ha->max_cmds = 1;
  1214.          if (!ips_allocatescbs(ha)) {
  1215.             /* couldn't allocate a temp SCB */
  1216.             printk(KERN_WARNING "(%s%d) unable to allocate CCBs - skipping contollern",
  1217.                    ips_name, ips_next_controller);
  1219.             ha->active = 0;
  1220.             ips_free(ha);
  1221.             scsi_unregister(sh);
  1222.             ips_ha[ips_next_controller] = 0;
  1223.             ips_sh[ips_next_controller] = 0;
  1224.             free_irq(ha->irq, ha);
  1225.             ips_next_controller++;
  1226.             ips_num_controllers--;
  1228.             continue;
  1229.          }
  1231.          ips_next_controller++;
  1232.       } while ((dev[i] = pci_find_device(IPS_VENDORID, deviceID[i], dev[i])));
  1233.    }
  1235.    /*
  1236.     * Do Phase 2 Initialization
  1237.     * Controller init
  1238.     */
  1239.    for (i = 0; i < ips_next_controller; i++) {
  1241.       if (ips_ha[i] == 0) {
  1242.          printk(KERN_WARNING "(%s%d) ignoring bad controllern", ips_name, i);
  1243.          continue;
  1244.       }
  1246.       if (ips_init_phase2(i) != SUCCESS)
  1247.          ips_num_controllers--;
  1249.    }
  1251.    if (ips_num_controllers > 0)
  1252.       register_reboot_notifier(&ips_notifier);
  1254.    return (ips_num_controllers);
  1256. #else
  1258.    /* No PCI -- No ServeRAID */
  1259.    return (0);
  1260. #endif /* CONFIG_PCI */
  1261. }
  1263. /****************************************************************************/
  1264. /*                                                                          */
  1265. /* Routine Name: ips_release                                                */
  1266. /*                                                                          */
  1267. /* Routine Description:                                                     */
  1268. /*                                                                          */
  1269. /*   Remove a driver                                                        */
  1270. /*                                                                          */
  1271. /****************************************************************************/
  1272. int
  1273. ips_release(struct Scsi_Host *sh) {
  1274.    ips_scb_t *scb;
  1275.    ips_ha_t  *ha;
  1276.    int        i;
  1278.    METHOD_TRACE("ips_release", 1);
  1280.    for (i = 0; i < IPS_MAX_ADAPTERS && ips_sh[i] != sh; i++);
  1282.    if (i == IPS_MAX_ADAPTERS) {
  1283.       printk(KERN_WARNING "(%s) release, invalid Scsi_Host pointer.n",
  1284.             ips_name);
  1285. #if LINUX_VERSION_CODE >= LinuxVersionCode(2,4,0)
  1286.       BUG();
  1287. #endif
  1288.       return (FALSE);
  1289.    }
  1291.    ha = IPS_HA(sh);
  1293.    if (!ha)
  1294.       return (FALSE);
  1296.    /* flush the cache on the controller */
  1297.    scb = &ha->scbs[ha->max_cmds-1];
  1299.    ips_init_scb(ha, scb);
  1301.    scb->timeout = ips_cmd_timeout;
  1302.    scb->cdb[0] = IPS_CMD_FLUSH;
  1304.    scb->cmd.flush_cache.op_code = IPS_CMD_FLUSH;
  1305.    scb->cmd.flush_cache.command_id = IPS_COMMAND_ID(ha, scb);
  1306.    scb->cmd.flush_cache.state = IPS_NORM_STATE;
  1307.    scb->cmd.flush_cache.reserved = 0;
  1308.    scb->cmd.flush_cache.reserved2 = 0;
  1309.    scb->cmd.flush_cache.reserved3 = 0;
  1310.    scb->cmd.flush_cache.reserved4 = 0;
  1312.    printk(KERN_NOTICE "(%s%d) Flushing Cache.n", ips_name, ha->host_num);
  1314.    /* send command */
  1315.    if (ips_send_wait(ha, scb, ips_cmd_timeout, IPS_INTR_ON) == IPS_FAILURE)
  1316.       printk(KERN_NOTICE "(%s%d) Incomplete Flush.n", ips_name, ha->host_num);
  1318.    printk(KERN_NOTICE "(%s%d) Flushing Complete.n", ips_name, ha->host_num);
  1320.    ips_sh[i] = NULL;
  1321.    ips_ha[i] = NULL;
  1323.    /* free extra memory */
  1324.    ips_free(ha);
  1326.    /* Free I/O Region */
  1327.    if (ha->io_addr)
  1328.       release_region(ha->io_addr, ha->io_len);
  1330.    /* free IRQ */
  1331.    free_irq(ha->irq, ha);
  1333.    scsi_unregister(sh);
  1335.    ips_released_controllers++;
  1337.    if (ips_num_controllers == ips_released_controllers){
  1338.       unregister_reboot_notifier(&ips_notifier);
  1339.       pci_unregister_driver(&ips_pci_driver);
  1340.    }
  1341.    return (FALSE);
  1342. }
  1344. /****************************************************************************/
  1345. /*                                                                          */
  1346. /* Routine Name: ips_halt                                                   */
  1347. /*                                                                          */
  1348. /* Routine Description:                                                     */
  1349. /*                                                                          */
  1350. /*   Perform cleanup when the system reboots                                */
  1351. /*                                                                          */
  1352. /****************************************************************************/
  1353. static int
  1354. ips_halt(struct notifier_block *nb, ulong event, void *buf) {
  1355.    ips_scb_t *scb;
  1356.    ips_ha_t  *ha;
  1357.    int        i;
  1359.    if ((event != SYS_RESTART) && (event != SYS_HALT) &&
  1360.        (event != SYS_POWER_OFF))
  1361.       return (NOTIFY_DONE);
  1363.    for (i = 0; i < ips_next_controller; i++) {
  1364.       ha = (ips_ha_t *) ips_ha[i];
  1366.       if (!ha)
  1367.          continue;
  1369.       if (!ha->active)
  1370.          continue;
  1372.       /* flush the cache on the controller */
  1373.       scb = &ha->scbs[ha->max_cmds-1];
  1375.       ips_init_scb(ha, scb);
  1377.       scb->timeout = ips_cmd_timeout;
  1378.       scb->cdb[0] = IPS_CMD_FLUSH;
  1380.       scb->cmd.flush_cache.op_code = IPS_CMD_FLUSH;
  1381.       scb->cmd.flush_cache.command_id = IPS_COMMAND_ID(ha, scb);
  1382.       scb->cmd.flush_cache.state = IPS_NORM_STATE;
  1383.       scb->cmd.flush_cache.reserved = 0;
  1384.       scb->cmd.flush_cache.reserved2 = 0;
  1385.       scb->cmd.flush_cache.reserved3 = 0;
  1386.       scb->cmd.flush_cache.reserved4 = 0;
  1388.       printk(KERN_NOTICE "(%s%d) Flushing Cache.n", ips_name, ha->host_num);
  1390.       /* send command */
  1391.       if (ips_send_wait(ha, scb, ips_cmd_timeout, IPS_INTR_ON) == IPS_FAILURE)
  1392.          printk(KERN_NOTICE "(%s%d) Incomplete Flush.n", ips_name, ha->host_num);
  1393.       else
  1394.          printk(KERN_NOTICE "(%s%d) Flushing Complete.n", ips_name, ha->host_num);
  1395.    }
  1397.    return (NOTIFY_OK);
  1398. }
  1400. /****************************************************************************/
  1401. /*                                                                          */
  1402. /* Routine Name: ips_eh_abort                                               */
  1403. /*                                                                          */
  1404. /* Routine Description:                                                     */
  1405. /*                                                                          */
  1406. /*   Abort a command (using the new error code stuff)                       */
  1407. /*                                                                          */
  1408. /****************************************************************************/
  1409. int
  1410. ips_eh_abort(Scsi_Cmnd *SC) {
  1411.    ips_ha_t         *ha;
  1412.    ips_copp_wait_item_t *item;
  1414.    METHOD_TRACE("ips_eh_abort", 1);
  1416.    if (!SC)
  1417.       return (FAILED);
  1419.    ha = (ips_ha_t *) SC->host->hostdata;
  1421.    if (!ha)
  1422.       return (FAILED);
  1424.    if (!ha->active)
  1425.       return (FAILED);
  1427.    if (SC->serial_number != SC->serial_number_at_timeout) {
  1428.       /* HMM, looks like a bogus command */
  1429.       DEBUG(1, "Abort called with bogus scsi command");
  1431.       return (FAILED);
  1432.    }
  1434.    if (test_and_set_bit(IPS_IN_ABORT, &ha->flags))
  1435.       return (FAILED);
  1437.    /* See if the command is on the copp queue */
  1438.    IPS_QUEUE_LOCK(&ha->copp_waitlist);
  1439.    item = ha->copp_waitlist.head;
  1440.    while ((item) && (item->scsi_cmd != SC))
  1441.       item = item->next;
  1442.    IPS_QUEUE_UNLOCK(&ha->copp_waitlist);
  1444.    if (item) {
  1445.       /* Found it */
  1446.       ips_removeq_copp(&ha->copp_waitlist, item);
  1447.       clear_bit(IPS_IN_ABORT, &ha->flags);
  1449.       return (SUCCESS);
  1450.    }
  1452.    /* See if the command is on the wait queue */
  1453.    if (ips_removeq_wait(&ha->scb_waitlist, SC)) {
  1454.       /* command not sent yet */
  1455.       clear_bit(IPS_IN_ABORT, &ha->flags);
  1457.       return (SUCCESS);
  1458.    } else {
  1459.       /* command must have already been sent */
  1460.       clear_bit(IPS_IN_ABORT, &ha->flags);
  1462.       return (FAILED);
  1463.    }
  1464. }
  1466. /****************************************************************************/
  1467. /*                                                                          */
  1468. /* Routine Name: ips_eh_reset                                               */
  1469. /*                                                                          */
  1470. /* Routine Description:                                                     */
  1471. /*                                                                          */
  1472. /*   Reset the controller (with new eh error code)                          */
  1473. /*                                                                          */
  1474. /* NOTE: this routine is called under the io_request_lock spinlock          */
  1475. /*                                                                          */
  1476. /****************************************************************************/
  1477. int
  1478. ips_eh_reset(Scsi_Cmnd *SC) {
  1479.    int                   ret;
  1480.    int                   i;
  1481.    ips_ha_t             *ha;
  1482.    ips_scb_t            *scb;
  1483.    ips_copp_wait_item_t *item;
  1484.    unsigned long         cpu_flags;
  1486.    METHOD_TRACE("ips_eh_reset", 1);
  1488. #ifdef NO_IPS_RESET
  1489.    return (FAILED);
  1490. #else
  1492.    if (!SC) {
  1493.       DEBUG(1, "Reset called with NULL scsi command");
  1495.       return (FAILED);
  1496.    }
  1498.    ha = (ips_ha_t *) SC->host->hostdata;
  1500.    if (!ha) {
  1501.       DEBUG(1, "Reset called with NULL ha struct");
  1503.       return (FAILED);
  1504.    }
  1506.    if (!ha->active)
  1507.       return (FAILED);
  1509.    if (test_and_set_bit(IPS_IN_RESET, &ha->flags))
  1510.       return (FAILED);
  1512.    /* See if the command is on the copp queue */
  1513.    IPS_QUEUE_LOCK(&ha->copp_waitlist);
  1514.    item = ha->copp_waitlist.head;
  1515.    while ((item) && (item->scsi_cmd != SC))
  1516.       item = item->next;
  1517.    IPS_QUEUE_UNLOCK(&ha->copp_waitlist);
  1519.    if (item) {
  1520.       /* Found it */
  1521.       ips_removeq_copp(&ha->copp_waitlist, item);
  1522.       clear_bit(IPS_IN_RESET, &ha->flags);
  1524.       return (SUCCESS);
  1525.    }
  1527.    /* See if the command is on the wait queue */
  1528.    if (ips_removeq_wait(&ha->scb_waitlist, SC)) {
  1529.       /* command not sent yet */
  1530.       clear_bit(IPS_IN_RESET, &ha->flags);
  1532.       return (SUCCESS);
  1533.    }
  1535.    /* An explanation for the casual observer:                              */
  1536.    /* Part of the function of a RAID controller is automatic error         */
  1537.    /* detection and recovery.  As such, the only problem that physically   */
  1538.    /* resetting a ServeRAID adapter will ever fix is when, for some reason,*/
  1539.    /* the driver is not successfully communicating with the adapter.       */
  1540.    /* Therefore, we will attempt to flush this adapter.  If that succeeds, */
  1541.    /* then there's no real purpose in a physical reset. This will complete */
  1542.    /* much faster and avoids any problems that might be caused by a        */
  1543.    /* physical reset ( such as having to fail all the outstanding I/O's ). */
  1544.                                                            
  1545.    if (ha->ioctl_reset == 0) {          /* IF Not an IOCTL Requested Reset */
  1546.       scb = &ha->scbs[ha->max_cmds-1];
  1548.       ips_init_scb(ha, scb);
  1550.       scb->timeout = ips_cmd_timeout;
  1551.       scb->cdb[0] = IPS_CMD_FLUSH;
  1553.       scb->cmd.flush_cache.op_code = IPS_CMD_FLUSH;
  1554.       scb->cmd.flush_cache.command_id = IPS_COMMAND_ID(ha, scb);
  1555.       scb->cmd.flush_cache.state = IPS_NORM_STATE;
  1556.       scb->cmd.flush_cache.reserved = 0;
  1557.       scb->cmd.flush_cache.reserved2 = 0;
  1558.       scb->cmd.flush_cache.reserved3 = 0;
  1559.       scb->cmd.flush_cache.reserved4 = 0;
  1561.       /* Attempt the flush command */
  1562.       ret = ips_send_wait(ha, scb, ips_cmd_timeout, IPS_INTR_IORL);
  1563.       if (ret == IPS_SUCCESS) {
  1564.          printk(KERN_NOTICE "(%s%d) Reset Request - Flushed Cachen", ips_name, ha->host_num);
  1565.          clear_bit(IPS_IN_RESET, &ha->flags);
  1566.          return (SUCCESS);
  1567.          }
  1568.    }
  1570.    /* Either we can't communicate with the adapter or it's an IOCTL request */
  1571.    /* from a ServeRAID utility.  A physical reset is needed at this point.  */
  1573.    ha->ioctl_reset = 0;             /* Reset the IOCTL Requested Reset Flag */
  1575.    /*
  1576.     * command must have already been sent
  1577.     * reset the controller
  1578.     */
  1579.    printk(KERN_NOTICE "(%s%d) Resetting controller.n",
  1580.           ips_name, ha->host_num);
  1581.    ret = (*ha->func.reset)(ha);
  1583.    if (!ret) {
  1584.       Scsi_Cmnd *scsi_cmd;
  1586.       printk(KERN_NOTICE
  1587.              "(%s%d) Controller reset failed - controller now offline.n",
  1588.              ips_name, ha->host_num);
  1590.       /* Now fail all of the active commands */
  1591.       DEBUG_VAR(1, "(%s%d) Failing active commands",
  1592.                 ips_name, ha->host_num);
  1594.       while ((scb = ips_removeq_scb_head(&ha->scb_activelist))) {
  1595.          scb->scsi_cmd->result = DID_ERROR << 16;
  1596.          scb->scsi_cmd->scsi_done(scb->scsi_cmd);
  1597.          ips_freescb(ha, scb);
  1598.       }
  1600.       /* Now fail all of the pending commands */
  1601.       DEBUG_VAR(1, "(%s%d) Failing pending commands",
  1602.                 ips_name, ha->host_num);
  1604.       while ((scsi_cmd = ips_removeq_wait_head(&ha->scb_waitlist))) {
  1605.          scsi_cmd->result = DID_ERROR;
  1606.          scsi_cmd->scsi_done(scsi_cmd);
  1607.       }
  1609.       ha->active = FALSE;
  1610.       clear_bit(IPS_IN_RESET, &ha->flags);
  1612.       return (FAILED);
  1613.    }
  1615.    if (!ips_clear_adapter(ha, IPS_INTR_IORL)) {
  1616.       Scsi_Cmnd *scsi_cmd;
  1618.       printk(KERN_NOTICE
  1619.              "(%s%d) Controller reset failed - controller now offline.n",
  1620.              ips_name, ha->host_num);
  1622.       /* Now fail all of the active commands */
  1623.       DEBUG_VAR(1, "(%s%d) Failing active commands",
  1624.                 ips_name, ha->host_num);
  1626.       while ((scb = ips_removeq_scb_head(&ha->scb_activelist))) {
  1627.          scb->scsi_cmd->result = DID_ERROR << 16;
  1628.          scb->scsi_cmd->scsi_done(scb->scsi_cmd);
  1629.          ips_freescb(ha, scb);
  1630.       }
  1632.       /* Now fail all of the pending commands */
  1633.       DEBUG_VAR(1, "(%s%d) Failing pending commands",
  1634.                 ips_name, ha->host_num);
  1636.       while ((scsi_cmd = ips_removeq_wait_head(&ha->scb_waitlist))) {
  1637.          scsi_cmd->result = DID_ERROR << 16;
  1638.          scsi_cmd->scsi_done(scsi_cmd);
  1639.       }
  1641.       ha->active = FALSE;
  1642.       clear_bit(IPS_IN_RESET, &ha->flags);
  1644.       return (FAILED);
  1645.    }
  1647.    /* FFDC */
  1648.    if (le32_to_cpu(ha->subsys->param[3]) & 0x300000) {
  1649.       struct timeval tv;
  1651.       do_gettimeofday(&tv);
  1652.       IPS_HA_LOCK(cpu_flags);
  1653.       ha->last_ffdc = tv.tv_sec;
  1654.       ha->reset_count++;
  1655.       IPS_HA_UNLOCK(cpu_flags);
  1656.       ips_ffdc_reset(ha, IPS_INTR_IORL);
  1657.    }
  1659.    /* Now fail all of the active commands */
  1660.    DEBUG_VAR(1, "(%s%d) Failing active commands",
  1661.              ips_name, ha->host_num);
  1663.    while ((scb = ips_removeq_scb_head(&ha->scb_activelist))) {
  1664.       scb->scsi_cmd->result = (DID_RESET << 16) | (SUGGEST_RETRY << 24);
  1665.       scb->scsi_cmd->scsi_done(scb->scsi_cmd);
  1666.       ips_freescb(ha, scb);
  1667.    }
  1669.    /* Reset DCDB active command bits */
  1670.    for (i = 1; i < ha->nbus; i++)
  1671.       ha->dcdb_active[i-1] = 0;
  1673.    /* Reset the number of active IOCTLs */
  1674.    IPS_HA_LOCK(cpu_flags);
  1675.    ha->num_ioctl = 0;
  1676.    IPS_HA_UNLOCK(cpu_flags);
  1678.    clear_bit(IPS_IN_RESET, &ha->flags);
  1680.    if (!test_bit(IPS_IN_INTR, &ha->flags)) {
  1681.       /*
  1682.        * Only execute the next command when
  1683.        * we are not being called from the
  1684.        * interrupt handler.  The interrupt
  1685.        * handler wants to do this and since
  1686.        * interrupts are turned off here....
  1687.        */
  1688.       ips_next(ha, IPS_INTR_IORL);
  1689.    }
  1691.    return (SUCCESS);
  1693. #endif /* NO_IPS_RESET */
  1695. }
  1697. /****************************************************************************/
  1698. /*                                                                          */
  1699. /* Routine Name: ips_queue                                                  */
  1700. /*                                                                          */
  1701. /* Routine Description:                                                     */
  1702. /*                                                                          */
  1703. /*   Send a command to the controller                                       */
  1704. /*                                                                          */
  1705. /* NOTE:                                                                    */
  1706. /*    Linux obtains io_request_lock before calling this function            */
  1707. /*                                                                          */
  1708. /****************************************************************************/
  1709. int
  1710. ips_queue(Scsi_Cmnd *SC, void (*done) (Scsi_Cmnd *)) {
  1711.    ips_ha_t         *ha;
  1712.    unsigned long     cpu_flags;
  1713.    ips_passthru_t   *pt;                                             
  1715.    METHOD_TRACE("ips_queue", 1);
  1717.    ha = (ips_ha_t *) SC->host->hostdata;
  1719.    if (!ha)
  1720.       return (1);
  1722.    if (!ha->active)
  1723.       return (DID_ERROR);
  1725.    if (ips_is_passthru(SC)) {
  1726.       IPS_QUEUE_LOCK(&ha->copp_waitlist);
  1727.       if (ha->copp_waitlist.count == IPS_MAX_IOCTL_QUEUE) {
  1728.          IPS_QUEUE_UNLOCK(&ha->copp_waitlist);
  1729.          SC->result = DID_BUS_BUSY << 16;
  1730.          done(SC);
  1732.          return (0);
  1733.       } else {
  1734.          IPS_QUEUE_UNLOCK(&ha->copp_waitlist);
  1735.       }
  1736.    } else {
  1737.       IPS_QUEUE_LOCK(&ha->scb_waitlist);
  1738.       if (ha->scb_waitlist.count == IPS_MAX_QUEUE) {
  1739.          IPS_QUEUE_UNLOCK(&ha->scb_waitlist);
  1740.          SC->result = DID_BUS_BUSY << 16;
  1741.          done(SC);
  1743.          return (0);
  1744.       } else {
  1745.          IPS_QUEUE_UNLOCK(&ha->scb_waitlist);
  1746.       }
  1748.    }
  1750.    SC->scsi_done = done;
  1752.    DEBUG_VAR(2, "(%s%d): ips_queue: cmd 0x%X (%d %d %d)",
  1753.              ips_name,
  1754.              ha->host_num,
  1755.              SC->cmnd[0],
  1756.              SC->channel,
  1757.              SC->target,
  1758.              SC->lun);
  1760.    /* Check for command to initiator IDs */
  1761.    if ((SC->channel > 0) && (SC->target == ha->ha_id[SC->channel])) {
  1762.       SC->result = DID_NO_CONNECT << 16;
  1763.       done(SC);
  1765.       return (0);
  1766.    }
  1768.    if (ips_is_passthru(SC)) {
  1770.       ips_copp_wait_item_t *scratch;
  1771.       
  1772.       /* A Reset IOCTL is only sent by the ServeRAID boot CD in extreme cases. */
  1773.       /* There can never be any system activity ( network or disk ), but check */
  1774.       /* anyway just as a good practice.                                       */
  1775.       pt = (ips_passthru_t *) SC->request_buffer;                                
  1776.       if ((pt->CoppCP.cmd.reset.op_code == IPS_CMD_RESET_CHANNEL) &&            
  1777.            (pt->CoppCP.cmd.reset.adapter_flag == 1))  {                         
  1778.          if (ha->scb_activelist.count != 0) {
  1779.              SC->result = DID_BUS_BUSY << 16;
  1780.              done(SC);
  1781.              return (0);
  1782.          }
  1783.          ha->ioctl_reset = 1;           /* This reset request is from an IOCTL */
  1784.          ips_eh_reset(SC);                                                         
  1785.          SC->result = DID_OK << 16;                                                
  1786.          SC->scsi_done(SC);                                                        
  1787.          return (0);                                                               
  1788.       }
  1790.       /* allocate space for the scribble */
  1791.       scratch = kmalloc(sizeof(ips_copp_wait_item_t), GFP_ATOMIC);
  1793.       if (!scratch) {
  1794.          SC->result = DID_ERROR << 16;
  1795.          done(SC);
  1797.          return (0);
  1798.       }
  1800.       scratch->scsi_cmd = SC;
  1801.       sema_init(&ha->ioctl_sem, 0);
  1802.       scratch->sem = &ha->ioctl_sem;
  1803.       scratch->next = NULL;
  1805.       ips_putq_copp_tail(&ha->copp_waitlist, scratch);
  1806.    }
  1807.    else
  1808.       ips_putq_wait_tail(&ha->scb_waitlist, SC);
  1810.    if(ha->scb_waitlist.count + ha->scb_activelist.count > 32)
  1811.          mod_timer(&SC->eh_timeout, jiffies + 120 * HZ);
  1813.    IPS_HA_LOCK(cpu_flags);
  1814.    if ((!test_bit(IPS_IN_INTR, &ha->flags)) &&
  1815.        (!test_bit(IPS_IN_ABORT, &ha->flags)) &&
  1816.        (!test_bit(IPS_IN_RESET, &ha->flags))) {
  1817.       IPS_HA_UNLOCK(cpu_flags);
  1818.       ips_next(ha, IPS_INTR_IORL);
  1819.    } else {
  1820.       IPS_HA_UNLOCK(cpu_flags);
  1821.    }
  1822.    
  1823.    /* If We were using the CD Boot Flash Buffer, Restore the Old Values */
  1824.    if ( ips_FlashData == ha->ioctl_data ) {                               
  1825.       ha->ioctl_data = ha->flash_data;                           
  1826.       ha->ioctl_order = ha->flash_order;                          
  1827.       ha->ioctl_datasize = ha->flash_datasize;                       
  1828.       ips_FlashDataInUse = 0;                                             
  1829.    }
  1830.    return (0);
  1831. }
  1833. /****************************************************************************/
  1834. /*                                                                          */
  1835. /* Routine Name: ips_biosparam                                              */
  1836. /*                                                                          */
  1837. /* Routine Description:                                                     */
  1838. /*                                                                          */
  1839. /*   Set bios geometry for the controller                                   */
  1840. /*                                                                          */
  1841. /****************************************************************************/
  1842. int
  1843. ips_biosparam(Disk *disk, kdev_t dev, int geom[]) {
  1844.    ips_ha_t         *ha;
  1845.    int               heads;
  1846.    int               sectors;
  1847.    int               cylinders;
  1849.    METHOD_TRACE("ips_biosparam", 1);
  1851.    ha = (ips_ha_t *) disk->device->host->hostdata;
  1853.    if (!ha)
  1854.       /* ?!?! host adater info invalid */
  1855.       return (0);
  1857.    if (!ha->active)
  1858.       return (0);
  1860.    if (!ips_read_adapter_status(ha, IPS_INTR_ON))
  1861.       /* ?!?! Enquiry command failed */
  1862.       return (0);
  1864.    if ((disk->capacity > 0x400000) &&
  1865.        ((ha->enq->ucMiscFlag & 0x8) == 0)) {
  1866.       heads = IPS_NORM_HEADS;
  1867.       sectors = IPS_NORM_SECTORS;
  1868.    } else {
  1869.       heads = IPS_COMP_HEADS;
  1870.       sectors = IPS_COMP_SECTORS;
  1871.    }
  1873.    cylinders = disk->capacity / (heads * sectors);
  1875.    DEBUG_VAR(2, "Geometry: heads: %d, sectors: %d, cylinders: %d",
  1876.              heads, sectors, cylinders);
  1878.    geom[0] = heads;
  1879.    geom[1] = sectors;
  1880.    geom[2] = cylinders;
  1882.    return (0);
  1883. }
  1885. /****************************************************************************/
  1886. /*                                                                          */
  1887. /* Routine Name: ips_select_queue_depth                                     */
  1888. /*                                                                          */
  1889. /* Routine Description:                                                     */
  1890. /*                                                                          */
  1891. /*   Select queue depths for the devices on the contoller                   */
  1892. /*                                                                          */
  1893. /****************************************************************************/
  1894. static void
  1895. ips_select_queue_depth(struct Scsi_Host *host, Scsi_Device *scsi_devs) {
  1896.    Scsi_Device *device;
  1897.    ips_ha_t    *ha;
  1898.    int          count = 0;
  1899.    int          min;
  1901.    ha = IPS_HA(host);
  1902.    min = ha->max_cmds / 4;
  1904.    for (device = scsi_devs; device; device = device->next) {
  1905.      if (device->host == host) {
  1906.         if ((device->channel == 0) && (device->type == 0))
  1907.            count++;
  1908.      }
  1909.    }
  1911.    for (device = scsi_devs; device; device = device->next) {
  1912.       if (device->host == host) {
  1913.          if ((device->channel == 0) && (device->type == 0)) {
  1914.             device->queue_depth = ( ha->max_cmds - 1 ) / count;
  1915.             if (device->queue_depth < min) 
  1916.                device->queue_depth = min;
  1917.          }
  1918.          else {
  1919.             device->queue_depth = 2;
  1920.          }
  1922.          if (device->queue_depth < 2)
  1923.             device->queue_depth = 2;
  1924.       }
  1925.    }
  1926. }
  1928. /****************************************************************************/
  1929. /*                                                                          */
  1930. /* Routine Name: do_ipsintr                                                 */
  1931. /*                                                                          */
  1932. /* Routine Description:                                                     */
  1933. /*                                                                          */
  1934. /*   Wrapper for the interrupt handler                                      */
  1935. /*                                                                          */
  1936. /****************************************************************************/
  1937. void
  1938. do_ipsintr(int irq, void *dev_id, struct pt_regs *regs) {
  1939.    ips_ha_t         *ha;
  1940.    unsigned long     cpu_flags;
  1942.    METHOD_TRACE("do_ipsintr", 2);
  1944.    ha = (ips_ha_t *) dev_id;
  1945.    if (!ha) 
  1946.       return;
  1947.    
  1948.    spin_lock_irqsave(&io_request_lock, cpu_flags);
  1950.    if (test_and_set_bit(IPS_IN_INTR, &ha->flags)) {
  1951.       spin_unlock_irqrestore(&io_request_lock, cpu_flags);
  1953.       return ;
  1954.    }
  1956.    if (!ha->active) {
  1957.       clear_bit(IPS_IN_INTR, &ha->flags);
  1958.       spin_unlock_irqrestore(&io_request_lock, cpu_flags);
  1960.       return;
  1961.    }
  1963.    (*ha->func.intr)(ha);
  1965.    clear_bit(IPS_IN_INTR, &ha->flags);
  1967.    spin_unlock_irqrestore(&io_request_lock, cpu_flags);
  1969.    /* start the next command */
  1970.    ips_next(ha, IPS_INTR_ON);
  1971. }
  1973. /****************************************************************************/
  1974. /*                                                                          */
  1975. /* Routine Name: ips_intr_copperhead                                        */
  1976. /*                                                                          */
  1977. /* Routine Description:                                                     */
  1978. /*                                                                          */
  1979. /*   Polling interrupt handler                                              */
  1980. /*                                                                          */
  1981. /*   ASSUMES interrupts are disabled                                        */
  1982. /*                                                                          */
  1983. /****************************************************************************/
  1984. void
  1985. ips_intr_copperhead(ips_ha_t *ha) {
  1986.    ips_stat_t       *sp;
  1987.    ips_scb_t        *scb;
  1988.    IPS_STATUS        cstatus;
  1989.    int               intrstatus;
  1990.    unsigned long     cpu_flags;
  1992.    METHOD_TRACE("ips_intr", 2);
  1994.    if (!ha)
  1995.       return;
  1997.    if (!ha->active)
  1998.       return;
  2000.    IPS_HA_LOCK(cpu_flags);
  2002.    intrstatus = (*ha->func.isintr)(ha);
  2004.    if (!intrstatus) {
  2005.       /*
  2006.        * Unexpected/Shared interrupt
  2007.        */
  2008.       IPS_HA_UNLOCK(cpu_flags);
  2010.       return;
  2011.    }
  2013.    while (TRUE) {
  2014.       sp = &ha->sp;
  2016.       intrstatus = (*ha->func.isintr)(ha);
  2018.       if (!intrstatus)
  2019.          break;
  2020.       else
  2021.          cstatus.value = (*ha->func.statupd)(ha);
  2023.       if (cstatus.fields.command_id > (IPS_MAX_CMDS - 1)) {
  2024.          /* Spurious Interupt ? */
  2025.          continue;
  2026.       }
  2028.       ips_chkstatus(ha, &cstatus);
  2029.       scb = (ips_scb_t *) sp->scb_addr;
  2031.       /*
  2032.        * use the callback function to finish things up
  2033.        * NOTE: interrupts are OFF for this
  2034.        */
  2035.       IPS_HA_UNLOCK(cpu_flags);
  2036.       (*scb->callback) (ha, scb);
  2037.       IPS_HA_LOCK(cpu_flags);
  2038.    } /* end while */
  2040.    IPS_HA_UNLOCK(cpu_flags);
  2041. }
  2043. /****************************************************************************/
  2044. /*                                                                          */
  2045. /* Routine Name: ips_intr_morpheus                                          */
  2046. /*                                                                          */
  2047. /* Routine Description:                                                     */
  2048. /*                                                                          */
  2049. /*   Polling interrupt handler                                              */
  2050. /*                                                                          */
  2051. /*   ASSUMES interrupts are disabled                                        */
  2052. /*                                                                          */
  2053. /****************************************************************************/
  2054. void
  2055. ips_intr_morpheus(ips_ha_t *ha) {
  2056.    ips_stat_t       *sp;
  2057.    ips_scb_t        *scb;
  2058.    IPS_STATUS        cstatus;
  2059.    int               intrstatus;
  2060.    unsigned long     cpu_flags;
  2062.    METHOD_TRACE("ips_intr_morpheus", 2);
  2064.    if (!ha)
  2065.       return;
  2067.    if (!ha->active)
  2068.       return;
  2070.    IPS_HA_LOCK(cpu_flags);
  2072.    intrstatus = (*ha->func.isintr)(ha);
  2074.    if (!intrstatus) {
  2075.       /*
  2076.        * Unexpected/Shared interrupt
  2077.        */
  2078.       IPS_HA_UNLOCK(cpu_flags);
  2080.       return;
  2081.    }
  2083.    while (TRUE) {
  2084.       sp = &ha->sp;
  2086.       intrstatus = (*ha->func.isintr)(ha);
  2088.       if (!intrstatus)
  2089.          break;
  2090.       else
  2091.          cstatus.value = (*ha->func.statupd)(ha);
  2093.       if (cstatus.value == 0xffffffff)
  2094.          /* No more to process */
  2095.          break;
  2097.       if (cstatus.fields.command_id > (IPS_MAX_CMDS - 1)) {
  2098.          printk(KERN_WARNING "(%s%d) Spurious interrupt; no ccb.n",
  2099.                 ips_name, ha->host_num);
  2101.          continue;
  2102.       }
  2104.       ips_chkstatus(ha, &cstatus);
  2105.       scb = (ips_scb_t *) sp->scb_addr;
  2107.       /*
  2108.        * use the callback function to finish things up
  2109.        * NOTE: interrupts are OFF for this
  2110.        */
  2111.       IPS_HA_UNLOCK(cpu_flags);
  2112.       (*scb->callback) (ha, scb);
  2113.       IPS_HA_LOCK(cpu_flags);
  2114.    } /* end while */
  2116.    IPS_HA_UNLOCK(cpu_flags);
  2117. }
  2119. /****************************************************************************/
  2120. /*                                                                          */
  2121. /* Routine Name: ips_info                                                   */
  2122. /*                                                                          */
  2123. /* Routine Description:                                                     */
  2124. /*                                                                          */
  2125. /*   Return info about the driver                                           */
  2126. /*                                                                          */
  2127. /****************************************************************************/
  2128. const char *
  2129. ips_info(struct Scsi_Host *SH) {
  2130.    static char  buffer[256];
  2131.    char        *bp;
  2132.    ips_ha_t    *ha;
  2134.    METHOD_TRACE("ips_info", 1);
  2136.    ha = IPS_HA(SH);
  2138.    if (!ha)
  2139.       return (NULL);
  2141.    bp = &buffer[0];
  2142.    memset(bp, 0, sizeof(buffer));
  2144.    sprintf(bp, "%s%s%s", "IBM PCI ServeRAID ", IPS_VERSION_HIGH, IPS_VERSION_LOW );
  2146.    if (ha->ad_type > 0 &&
  2147.        ha->ad_type <= MAX_ADAPTER_NAME) {
  2148.       strcat(bp, " <");
  2149.       strcat(bp, ips_adapter_name[ha->ad_type-1]);
  2150.       strcat(bp, ">");
  2151.    }
  2153.    return (bp);
  2154. }
  2156. /****************************************************************************/
  2157. /*                                                                          */
  2158. /* Routine Name: ips_proc_info                                              */
  2159. /*                                                                          */
  2160. /* Routine Description:                                                     */
  2161. /*                                                                          */
  2162. /*   The passthru interface for the driver                                  */
  2163. /*                                                                          */
  2164. /****************************************************************************/
  2165. int
  2166. ips_proc_info(char *buffer, char **start, off_t offset,
  2167.               int length, int hostno, int func) {
  2168.    int           i;
  2169.    int           ret;
  2170.    ips_ha_t     *ha = NULL;
  2172.    METHOD_TRACE("ips_proc_info", 1);
  2174.    /* Find our host structure */
  2175.    for (i = 0; i < ips_next_controller; i++) {
  2176.       if (ips_sh[i]) {
  2177.          if (ips_sh[i]->host_no == hostno) {
  2178.             ha = (ips_ha_t *) ips_sh[i]->hostdata;
  2179.             break;
  2180.          }
  2181.       }
  2182.    }
  2184.    if (!ha)
  2185.       return (-EINVAL);
  2187.    if (func) {
  2188.       /* write */
  2189.       return (0);
  2190.    } else {
  2191.       /* read */
  2192.       if (start)
  2193.          *start = buffer;
  2195.       ret = ips_host_info(ha, buffer, offset, length);
  2197.       return (ret);
  2198.    }
  2199. }
  2201. /*--------------------------------------------------------------------------*/
  2202. /* Helper Functions                                                         */
  2203. /*--------------------------------------------------------------------------*/
  2205. /****************************************************************************/
  2206. /*                                                                          */
  2207. /* Routine Name: ips_is_passthru                                            */
  2208. /*                                                                          */
  2209. /* Routine Description:                                                     */
  2210. /*                                                                          */
  2211. /*   Determine if the specified SCSI command is really a passthru command   */
  2212. /*                                                                          */
  2213. /****************************************************************************/
  2214. static int
  2215. ips_is_passthru(Scsi_Cmnd *SC) {
  2216.    METHOD_TRACE("ips_is_passthru", 1);
  2218.    if (!SC)
  2219.       return (0);
  2221.    if ((SC->cmnd[0] == IPS_IOCTL_COMMAND) &&
  2222.        (SC->channel == 0) &&
  2223.        (SC->target == IPS_ADAPTER_ID) &&
  2224.        (SC->lun == 0) &&
  2225.         SC->request_buffer){
  2226.       if((!SC->use_sg) && SC->request_bufflen &&
  2227.          (((char *) SC->request_buffer)[0] == 'C') &&
  2228.          (((char *) SC->request_buffer)[1] == 'O') &&
  2229.          (((char *) SC->request_buffer)[2] == 'P') &&
  2230.          (((char *) SC->request_buffer)[3] == 'P'))
  2231.          return 1;
  2232.       else if(SC->use_sg){
  2233.          struct scatterlist *sg = SC->request_buffer;
  2234.          char *buffer = sg[0].address;
  2235.          if(buffer && buffer[0] == 'C' && buffer[1] == 'O' && 
  2236.             buffer[2] == 'P' && buffer[3] == 'P')
  2237.             return 1;
  2238.       }
  2239.    }
  2240.    return 0;
  2241. }
  2243. /****************************************************************************/
  2244. /*                                                                          */
  2245. /* Routine Name: ips_make_passthru                                          */
  2246. /*                                                                          */
  2247. /* Routine Description:                                                     */
  2248. /*                                                                          */
  2249. /*   Make a passthru command out of the info in the Scsi block              */
  2250. /*                                                                          */
  2251. /****************************************************************************/
  2252. static int
  2253. ips_make_passthru(ips_ha_t *ha, Scsi_Cmnd *SC, ips_scb_t *scb, int intr) {
  2254.    ips_passthru_t *pt;
  2255.    char *buffer;
  2256.    int length = 0;
  2258.    METHOD_TRACE("ips_make_passthru", 1);
  2260.    if(!SC->use_sg){
  2261.       buffer = SC->request_buffer;
  2262.       length = SC->request_bufflen;
  2263.    }else{
  2264.       struct scatterlist *sg = SC->request_buffer;
  2265.       int i;
  2266.       for(i = 0; i < SC->use_sg; i++)
  2267.          length += sg[i].length;
  2269.       if (length < sizeof(ips_passthru_t)) {
  2270.          /* wrong size */
  2271.          DEBUG_VAR(1, "(%s%d) Passthru structure wrong size",
  2272.              ips_name, ha->host_num);
  2273.          return (IPS_FAILURE);
  2274.       }else if(!ha->ioctl_data || length > (PAGE_SIZE << ha->ioctl_order)){
  2275.          void *bigger_buf;
  2276.          int count;
  2277.          int order;
  2278.          /* try to allocate a bigger buffer */
  2279.          for (count = PAGE_SIZE, order = 0;
  2280.               count < length;
  2281.               order++, count <<= 1);
  2282.          bigger_buf = (void *) __get_free_pages(GFP_ATOMIC, order);
  2283.          if (bigger_buf) {
  2284.             /* free the old memory */
  2285.             free_pages((unsigned long) ha->ioctl_data, ha->ioctl_order);
  2286.             /* use the new memory */
  2287.             ha->ioctl_data = (char *) bigger_buf;
  2288.             ha->ioctl_order = order;
  2289.             ha->ioctl_datasize = count;
  2290.          } else {
  2291.              pt = (ips_passthru_t*)sg[0].address;
  2292.              pt->BasicStatus = 0x0B;
  2293.              pt->ExtendedStatus = 0x00;
  2294.              SC->result = DID_ERROR << 16;
  2295.              return (IPS_FAILURE);
  2296.          }
  2297.       }
  2298.       ha->ioctl_datasize = length;
  2299.       length = 0;
  2300.       for(i = 0; i < SC->use_sg; i++){
  2301.          memcpy(&ha->ioctl_data[length], sg[i].address, sg[i].length);
  2302.          length += sg[i].length;
  2303.       }
  2304.       pt = (ips_passthru_t *)ha->ioctl_data;
  2305.       buffer = ha->ioctl_data;
  2306.    }
  2307.    if (!length || !buffer) {
  2308.       /* no data */
  2309.       DEBUG_VAR(1, "(%s%d) No passthru structure",
  2310.                 ips_name, ha->host_num);
  2312.       return (IPS_FAILURE);
  2313.    }
  2314.    if (length < sizeof(ips_passthru_t)) {
  2315.       /* wrong size */
  2316.       DEBUG_VAR(1, "(%s%d) Passthru structure wrong size",
  2317.              ips_name, ha->host_num);
  2319.       return (IPS_FAILURE);
  2320.    }
  2321.    pt = (ips_passthru_t*) buffer;
  2322.    /*
  2323.     * Some notes about the passthru interface used
  2324.     *
  2325.     * IF the scsi op_code == 0x0d then we assume
  2326.     * that the data came along with/goes with the
  2327.     * packet we received from the sg driver. In this
  2328.     * case the CmdBSize field of the pt structure is
  2329.     * used for the size of the buffer.
  2330.     *
  2331.     * IF the scsi op_code == 0x81 then we assume that
  2332.     * we will need our own buffer and we will copy the
  2333.     * data to/from the user buffer passed in the scsi
  2334.     * command.  The data address resides at offset 4
  2335.     * in the scsi command.  The length of the data resides
  2336.     * at offset 8 in the scsi command.
  2337.     */
  2339.    switch (pt->CoppCmd) {
  2340.    case IPS_NUMCTRLS:
  2341.       memcpy(buffer + sizeof(ips_passthru_t),
  2342.              &ips_num_controllers, sizeof(int));
  2343.       SC->result = DID_OK << 16;
  2345.       return (IPS_SUCCESS_IMM);
  2347.    case IPS_CTRLINFO:
  2348.       memcpy(buffer + sizeof(ips_passthru_t),
  2349.              ha, sizeof(ips_ha_t));
  2350.       SC->result = DID_OK << 16;
  2352.       return (IPS_SUCCESS_IMM);
  2354.    case IPS_COPPUSRCMD:
  2355.    case IPS_COPPIOCCMD:
  2356.       if (SC->cmnd[0] == IPS_IOCTL_COMMAND) {
  2357.          if (length < (sizeof(ips_passthru_t) + pt->CmdBSize)) {
  2358.             /* wrong size */
  2359.             DEBUG_VAR(1, "(%s%d) Passthru structure wrong size",
  2360.                       ips_name, ha->host_num);
  2362.             return (IPS_FAILURE);
  2363.          }
  2365.          if(ha->device_id == IPS_DEVICEID_COPPERHEAD &&
  2366.             pt->CoppCP.cmd.flashfw.op_code == IPS_CMD_RW_BIOSFW)
  2367.             return ips_flash_copperhead(ha, pt, scb);
  2369.          if (ips_usrcmd(ha, pt, scb))
  2370.             return (IPS_SUCCESS);
  2371.          else
  2372.             return (IPS_FAILURE);
  2373.       } 
  2374.      
  2375.       break;
  2377.    } /* end switch */
  2379.          return (IPS_FAILURE);
  2380.       }
  2382. /****************************************************************************/
  2383. /* Routine Name: ips_flash_copperhead                                       */
  2384. /* Routine Description:                                                     */
  2385. /*   Flash the BIOS/FW on a Copperhead style controller                     */
  2386. /****************************************************************************/
  2387. static int
  2388. ips_flash_copperhead(ips_ha_t *ha, ips_passthru_t *pt, ips_scb_t *scb){
  2389.    int datasize, count;
  2391.    /* Trombone is the only copperhead that can do packet flash, but only
  2392.     * for firmware. No one said it had to make sence. */
  2393.    if(IPS_IS_TROMBONE(ha) && pt->CoppCP.cmd.flashfw.type == IPS_FW_IMAGE){
  2394.       if(ips_usrcmd(ha, pt, scb))
  2395.          return IPS_SUCCESS;
  2396.       else
  2397.          return IPS_FAILURE;
  2398.    }
  2399.    pt->BasicStatus = 0x0B;
  2400.    pt->ExtendedStatus = 0;
  2401.    scb->scsi_cmd->result = DID_OK <<16;
  2402.    /* IF it's OK to Use the "CD BOOT" Flash Buffer, then you can     */
  2403.    /* avoid allocating a huge buffer per adapter ( which can fail ). */
  2404.    if(pt->CoppCP.cmd.flashfw.type == IPS_BIOS_IMAGE &&
  2405.       pt->CoppCP.cmd.flashfw.direction == IPS_ERASE_BIOS){
  2406.       pt->BasicStatus = 0;
  2407.       return ips_flash_bios(ha, pt, scb);
  2408.    }else if(pt->CoppCP.cmd.flashfw.packet_num == 0){
  2409.       if(ips_FlashData && !test_and_set_bit(0, &ips_FlashDataInUse)){
  2410.          ha->flash_data  = ips_FlashData;
  2411.          ha->flash_order = 7;
  2412.          ha->flash_datasize = 0;
  2413.       }else if(!ha->flash_data){
  2414.          datasize = pt->CoppCP.cmd.flashfw.total_packets *
  2415.                     pt->CoppCP.cmd.flashfw.count;
  2416.          for (count = PAGE_SIZE, ha->flash_order = 0; count < datasize;
  2417.               ha->flash_order++, count <<= 1);
  2418.          ha->flash_data = (char *)__get_free_pages(GFP_ATOMIC, ha->flash_order);
  2419.          ha->flash_datasize = 0;
  2420.       }else
  2421.          return IPS_FAILURE;
  2422.    }else{
  2423.       if(pt->CoppCP.cmd.flashfw.count + ha->flash_datasize >
  2424.         (PAGE_SIZE << ha->flash_order)){
  2425.          ips_free_flash_copperhead(ha);
  2426.          printk(KERN_WARNING "failed size sanity checkn");
  2427.          return IPS_FAILURE;
  2428.       }
  2429.    }
  2430.    if(!ha->flash_data)
  2431.       return IPS_FAILURE;
  2432.    pt->BasicStatus = 0;
  2433.    memcpy(&ha->flash_data[ha->flash_datasize], pt + 1,
  2434.           pt->CoppCP.cmd.flashfw.count);
  2435.    ha->flash_datasize += pt->CoppCP.cmd.flashfw.count;
  2436.    if(pt->CoppCP.cmd.flashfw.packet_num ==
  2437.       pt->CoppCP.cmd.flashfw.total_packets - 1){
  2438.       if(pt->CoppCP.cmd.flashfw.type == IPS_BIOS_IMAGE)
  2439.          return ips_flash_bios(ha, pt, scb);
  2440.       else if(pt->CoppCP.cmd.flashfw.type == IPS_FW_IMAGE)
  2441.          return ips_flash_firmware(ha, pt, scb);
  2442.    }
  2443.    return IPS_SUCCESS_IMM;
  2444. }
  2446. /****************************************************************************/
  2447. /* Routine Name: ips_flash_bios                                             */
  2448. /* Routine Description:                                                     */
  2449. /*   flashes the bios of a copperhead adapter                               */
  2450. /****************************************************************************/
  2451. static int
  2452. ips_flash_bios(ips_ha_t * ha, ips_passthru_t *pt, ips_scb_t *scb){
  2454.    if(pt->CoppCP.cmd.flashfw.type == IPS_BIOS_IMAGE &&
  2455.       pt->CoppCP.cmd.flashfw.direction == IPS_WRITE_BIOS){
  2456.       if ((!ha->func.programbios) || (!ha->func.erasebios) ||
  2457.           (!ha->func.verifybios))
  2458.          goto error;
  2459.       if((*ha->func.erasebios)(ha)){
  2460.          DEBUG_VAR(1, "(%s%d) flash bios failed - unable to erase flash",
  2461.                    ips_name, ha->host_num);
  2462.          goto error;
  2463.       }else if ((*ha->func.programbios)(ha, ha->flash_data + IPS_BIOS_HEADER,
  2464.           ha->flash_datasize - IPS_BIOS_HEADER, 0 )) {
  2465.          DEBUG_VAR(1, "(%s%d) flash bios failed - unable to flash",
  2466.                    ips_name, ha->host_num);
  2467.          goto error;
  2468.       }else if ((*ha->func.verifybios)(ha, ha->flash_data + IPS_BIOS_HEADER,
  2469.           ha->flash_datasize - IPS_BIOS_HEADER, 0 )) {
  2470.          DEBUG_VAR(1, "(%s%d) flash bios failed - unable to verify flash",
  2471.                    ips_name, ha->host_num);
  2472.          goto error;
  2473.       }
  2474.       ips_free_flash_copperhead(ha);
  2475.       return IPS_SUCCESS_IMM;
  2476.    }else if(pt->CoppCP.cmd.flashfw.type == IPS_BIOS_IMAGE &&
  2477.       pt->CoppCP.cmd.flashfw.direction == IPS_ERASE_BIOS){
  2478.       if(!ha->func.erasebios)
  2479.          goto error;
  2480.       if((*ha->func.erasebios)(ha)){
  2481.          DEBUG_VAR(1, "(%s%d) flash bios failed - unable to erase flash",
  2482.                    ips_name, ha->host_num);
  2483.          goto error;
  2484.       }
  2485.       return IPS_SUCCESS_IMM;
  2486.    }
  2487. error:
  2488.    pt->BasicStatus = 0x0B;
  2489.    pt->ExtendedStatus = 0x00;
  2490.    ips_free_flash_copperhead(ha);
  2491.    return IPS_FAILURE;
  2492. }
  2494. /****************************************************************************/
  2495. /* Routine Name: ips_flash_firmware                                         */
  2496. /* Routine Description:                                                     */
  2497. /*   flashes the firmware of a copperhead adapter                           */
  2498. /****************************************************************************/
  2499. static int
  2500. ips_flash_firmware(ips_ha_t * ha, ips_passthru_t *pt, ips_scb_t *scb){
  2501.    IPS_SG_LIST *sg_list;
  2503.    if(pt->CoppCP.cmd.flashfw.type == IPS_FW_IMAGE &&
  2504.       pt->CoppCP.cmd.flashfw.direction == IPS_WRITE_FW ){
  2505.       memset(&pt->CoppCP.cmd, 0, sizeof(IPS_HOST_COMMAND));
  2506.       pt->CoppCP.cmd.flashfw.op_code = IPS_CMD_DOWNLOAD;
  2507.       pt->CoppCP.cmd.flashfw.count = cpu_to_le32(ha->flash_datasize);
  2508.    }else{
  2509.       pt->BasicStatus = 0x0B;
  2510.       pt->ExtendedStatus = 0x00;
  2511.       ips_free_flash_copperhead(ha);
  2512.       return IPS_FAILURE;
  2513.    }
  2514.    /* Save the S/G list pointer so it doesn't get clobbered */
  2515.    sg_list = scb->sg_list;
  2516.    /* copy in the CP */
  2517.    memcpy(&scb->cmd, &pt->CoppCP.cmd, sizeof(IPS_IOCTL_CMD));
  2518.    /* FIX stuff that might be wrong */
  2519.    scb->sg_list = sg_list;
  2520.    scb->scb_busaddr = VIRT_TO_BUS(scb);
  2521.    scb->bus = scb->scsi_cmd->channel;
  2522.    scb->target_id = scb->scsi_cmd->target;
  2523.    scb->lun = scb->scsi_cmd->lun;
  2524.    scb->sg_len = 0;
  2525.    scb->data_len = 0;
  2526.    scb->flags = 0;
  2527.    scb->op_code = 0;
  2528.    scb->callback = ipsintr_done;
  2529.    scb->timeout = ips_cmd_timeout;
  2530.    scb->cmd.flashfw.command_id = IPS_COMMAND_ID(ha, scb);
  2531.    scb->cmd.flashfw.buffer_addr = VIRT_TO_BUS(ha->flash_data);
  2532.    if (pt->TimeOut)
  2533.       scb->timeout = pt->TimeOut;
  2534.    scb->scsi_cmd->result = DID_OK <<16;
  2535.    return IPS_SUCCESS;
  2536. }
  2538. /****************************************************************************/
  2539. /* Routine Name: ips_free_flash_copperhead                                  */
  2540. /* Routine Description:                                                     */
  2541. /*   release the memory resources used to hold the flash image              */
  2542. /****************************************************************************/
  2543. static void
  2544. ips_free_flash_copperhead(ips_ha_t *ha){
  2545.    if(ha->flash_data == ips_FlashData)
  2546.       test_and_clear_bit(0, &ips_FlashDataInUse);
  2547.    else if(ha->flash_data)
  2548.       free_pages((unsigned long)ha->flash_data, ha->flash_order);
  2549.    ha->flash_data = NULL;
  2550. }
  2552. /****************************************************************************/
  2553. /*                                                                          */
  2554. /* Routine Name: ips_usrcmd                                                 */
  2555. /*                                                                          */
  2556. /* Routine Description:                                                     */
  2557. /*                                                                          */
  2558. /*   Process a user command and make it ready to send                       */
  2559. /*                                                                          */
  2560. /****************************************************************************/
  2561. static int
  2562. ips_usrcmd(ips_ha_t *ha, ips_passthru_t *pt, ips_scb_t *scb) {
  2563.    IPS_SG_LIST *sg_list;
  2565.    METHOD_TRACE("ips_usrcmd", 1);
  2567.    if ((!scb) || (!pt) || (!ha))
  2568.       return (0);
  2570.    /* Save the S/G list pointer so it doesn't get clobbered */
  2571.    sg_list = scb->sg_list;
  2573.    /* copy in the CP */
  2574.    memcpy(&scb->cmd, &pt->CoppCP.cmd, sizeof(IPS_IOCTL_CMD));
  2575.    memcpy(&scb->dcdb, &pt->CoppCP.dcdb, sizeof(IPS_DCDB_TABLE));
  2577.    /* FIX stuff that might be wrong */
  2578.    scb->sg_list = sg_list;
  2579.    scb->scb_busaddr = VIRT_TO_BUS(scb);
  2580.    scb->bus = scb->scsi_cmd->channel;
  2581.    scb->target_id = scb->scsi_cmd->target;
  2582.    scb->lun = scb->scsi_cmd->lun;
  2583.    scb->sg_len = 0;
  2584.    scb->data_len = 0;
  2585.    scb->flags = 0;
  2586.    scb->op_code = 0;
  2587.    scb->callback = ipsintr_done;
  2588.    scb->timeout = ips_cmd_timeout;
  2589.    scb->cmd.basic_io.command_id = IPS_COMMAND_ID(ha, scb);
  2591.    /* we don't support DCDB/READ/WRITE Scatter Gather */
  2592.    if ((scb->cmd.basic_io.op_code == IPS_CMD_READ_SG) ||
  2593.        (scb->cmd.basic_io.op_code == IPS_CMD_WRITE_SG) ||
  2594.        (scb->cmd.basic_io.op_code == IPS_CMD_DCDB_SG))
  2595.       return (0);
  2597.    if (pt->CmdBSize) {
  2598.       if(!scb->scsi_cmd->use_sg)
  2599.          scb->data_busaddr = VIRT_TO_BUS(scb->scsi_cmd->request_buffer + sizeof(ips_passthru_t));
  2600.       else
  2601.          scb->data_busaddr = VIRT_TO_BUS(ha->ioctl_data + sizeof(ips_passthru_t));
  2602.    } else {
  2603.       scb->data_busaddr = 0L;
  2604.    }
  2606.    if (scb->cmd.dcdb.op_code == IPS_CMD_DCDB)