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

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

嵌入式Linux

开发平台：

Unix_Linux

ips.c：源码内容
  1. /*****************************************************************************/
  2. /* ips.c -- driver for the IBM ServeRAID controller                          */
  3. /*                                                                           */
  4. /* Written By: Keith Mitchell, IBM Corporation                               */
  5. /*                                                                           */
  6. /* Copyright (C) 2000 IBM Corporation                                        */
  7. /*                                                                           */
  8. /* This program is free software; you can redistribute it and/or modify      */
  9. /* it under the terms of the GNU General Public License as published by      */
  10. /* the Free Software Foundation; either version 2 of the License, or         */
  11. /* (at your option) any later version.                                       */
  12. /*                                                                           */
  13. /* This program is distributed in the hope that it will be useful,           */
  14. /* but WITHOUT ANY WARRANTY; without even the implied warranty of            */
  15. /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             */
  16. /* GNU General Public License for more details.                              */
  17. /*                                                                           */
  18. /* NO WARRANTY                                                               */
  19. /* THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR        */
  20. /* CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT      */
  21. /* LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,      */
  22. /* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is    */
  23. /* solely responsible for determining the appropriateness of using and       */
  24. /* distributing the Program and assumes all risks associated with its        */
  25. /* exercise of rights under this Agreement, including but not limited to     */
  26. /* the risks and costs of program errors, damage to or loss of data,         */
  27. /* programs or equipment, and unavailability or interruption of operations.  */
  28. /*                                                                           */
  29. /* DISCLAIMER OF LIABILITY                                                   */
  30. /* NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY   */
  31. /* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL        */
  32. /* DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND   */
  33. /* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR     */
  34. /* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE    */
  35. /* USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED  */
  36. /* HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES             */
  37. /*                                                                           */
  38. /* You should have received a copy of the GNU General Public License         */
  39. /* along with this program; if not, write to the Free Software               */
  40. /* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  41. /*                                                                           */
  42. /* Bugs/Comments/Suggestions about this driver should be mailed to:          */
  43. /*      ipslinux@us.ibm.com                                                 */
  44. /*                                                                           */
  45. /* For system support issues, contact your local IBM Customer support.       */
  46. /* Directions to find IBM Customer Support for each country can be found at: */
  47. /*      http://www.ibm.com/planetwide/                                       */
  48. /*                                                                           */
  49. /*****************************************************************************/
  51. /*****************************************************************************/
  52. /* Change Log                                                                */
  53. /*                                                                           */
  54. /* 0.99.02  - Breakup commands that are bigger than 8 * the stripe size      */
  55. /* 0.99.03  - Make interrupt routine handle all completed request on the     */
  56. /*            adapter not just the first one                                 */
  57. /*          - Make sure passthru commands get woken up if we run out of      */
  58. /*            SCBs                                                           */
  59. /*          - Send all of the commands on the queue at once rather than      */
  60. /*            one at a time since the card will support it.                  */
  61. /* 0.99.04  - Fix race condition in the passthru mechanism -- this required  */
  62. /*            the interface to the utilities to change                       */
  63. /*          - Fix error recovery code                                        */
  64. /* 0.99.05  - Fix an oops when we get certain passthru commands              */
  65. /* 1.00.00  - Initial Public Release                                         */
  66. /*            Functionally equivalent to 0.99.05                             */
  67. /* 3.60.00  - Bump max commands to 128 for use with ServeRAID firmware 3.60  */
  68. /*          - Change version to 3.60 to coincide with ServeRAID release      */
  69. /*            numbering.                                                     */
  70. /* 3.60.01  - Remove bogus error check in passthru routine                   */
  71. /* 3.60.02  - Make DCDB direction based on lookup table                      */
  72. /*          - Only allow one DCDB command to a SCSI ID at a time             */
  73. /* 4.00.00  - Add support for ServeRAID 4                                    */
  74. /* 4.00.01  - Add support for First Failure Data Capture                     */
  75. /* 4.00.02  - Fix problem with PT DCDB with no buffer                        */
  76. /* 4.00.03  - Add alternative passthru interface                             */
  77. /*          - Add ability to flash ServeRAID BIOS                            */
  78. /* 4.00.04  - Rename structures/constants to be prefixed with IPS_           */
  79. /* 4.00.05  - Remove wish_block from init routine                            */
  80. /*          - Use linux/spinlock.h instead of asm/spinlock.h for kernels     */
  81. /*            2.3.18 and later                                               */
  82. /*          - Sync with other changes from the 2.3 kernels                   */
  83. /* 4.00.06  - Fix timeout with initial FFDC command                          */
  84. /* 4.00.06a - Port to 2.4 (trivial) -- Christoph Hellwig <hch@infradead.org> */
  85. /* 4.10.00  - Add support for ServeRAID 4M/4L                                */
  86. /* 4.10.13  - Fix for dynamic unload and proc file system                    */
  87. /* 4.20.03  - Rename version to coincide with new release schedules          */
  88. /*            Performance fixes                                              */
  89. /*            Fix truncation of /proc files with cat                         */
  90. /*            Merge in changes through kernel 2.4.0test1ac21                 */
  91. /* 4.20.13  - Fix some failure cases / reset code                            */
  92. /*          - Hook into the reboot_notifier to flush the controller cache    */
  93. /* 4.50.01  - Fix problem when there is a hole in logical drive numbering    */
  94. /* 4.70.09  - Use a Common ( Large Buffer ) for Flashing from the JCRM CD    */
  95. /*          - Add IPSSEND Flash Support                                      */
  96. /*          - Set Sense Data for Unknown SCSI Command                        */
  97. /*          - Use Slot Number from NVRAM Page 5                              */
  98. /*          - Restore caller's DCDB Structure                                */
  99. /* 4.70.12  - Corrective actions for bad controller ( during initialization )*/
  100. /* 4.70.13  - Don't Send CDB's if we already know the device is not present  */
  101. /*          - Don't release HA Lock in ips_next() until SC taken off queue   */
  102. /*          - Unregister SCSI device in ips_release()                        */
  103. /* 4.70.15  - Fix Breakup for very large ( non-SG ) requests in ips_done()   */
  104. /* 4.71.00  - Change all memory allocations to not use GFP_DMA flag          */
  105. /*            Code Clean-Up for 2.4.x kernel                                 */
  106. /* 4.72.00  - Allow for a Scatter-Gather Element to exceed MAX_XFER Size     */
  107. /* 4.72.01  - I/O Mapped Memory release ( so "insmod ips" does not Fail )    */
  108. /*            Don't Issue Internal FFDC Command if there are Active Commands */
  109. /*            Close Window for getting too many IOCTL's active               */
  110. /* 4.80.00    Make ia64 Safe                                                 */
  111. /* 4.80.04    Eliminate calls to strtok() if 2.4.x or greater                */
  112. /*            Adjustments to Device Queue Depth                              */
  113. /* 4.80.14    Take all semaphores off stack                                  */
  114. /*            Clean Up New_IOCTL path                                        */
  115. /* 4.80.20    Set max_sectors in Scsi_Host structure ( if >= 2.4.7 kernel )  */
  116. /*            5 second delay needed after resetting an i960 adapter          */
  117. /*****************************************************************************/
  119. /*
  120.  * Conditional Compilation directives for this driver:
  121.  *
  122.  * IPS_DEBUG            - Turn on debugging info
  123.  *
  124.  *
  125.  * Parameters:
  126.  *
  127.  * debug:<number>       - Set debug level to <number>
  128.  *                        NOTE: only works when IPS_DEBUG compile directive
  129.  *                              is used.
  130.  *
  131.  *       1              - Normal debug messages
  132.  *       2              - Verbose debug messages
  133.  *       11             - Method trace (non interrupt)
  134.  *       12             - Method trace (includes interrupt)
  135.  *
  136.  * noreset              - Don't reset the controller
  137.  * nocmdline            - Turn off passthru support
  138.  * noi2o                - Don't use I2O Queues (ServeRAID 4 only)
  139.  * nommap               - Don't use memory mapped I/O
  140.  * ioctlsize            - Initial size of the IOCTL buffer
  141.  */
  142.  
  143. #include <asm/io.h>
  144. #include <asm/byteorder.h>
  145. #include <asm/page.h>
  146. #include <linux/stddef.h>
  147. #include <linux/version.h>
  148. #include <linux/string.h>
  149. #include <linux/errno.h>
  150. #include <linux/kernel.h>
  151. #include <linux/ioport.h>
  152. #include <linux/slab.h>
  153. #include <linux/vmalloc.h>
  154. #include <linux/delay.h>
  155. #include <linux/sched.h>
  156. #include <linux/pci.h>
  157. #include <linux/proc_fs.h>
  158. #include <linux/reboot.h>
  159. #include <linux/tqueue.h>
  160. #include <linux/interrupt.h>
  162. #include <linux/blk.h>
  163. #include <linux/types.h>
  165. #ifndef NO_IPS_CMDLINE
  166. #include <scsi/sg.h>
  167. #endif
  169. #include "sd.h"
  170. #include "scsi.h"
  171. #include "hosts.h"
  172. #include "ips.h"
  174. #include <linux/module.h>
  176. #include <linux/stat.h>
  177. #include <linux/config.h>
  179. #if LINUX_VERSION_CODE >= LinuxVersionCode(2,3,18)
  180. #include <linux/spinlock.h>
  181. #else
  182. #include <asm/spinlock.h>
  183. #endif
  185. #if LINUX_VERSION_CODE >= LinuxVersionCode(2,3,13)
  186. #include <linux/init.h>
  187. #endif
  189. #include <linux/smp.h>
  191. #ifdef MODULE
  192.    static char *ips = NULL;
  193.    MODULE_PARM(ips, "s");
  194. #endif
  196. /*
  197.  * DRIVER_VER
  198.  */
  199. #define IPS_VERSION_HIGH        "4.80"
  200. #define IPS_VERSION_LOW         ".26 "
  202. #if LINUX_VERSION_CODE < LinuxVersionCode(2,3,27)
  203. struct proc_dir_entry proc_scsi_ips = {
  204.    0,
  205.    3, "ips",
  206.    S_IFDIR | S_IRUGO | S_IXUGO, 2
  207. };
  208. #endif
  210. #if !defined(__i386__) && !defined(__ia64__)
  211.    #error "This driver has only been tested on the x86/ia64 platforms"
  212. #endif
  214. #if LINUX_VERSION_CODE < LinuxVersionCode(2,2,0)
  215.    #error "This driver only works with kernel 2.2.0 and later"
  216. #endif
  218. #if !defined(NO_IPS_CMDLINE) && ((SG_BIG_BUFF < 8192) || !defined(SG_BIG_BUFF))
  219.    #error "To use the command-line interface you need to define SG_BIG_BUFF"
  220. #endif
  222. #ifdef IPS_DEBUG
  223.    #define METHOD_TRACE(s, i)    if (ips_debug >= (i+10)) printk(KERN_NOTICE s "n");
  224.    #define DEBUG(i, s)           if (ips_debug >= i) printk(KERN_NOTICE s "n");
  225.    #define DEBUG_VAR(i, s, v...) if (ips_debug >= i) printk(KERN_NOTICE s "n", v);
  226. #else
  227.    #define METHOD_TRACE(s, i)
  228.    #define DEBUG(i, s)
  229.    #define DEBUG_VAR(i, s, v...)
  230. #endif
  232. /*
  233.  * global variables
  234.  */
  235. static const char   ips_name[] = "ips";
  236. static struct Scsi_Host * ips_sh[IPS_MAX_ADAPTERS];  /* Array of host controller structures */
  237. static ips_ha_t * ips_ha[IPS_MAX_ADAPTERS];          /* Array of HA structures */
  238. static unsigned int ips_next_controller = 0;
  239. static unsigned int ips_num_controllers = 0;
  240. static unsigned int ips_released_controllers = 0;
  241. static int          ips_cmd_timeout = 60;
  242. static int          ips_reset_timeout = 60 * 5;
  243. static int          ips_force_memio = 1;             /* Always use Memory Mapped I/O    */
  244. static int          ips_force_i2o = 1;               /* Always use I2O command delivery */
  245. static int          ips_resetcontroller = 1;         /* Reset the controller            */
  246. static int          ips_cmdline = 1;                 /* Support for passthru            */
  247. static int          ips_ioctlsize = IPS_IOCTL_SIZE;  /* Size of the ioctl buffer        */
  248. static int          ips_cd_boot = 0;                 /* Booting from ServeRAID Manager CD */
  249. static char        *ips_FlashData = NULL;            /* CD Boot - Flash Data Buffer      */
  250. static int          ips_FlashDataInUse = 0;          /* CD Boot - Flash Data In Use Flag */
  252. #ifdef IPS_DEBUG
  253. static int          ips_debug = 0;                   /* Debug mode                      */
  254. #endif
  256. /*
  257.  * Necessary forward function protoypes
  258.  */
  259. static int ips_halt(struct notifier_block *nb, ulong event, void *buf);
  261. #define MAX_ADAPTER_NAME 11
  263. static char ips_adapter_name[][30] = {
  264.    "ServeRAID",
  265.    "ServeRAID II",
  266.    "ServeRAID on motherboard",
  267.    "ServeRAID on motherboard",
  268.    "ServeRAID 3H",
  269.    "ServeRAID 3L",
  270.    "ServeRAID 4H",
  271.    "ServeRAID 4M",
  272.    "ServeRAID 4L",
  273.    "ServeRAID 4Mx",
  274.    "ServeRAID 4Lx"
  275. };
  277. static struct notifier_block ips_notifier = {
  278.    ips_halt, NULL, 0
  279. };
  281. /*
  282.  * Direction table
  283.  */
  284. static char ips_command_direction[] = {
  285. IPS_DATA_NONE, IPS_DATA_NONE, IPS_DATA_IN,   IPS_DATA_IN,   IPS_DATA_OUT,
  286. IPS_DATA_IN,   IPS_DATA_IN,   IPS_DATA_OUT,  IPS_DATA_IN,   IPS_DATA_UNK,
  287. IPS_DATA_OUT,  IPS_DATA_OUT,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,
  288. IPS_DATA_IN,   IPS_DATA_NONE, IPS_DATA_IN,   IPS_DATA_IN,   IPS_DATA_OUT,
  289. IPS_DATA_IN,   IPS_DATA_OUT,  IPS_DATA_NONE, IPS_DATA_NONE, IPS_DATA_OUT,
  290. IPS_DATA_NONE, IPS_DATA_IN,   IPS_DATA_NONE, IPS_DATA_IN,   IPS_DATA_OUT,
  291. IPS_DATA_NONE, IPS_DATA_UNK,  IPS_DATA_IN,   IPS_DATA_UNK,  IPS_DATA_IN,
  292. IPS_DATA_UNK,  IPS_DATA_OUT,  IPS_DATA_IN,   IPS_DATA_UNK,  IPS_DATA_UNK,
  293. IPS_DATA_IN,   IPS_DATA_IN,   IPS_DATA_OUT,  IPS_DATA_NONE, IPS_DATA_UNK,
  294. IPS_DATA_IN,   IPS_DATA_OUT,  IPS_DATA_OUT,  IPS_DATA_OUT,  IPS_DATA_OUT,
  295. IPS_DATA_OUT,  IPS_DATA_NONE, IPS_DATA_IN,   IPS_DATA_NONE, IPS_DATA_NONE,
  296. IPS_DATA_IN,   IPS_DATA_OUT,  IPS_DATA_OUT,  IPS_DATA_OUT,  IPS_DATA_OUT,
  297. IPS_DATA_IN,   IPS_DATA_OUT,  IPS_DATA_IN,   IPS_DATA_OUT,  IPS_DATA_OUT,
  298. IPS_DATA_OUT,  IPS_DATA_IN,   IPS_DATA_IN,   IPS_DATA_IN,   IPS_DATA_NONE,
  299. IPS_DATA_UNK,  IPS_DATA_NONE, IPS_DATA_NONE, IPS_DATA_NONE, IPS_DATA_UNK,
  300. IPS_DATA_NONE, IPS_DATA_OUT,  IPS_DATA_IN,   IPS_DATA_UNK,  IPS_DATA_UNK,
  301. IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,
  302. IPS_DATA_OUT,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,
  303. IPS_DATA_IN,   IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,
  304. IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,
  305. IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,
  306. IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,
  307. IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,
  308. IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,
  309. IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,
  310. IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,
  311. IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,
  312. IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,
  313. IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,
  314. IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,
  315. IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,
  316. IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,
  317. IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,
  318. IPS_DATA_NONE, IPS_DATA_NONE, IPS_DATA_UNK,  IPS_DATA_IN,   IPS_DATA_NONE,
  319. IPS_DATA_OUT,  IPS_DATA_UNK,  IPS_DATA_NONE, IPS_DATA_UNK,  IPS_DATA_OUT,
  320. IPS_DATA_OUT,  IPS_DATA_OUT,  IPS_DATA_OUT,  IPS_DATA_OUT,  IPS_DATA_NONE,
  321. IPS_DATA_UNK,  IPS_DATA_IN,   IPS_DATA_OUT,  IPS_DATA_IN,   IPS_DATA_IN,
  322. IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,
  323. IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,
  324. IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,
  325. IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,
  326. IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,
  327. IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,
  328. IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,
  329. IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,
  330. IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,
  331. IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_OUT,
  332. IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,
  333. IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,
  334. IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,
  335. IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK,  IPS_DATA_UNK
  336. };
  338. /*
  339.  * Function prototypes
  340.  */
  341. int ips_detect(Scsi_Host_Template *);
  342. int ips_release(struct Scsi_Host *);
  343. int ips_eh_abort(Scsi_Cmnd *);
  344. int ips_eh_reset(Scsi_Cmnd *);
  345. int ips_queue(Scsi_Cmnd *, void (*) (Scsi_Cmnd *));
  346. int ips_biosparam(Disk *, kdev_t, int *);
  347. const char * ips_info(struct Scsi_Host *);
  348. void do_ipsintr(int, void *, struct pt_regs *);
  349. static int ips_hainit(ips_ha_t *);
  350. static int ips_map_status(ips_ha_t *, ips_scb_t *, ips_stat_t *);
  351. static int ips_send(ips_ha_t *, ips_scb_t *, ips_scb_callback);
  352. static int ips_send_wait(ips_ha_t *, ips_scb_t *, int, int);
  353. static int ips_send_cmd(ips_ha_t *, ips_scb_t *);
  354. static int ips_online(ips_ha_t *, ips_scb_t *);
  355. static int ips_inquiry(ips_ha_t *, ips_scb_t *);
  356. static int ips_rdcap(ips_ha_t *, ips_scb_t *);
  357. static int ips_msense(ips_ha_t *, ips_scb_t *);
  358. static int ips_reqsen(ips_ha_t *, ips_scb_t *);
  359. static int ips_allocatescbs(ips_ha_t *);
  360. static int ips_reset_copperhead(ips_ha_t *);
  361. static int ips_reset_copperhead_memio(ips_ha_t *);
  362. static int ips_reset_morpheus(ips_ha_t *);
  363. static int ips_issue_copperhead(ips_ha_t *, ips_scb_t *);
  364. static int ips_issue_copperhead_memio(ips_ha_t *, ips_scb_t *);
  365. static int ips_issue_i2o(ips_ha_t *, ips_scb_t *);
  366. static int ips_issue_i2o_memio(ips_ha_t *, ips_scb_t *);
  367. static int ips_isintr_copperhead(ips_ha_t *);
  368. static int ips_isintr_copperhead_memio(ips_ha_t *);
  369. static int ips_isintr_morpheus(ips_ha_t *);
  370. static int ips_wait(ips_ha_t *, int, int);
  371. static int ips_write_driver_status(ips_ha_t *, int);
  372. static int ips_read_adapter_status(ips_ha_t *, int);
  373. static int ips_read_subsystem_parameters(ips_ha_t *, int);
  374. static int ips_read_config(ips_ha_t *, int);
  375. static int ips_clear_adapter(ips_ha_t *, int);
  376. static int ips_readwrite_page5(ips_ha_t *, int, int);
  377. static int ips_init_copperhead(ips_ha_t *);
  378. static int ips_init_copperhead_memio(ips_ha_t *);
  379. static int ips_init_morpheus(ips_ha_t *);
  380. static int ips_isinit_copperhead(ips_ha_t *);
  381. static int ips_isinit_copperhead_memio(ips_ha_t *);
  382. static int ips_isinit_morpheus(ips_ha_t *);
  383. static int ips_erase_bios(ips_ha_t *);
  384. static int ips_program_bios(ips_ha_t *, char *, u_int32_t, u_int32_t);
  385. static int ips_verify_bios(ips_ha_t *, char *, u_int32_t, u_int32_t);
  386. static int ips_erase_bios_memio(ips_ha_t *);
  387. static int ips_program_bios_memio(ips_ha_t *, char *, u_int32_t, u_int32_t);
  388. static int ips_verify_bios_memio(ips_ha_t *, char *, u_int32_t, u_int32_t);
  389. static void ips_flash_bios_section(void *);
  390. static void ips_flash_bios_segment(void *);
  391. static void ips_scheduled_flash_bios(void *);
  392. static void ips_create_nvrampage5(ips_ha_t *, IPS_NVRAM_P5 *);
  393. static void ips_get_bios_version(ips_ha_t *, int);
  394. static void ips_identify_controller(ips_ha_t *);
  395. static void ips_select_queue_depth(struct Scsi_Host *, Scsi_Device *);
  396. static void ips_chkstatus(ips_ha_t *, IPS_STATUS *);
  397. static void ips_enable_int_copperhead(ips_ha_t *);
  398. static void ips_enable_int_copperhead_memio(ips_ha_t *);
  399. static void ips_enable_int_morpheus(ips_ha_t *);
  400. static void ips_intr_copperhead(ips_ha_t *);
  401. static void ips_intr_morpheus(ips_ha_t *);
  402. static void ips_next(ips_ha_t *, int);
  403. static void ipsintr_blocking(ips_ha_t *, struct ips_scb *);
  404. static void ipsintr_done(ips_ha_t *, struct ips_scb *);
  405. static void ips_done(ips_ha_t *, ips_scb_t *);
  406. static void ips_free(ips_ha_t *);
  407. static void ips_init_scb(ips_ha_t *, ips_scb_t *);
  408. static void ips_freescb(ips_ha_t *, ips_scb_t *);
  409. static void ips_statinit(ips_ha_t *);
  410. static void ips_statinit_memio(ips_ha_t *);
  411. static void ips_fix_ffdc_time(ips_ha_t *, ips_scb_t *, time_t);
  412. static void ips_ffdc_reset(ips_ha_t *, int);
  413. static void ips_ffdc_time(ips_ha_t *, int);
  414. static u_int32_t ips_statupd_copperhead(ips_ha_t *);
  415. static u_int32_t ips_statupd_copperhead_memio(ips_ha_t *);
  416. static u_int32_t ips_statupd_morpheus(ips_ha_t *);
  417. static ips_scb_t * ips_getscb(ips_ha_t *);
  418. static inline void ips_putq_scb_head(ips_scb_queue_t *, ips_scb_t *);
  419. static inline void ips_putq_scb_tail(ips_scb_queue_t *, ips_scb_t *);
  420. static inline void ips_putq_wait_head(ips_wait_queue_t *, Scsi_Cmnd *);
  421. static inline void ips_putq_wait_tail(ips_wait_queue_t *, Scsi_Cmnd *);
  422. static inline void ips_putq_copp_head(ips_copp_queue_t *, ips_copp_wait_item_t *);
  423. static inline void ips_putq_copp_tail(ips_copp_queue_t *, ips_copp_wait_item_t *);
  424. static inline ips_scb_t * ips_removeq_scb_head(ips_scb_queue_t *);
  425. static inline ips_scb_t * ips_removeq_scb(ips_scb_queue_t *, ips_scb_t *);
  426. static inline Scsi_Cmnd * ips_removeq_wait_head(ips_wait_queue_t *);
  427. static inline Scsi_Cmnd * ips_removeq_wait(ips_wait_queue_t *, Scsi_Cmnd *);
  428. static inline ips_copp_wait_item_t * ips_removeq_copp(ips_copp_queue_t *, ips_copp_wait_item_t *);
  429. static inline ips_copp_wait_item_t * ips_removeq_copp_head(ips_copp_queue_t *);
  431. #ifndef NO_IPS_CMDLINE
  432. static int ips_is_passthru(Scsi_Cmnd *);
  433. static int ips_make_passthru(ips_ha_t *, Scsi_Cmnd *, ips_scb_t *, int);
  434. static int ips_usrcmd(ips_ha_t *, ips_passthru_t *, ips_scb_t *);
  435. static int ips_newusrcmd(ips_ha_t *, ips_passthru_t *, ips_scb_t *);
  436. static void ips_cleanup_passthru(ips_ha_t *, ips_scb_t *);
  437. #endif
  439. int  ips_proc_info(char *, char **, off_t, int, int, int);
  440. static int ips_host_info(ips_ha_t *, char *, off_t, int);
  441. static void copy_mem_info(IPS_INFOSTR *, char *, int);
  442. static int copy_info(IPS_INFOSTR *, char *, ...);
  444. /*--------------------------------------------------------------------------*/
  445. /* Exported Functions                                                       */
  446. /*--------------------------------------------------------------------------*/
  448. /****************************************************************************/
  449. /*                                                                          */
  450. /* Routine Name: ips_setup                                                  */
  451. /*                                                                          */
  452. /* Routine Description:                                                     */
  453. /*                                                                          */
  454. /*   setup parameters to the driver                                         */
  455. /*                                                                          */
  456. /****************************************************************************/
  457. #if LINUX_VERSION_CODE >= LinuxVersionCode(2,3,13)
  458. static int
  459. ips_setup(char *ips_str) {
  460. #else
  461. void
  462. ips_setup(char *ips_str, int *dummy) {
  463. #endif
  464.    int        i;
  466. #if LINUX_VERSION_CODE < LinuxVersionCode(2,4,0)
  467.    char      *p;
  468.    char       tokens[3] = {',', '.', 0};
  469. #endif
  471.    char      *key;
  472.    char      *value;
  473.    IPS_OPTION options[] = {
  474.       {"noreset", &ips_resetcontroller, 0},
  475. #ifdef IPS_DEBUG
  476.       {"debug", &ips_debug, 1},
  477. #endif
  478.       {"noi2o", &ips_force_i2o, 0},
  479.       {"nommap", &ips_force_memio, 0},
  480.       {"nocmdline", &ips_cmdline, 0},
  481.       {"ioctlsize", &ips_ioctlsize, IPS_IOCTL_SIZE},
  482.       {"cdboot", &ips_cd_boot, 0},
  483.    };
  485.    METHOD_TRACE("ips_setup", 1);
  487. /* Don't use strtok() anymore ( if 2.4 Kernel or beyond ) */
  488. #if LINUX_VERSION_CODE >= LinuxVersionCode(2,4,0)
  489.    /* Search for value */
  490.    while ((key = strsep(&ips_str, ",."))) {
  491.       if (!*key)
  492.          continue;
  493.       value = strchr(key, ':');
  494.       if (value)
  495.          *value++ = '';
  496.      /*
  497.       * We now have key/value pairs.
  498.       * Update the variables
  499.       */
  500.       for (i = 0; i < (sizeof(options) / sizeof(options[0])); i++) {
  501.         if (strnicmp(key, options[i].option_name, strlen(options[i].option_name)) == 0) {
  502.            if (value)
  503.               *options[i].option_flag = simple_strtoul(value, NULL, 0);
  504.            else
  505.               *options[i].option_flag = options[i].option_value;
  506.            break;
  507.         }
  508.       }
  509.    }
  510. #else
  511.    for (key = strtok(ips_str, tokens); key; key = strtok(NULL, tokens)) {
  512.       p = key;
  514.       /* Search for value */
  515.       while ((p) && (*p != ':'))
  516.          p++;
  518.       if (p) {
  519.          *p = '';
  520.          value = p+1;
  521.       } else
  522.          value = NULL;
  524.       /*
  525.        * We now have key/value pairs.
  526.        * Update the variables
  527.        */
  528.       for (i = 0; i < (sizeof(options) / sizeof(options[0])); i++) {
  529.          if (strnicmp(key, options[i].option_name, strlen(ips_str)) == 0) {
  530.             if (value)
  531.                *options[i].option_flag = simple_strtoul(value, NULL, 0);
  532.             else
  533.                *options[i].option_flag = options[i].option_value;
  535.             break;
  536.          }
  537.       }
  538.    }
  539. #endif
  541. #if LINUX_VERSION_CODE >= LinuxVersionCode(2,3,13)
  542.    return (1);
  543. #endif
  544. }
  546. #if LINUX_VERSION_CODE >= LinuxVersionCode(2,3,13)
  547. __setup("ips=", ips_setup);
  548. #endif
  550. /****************************************************************************/
  551. /*                                                                          */
  552. /* Routine Name: ips_detect                                                 */
  553. /*                                                                          */
  554. /* Routine Description:                                                     */
  555. /*                                                                          */
  556. /*   Detect and initialize the driver                                       */
  557. /*                                                                          */
  558. /* NOTE: this routine is called under the io_request_lock spinlock          */
  559. /*                                                                          */
  560. /****************************************************************************/
  561. int
  562. ips_detect(Scsi_Host_Template *SHT) {
  563.    struct Scsi_Host *sh;
  564.    ips_ha_t         *ha;
  565.    u_int32_t         io_addr;
  566.    u_int32_t         mem_addr;
  567.    u_int32_t         io_len;
  568.    u_int32_t         mem_len;
  569.    u_int16_t         planer;
  570.    u_int8_t          revision_id;
  571.    u_int8_t          bus;
  572.    u_int8_t          func;
  573.    u_int8_t          irq;
  574.    u_int16_t         deviceID[2];
  575.    u_int16_t         subdevice_id;
  576.    int               i;
  577.    int               j;
  578.    u_int32_t         count;
  579.    char             *ioremap_ptr;
  580.    char             *mem_ptr;
  581.    struct pci_dev   *dev[2];
  582.    struct pci_dev   *morpheus = NULL;
  583.    struct pci_dev   *trombone = NULL;
  584. #if LINUX_VERSION_CODE < LinuxVersionCode(2,3,14)
  585.    u_int32_t         currbar;
  586.    u_int32_t         maskbar;
  587.    u_int8_t          barnum;
  588. #endif
  590.    METHOD_TRACE("ips_detect", 1);
  592. #ifdef MODULE
  593.    if (ips)
  594. #if LINUX_VERSION_CODE >= LinuxVersionCode(2,3,13)
  595.       ips_setup(ips);
  596. #else
  597.       ips_setup(ips, NULL);
  598. #endif
  599. #endif
  601.    /* If Booting from the ServeRAID Manager CD, Allocate a large Flash  */
  602.    /* Buffer ( so we won't need to allocate one for each adapter ).     */
  603.     if ( ips_cd_boot ) {            
  604.       ips_FlashData = ( char * ) __get_free_pages( GFP_KERNEL, 7 );   
  605.       if (ips_FlashData == NULL) {
  606.          /* The validity of this pointer is checked in ips_make_passthru() before it is used */
  607.          printk( KERN_WARNING "ERROR: Can't Allocate Large Buffer for Flashingn" );
  608.       }
  609.    }                                                                               
  611.    SHT->proc_info = ips_proc_info;
  612. #if LINUX_VERSION_CODE < LinuxVersionCode(2,3,27)
  613.    SHT->proc_dir = &proc_scsi_ips;
  614. #else
  615.    SHT->proc_name = "ips";
  616. #endif
  618. #if defined(CONFIG_PCI)
  620.    /* initalize number of controllers */
  621.    ips_num_controllers = 0;
  622.    ips_next_controller = 0;
  623.    ips_released_controllers = 0;
  625.    if (!pci_present())
  626.       return (0);
  628.    morpheus = pci_find_device(IPS_VENDORID, IPS_DEVICEID_MORPHEUS, morpheus);
  629.    trombone = pci_find_device(IPS_VENDORID, IPS_DEVICEID_COPPERHEAD, trombone);
  631.    /* determine which controller to probe first */
  632.    if (!morpheus) {
  633.       /* we only have trombone */
  634.       dev[0] = trombone;
  635.       dev[1] = NULL;
  636.       deviceID[0] = IPS_DEVICEID_COPPERHEAD;
  637.    } else if (!trombone) {
  638.       /* we only have morpheus */
  639.       dev[0] = morpheus;
  640.       dev[1] = NULL;
  641.       deviceID[0] = IPS_DEVICEID_MORPHEUS;
  642.    } else {
  643.       /* we have both in the system */
  644.       if (trombone->bus->number < morpheus->bus->number) {
  645.          dev[0] = trombone;
  646.          dev[1] = morpheus;
  647.          deviceID[0] = IPS_DEVICEID_COPPERHEAD;
  648.          deviceID[1] = IPS_DEVICEID_MORPHEUS;
  649.       } else if (trombone->bus->number > morpheus->bus->number) {
  650.          dev[0] = morpheus;
  651.          dev[1] = trombone;
  652.          deviceID[0] = IPS_DEVICEID_MORPHEUS;
  653.          deviceID[1] = IPS_DEVICEID_COPPERHEAD;
  654.       } else {
  655.          /* further detection required */
  656.          if (trombone->devfn < morpheus->devfn) {
  657.             dev[0] = trombone;
  658.             dev[1] = morpheus;
  659.             deviceID[0] = IPS_DEVICEID_COPPERHEAD;
  660.             deviceID[1] = IPS_DEVICEID_MORPHEUS;
  661.          } else {
  662.             dev[0] = morpheus;
  663.             dev[1] = trombone;
  664.             deviceID[0] = IPS_DEVICEID_MORPHEUS;
  665.             deviceID[1] = IPS_DEVICEID_COPPERHEAD;
  666.          }
  667.       }
  668.    }
  670.    /* Now scan the controllers */
  671.    for (i = 0; i < 2; i++) {
  672.       if (!dev[i])
  673.          break;
  675.       do {
  676.          if (ips_next_controller >= IPS_MAX_ADAPTERS)
  677.             break;
  679. #if LINUX_VERSION_CODE >= LinuxVersionCode(2,4,0)
  680.          if (pci_enable_device(dev[i]))
  681.             break;
  682. #endif
  684.          /* stuff that we get in dev */
  685.          irq = dev[i]->irq;
  686.          bus = dev[i]->bus->number;
  687.          func = dev[i]->devfn;
  689.          /* Init MEM/IO addresses to 0 */
  690.          mem_addr = 0;
  691.          io_addr = 0;
  692.          mem_len = 0;
  693.          io_len = 0;
  695.          for (j = 0; j < 2; j++) {
  696. #if LINUX_VERSION_CODE >= LinuxVersionCode(2,4,0)
  697.             if (!pci_resource_start(dev[i], j))
  698.                break;
  700.             if (pci_resource_flags(dev[i], j) & IORESOURCE_IO) {
  701.                io_addr = pci_resource_start(dev[i], j);
  702.                io_len = pci_resource_len(dev[i], j);
  703.             } else {
  704.                mem_addr = pci_resource_start(dev[i], j);
  705.                mem_len = pci_resource_len(dev[i], j);
  706.             }
  707. #elif LINUX_VERSION_CODE >= LinuxVersionCode(2,3,14)
  708.             if (!dev[i]->resource[j].start)
  709.                break;
  711.             if ((dev[i]->resource[j].start & PCI_BASE_ADDRESS_SPACE) == PCI_BASE_ADDRESS_SPACE_IO) {
  712.                io_addr = dev[i]->resource[j].start;
  713.                io_len = dev[i]->resource[j].end - dev[i]->resource[j].start + 1;
  714.             } else {
  715.                mem_addr = dev[i]->resource[j].start;
  716.                mem_len = dev[i]->resource[j].end - dev[i]->resource[j].start + 1;
  717.             }
  718. #else
  719.             if (!dev[i]->base_address[j])
  720.                break;
  722.             if ((dev[i]->base_address[j] & PCI_BASE_ADDRESS_SPACE) == PCI_BASE_ADDRESS_SPACE_IO) {
  723.                barnum = PCI_BASE_ADDRESS_0 + (j * 4);
  724.                io_addr = dev[i]->base_address[j] & PCI_BASE_ADDRESS_IO_MASK;
  726.                /* Get Size */
  727.                pci_read_config_dword(dev[i], barnum, &currbar);
  728.                pci_write_config_dword(dev[i], barnum, ~0);
  729.                pci_read_config_dword(dev[i], barnum, &maskbar);
  730.                pci_write_config_dword(dev[i], barnum, currbar);
  732.                io_len = ~(maskbar & PCI_BASE_ADDRESS_IO_MASK) + 1;
  733.             } else {
  734.                barnum = PCI_BASE_ADDRESS_0 + (j * 4);
  735.                mem_addr = dev[i]->base_address[j] & PCI_BASE_ADDRESS_MEM_MASK;
  737.                /* Get Size */
  738.                pci_read_config_dword(dev[i], barnum, &currbar);
  739.                pci_write_config_dword(dev[i], barnum, ~0);
  740.                pci_read_config_dword(dev[i], barnum, &maskbar);
  741.                pci_write_config_dword(dev[i], barnum, currbar);
  743.                mem_len = ~(maskbar & PCI_BASE_ADDRESS_MEM_MASK) + 1;
  744.             }
  745. #endif
  746.          }
  748.          /* setup memory mapped area (if applicable) */
  749.          if (mem_addr) {
  750.             u_int32_t base;
  751.             u_int32_t offs;
  753.             DEBUG_VAR(1, "(%s%d) detect, Memory region %x, size: %d",
  754.                       ips_name, ips_next_controller, mem_addr, mem_len);
  756. #if LINUX_VERSION_CODE >= LinuxVersionCode(2,3,17)
  757.             if (check_mem_region(mem_addr, mem_len)) {
  758.                /* Couldn't allocate io space */
  759.                printk(KERN_WARNING "(%s%d) couldn't allocate IO space %x len %d.n",
  760.                       ips_name, ips_next_controller, io_addr, io_len);
  762.                ips_next_controller++;
  764.                continue;
  765.             }
  767.             request_mem_region(mem_addr, mem_len, "ips");
  768. #endif
  770.             base = mem_addr & PAGE_MASK;
  771.             offs = mem_addr - base;
  773.             ioremap_ptr = ioremap(base, PAGE_SIZE);
  774.             mem_ptr = ioremap_ptr + offs;
  775.          } else {
  776.             ioremap_ptr = NULL;
  777.             mem_ptr = NULL;
  778.          }
  780.          /* setup I/O mapped area (if applicable) */
  781.          if (io_addr) {
  782.             DEBUG_VAR(1, "(%s%d) detect, IO region %x, size: %d",
  783.                       ips_name, ips_next_controller, io_addr, io_len);
  785.             if (check_region(io_addr, io_len)) {
  786.                /* Couldn't allocate io space */
  787.                printk(KERN_WARNING "(%s%d) couldn't allocate IO space %x len %d.n",
  788.                       ips_name, ips_next_controller, io_addr, io_len);
  790.                ips_next_controller++;
  792.                continue;
  793.             }
  795.             request_region(io_addr, io_len, "ips");
  796.          }
  798.          /* get planer status */
  799.          if (pci_read_config_word(dev[i], 0x04, &planer)) {
  800.             printk(KERN_WARNING "(%s%d) can't get planer status.n",
  801.                    ips_name, ips_next_controller);
  803.             ips_next_controller++;
  805.             continue;
  806.          }
  808.          /* check to see if an onboard planer controller is disabled */
  809.          if (!(planer & 0x000C)) {
  811.             DEBUG_VAR(1, "(%s%d) detect, Onboard ServeRAID disabled by BIOS",
  812.                       ips_name, ips_next_controller);
  814.             ips_next_controller++;
  816.             continue;
  817.          }
  819.          DEBUG_VAR(1, "(%s%d) detect bus %d, func %x, irq %d, io %x, mem: %x, ptr: %p",
  820.                    ips_name, ips_next_controller, bus, func, irq, io_addr, mem_addr, mem_ptr);
  822.          /* get the revision ID */
  823.          if (pci_read_config_byte(dev[i], PCI_REVISION_ID, &revision_id)) {
  824.             printk(KERN_WARNING "(%s%d) can't get revision id.n",
  825.                    ips_name, ips_next_controller);
  827.             ips_next_controller++;
  829.             continue;
  830.          }
  832. #if LINUX_VERSION_CODE < LinuxVersionCode(2,3,15)
  833.          /* get the subdevice id */
  834.          if (pci_read_config_word(dev[i], PCI_SUBSYSTEM_ID, &subdevice_id)) {
  835.             printk(KERN_WARNING "(%s%d) can't get subdevice id.n",
  836.                    ips_name, ips_next_controller);
  838.             ips_next_controller++;
  840.             continue;
  841.          }
  842. #else
  843.          subdevice_id = dev[i]->subsystem_device;
  844. #endif
  846.          /* found a controller */
  847.          sh = scsi_register(SHT, sizeof(ips_ha_t));
  849.          if (sh == NULL) {
  850.             printk(KERN_WARNING "(%s%d) Unable to register controller with SCSI subsystem - skipping controllern",
  851.                    ips_name, ips_next_controller);
  853.             ips_next_controller++;
  855.             continue;
  856.          }
  858.          ha = IPS_HA(sh);
  859.          memset(ha, 0, sizeof(ips_ha_t));
  861.          /* Initialize spin lock */
  862.          spin_lock_init(&ha->scb_lock);
  863.          spin_lock_init(&ha->copp_lock);
  864.          spin_lock_init(&ha->ips_lock);
  865.          spin_lock_init(&ha->copp_waitlist.lock);
  866.          spin_lock_init(&ha->scb_waitlist.lock);
  867.          spin_lock_init(&ha->scb_activelist.lock);
  869.          ips_sh[ips_next_controller] = sh;
  870.          ips_ha[ips_next_controller] = ha;
  871.          ips_num_controllers++;
  872.          ha->active = 1;
  874.          ha->enq = kmalloc(sizeof(IPS_ENQ), GFP_KERNEL);
  876.          if (!ha->enq) {
  877.             printk(KERN_WARNING "(%s%d) Unable to allocate host inquiry structure - skipping contollern",
  878.                    ips_name, ips_next_controller);
  880.             ha->active = 0;
  881.             ips_free(ha);
  882.             scsi_unregister(sh);
  883.             ips_ha[ips_next_controller] = 0;
  884.             ips_sh[ips_next_controller] = 0;
  885.             ips_next_controller++;
  886.             ips_num_controllers--;
  888.             continue;
  889.          }
  891.          ha->adapt = kmalloc(sizeof(IPS_ADAPTER), GFP_KERNEL);
  893.          if (!ha->adapt) {
  894.             printk(KERN_WARNING "(%s%d) Unable to allocate host adapt structure - skipping controllern",
  895.                    ips_name, ips_next_controller);
  897.             ha->active = 0;
  898.             ips_free(ha);
  899.             scsi_unregister(sh);
  900.             ips_ha[ips_next_controller] = 0;
  901.             ips_sh[ips_next_controller] = 0;
  902.             ips_next_controller++;
  903.             ips_num_controllers--;
  905.             continue;
  906.          }
  908.          ha->conf = kmalloc(sizeof(IPS_CONF), GFP_KERNEL);
  910.          if (!ha->conf) {
  911.             printk(KERN_WARNING "(%s%d) Unable to allocate host conf structure - skipping controllern",
  912.                    ips_name, ips_next_controller);
  914.             ha->active = 0;
  915.             ips_free(ha);
  916.             scsi_unregister(sh);
  917.             ips_ha[ips_next_controller] = 0;
  918.             ips_sh[ips_next_controller] = 0;
  919.             ips_next_controller++;
  920.             ips_num_controllers--;
  922.             continue;
  923.          }
  925.          ha->nvram = kmalloc(sizeof(IPS_NVRAM_P5), GFP_KERNEL);
  927.          if (!ha->nvram) {
  928.             printk(KERN_WARNING "(%s%d) Unable to allocate host nvram structure - skipping controllern",
  929.                    ips_name, ips_next_controller);
  931.             ha->active = 0;
  932.             ips_free(ha);
  933.             scsi_unregister(sh);
  934.             ips_ha[ips_next_controller] = 0;
  935.             ips_sh[ips_next_controller] = 0;
  936.             ips_next_controller++;
  937.             ips_num_controllers--;
  939.             continue;
  940.          }
  942.          ha->subsys = kmalloc(sizeof(IPS_SUBSYS), GFP_KERNEL);
  944.          if (!ha->subsys) {
  945.             printk(KERN_WARNING "(%s%d) Unable to allocate host subsystem structure - skipping controllern",
  946.                    ips_name, ips_next_controller);
  948.             ha->active = 0;
  949.             ips_free(ha);
  950.             scsi_unregister(sh);
  951.             ips_ha[ips_next_controller] = 0;
  952.             ips_sh[ips_next_controller] = 0;
  953.             ips_next_controller++;
  954.             ips_num_controllers--;
  956.             continue;
  957.          }
  959.          ha->dummy = kmalloc(sizeof(IPS_IO_CMD), GFP_KERNEL);
  961.          if (!ha->dummy) {
  962.             printk(KERN_WARNING "(%s%d) Unable to allocate host dummy structure - skipping controllern",
  963.                    ips_name, ips_next_controller);
  965.             ha->active = 0;
  966.             ips_free(ha);
  967.             scsi_unregister(sh);
  968.             ips_ha[ips_next_controller] = 0;
  969.             ips_sh[ips_next_controller] = 0;
  970.             ips_next_controller++;
  971.             ips_num_controllers--;
  973.             continue;
  974.          }
  976.          for (count = PAGE_SIZE, ha->ioctl_order = 0;
  977.               count < ips_ioctlsize;
  978.               ha->ioctl_order++, count <<= 1);
  980.          ha->ioctl_data = (char *) __get_free_pages(GFP_KERNEL, ha->ioctl_order);
  981.          ha->ioctl_datasize = count;
  983.          if (!ha->ioctl_data) {
  984.             printk(KERN_WARNING "(%s%d) Unable to allocate ioctl datan",
  985.                    ips_name, ips_next_controller);
  987.             ha->ioctl_data = NULL;
  988.             ha->ioctl_order = 0;
  989.             ha->ioctl_datasize = 0;
  990.          }
  992.          /* Store away needed values for later use */
  993.          sh->io_port = io_addr;
  994.          sh->n_io_port = io_addr ? 255 : 0;
  995.          sh->unique_id = (io_addr) ? io_addr : mem_addr;
  996.          sh->irq = irq;
  997.          sh->select_queue_depths = ips_select_queue_depth;
  998.          sh->sg_tablesize = sh->hostt->sg_tablesize;
  999.          sh->can_queue = sh->hostt->can_queue;
  1000.          sh->cmd_per_lun = sh->hostt->cmd_per_lun;
  1001.          sh->unchecked_isa_dma = sh->hostt->unchecked_isa_dma;
  1002.          sh->use_clustering = sh->hostt->use_clustering;
  1004. #if LINUX_VERSION_CODE >= LinuxVersionCode(2,4,7)
  1005.          sh->max_sectors = 128;
  1006. #endif
  1008. #if LINUX_VERSION_CODE < LinuxVersionCode(2,3,32)
  1009.          sh->wish_block = FALSE;
  1010. #endif
  1012.          /* Store info in HA structure */
  1013.          ha->irq = irq;
  1014.          ha->io_addr = io_addr;
  1015.          ha->io_len = io_len;
  1016.          ha->mem_addr = mem_addr;
  1017.          ha->mem_len = mem_len;
  1018.          ha->mem_ptr = mem_ptr;
  1019.          ha->ioremap_ptr = ioremap_ptr;
  1020.          ha->host_num = ips_next_controller;
  1021.          ha->revision_id = revision_id;
  1022.          ha->slot_num = PCI_SLOT(dev[i]->devfn);
  1023.          ha->device_id = deviceID[i];
  1024.          ha->subdevice_id = subdevice_id;
  1025.          ha->pcidev = dev[i];
  1027.          /*
  1028.           * Setup Functions
  1029.           */
  1030.          if (IPS_IS_MORPHEUS(ha)) {
  1031.             /* morpheus */
  1032.             ha->func.isintr = ips_isintr_morpheus;
  1033.             ha->func.isinit = ips_isinit_morpheus;
  1034.             ha->func.issue = ips_issue_i2o_memio;
  1035.             ha->func.init = ips_init_morpheus;
  1036.             ha->func.statupd = ips_statupd_morpheus;
  1037.             ha->func.reset = ips_reset_morpheus;
  1038.             ha->func.intr = ips_intr_morpheus;
  1039.             ha->func.enableint = ips_enable_int_morpheus;
  1040.          } else if (IPS_USE_MEMIO(ha)) {
  1041.             /* copperhead w/MEMIO */
  1042.             ha->func.isintr = ips_isintr_copperhead_memio;
  1043.             ha->func.isinit = ips_isinit_copperhead_memio;
  1044.             ha->func.init = ips_init_copperhead_memio;
  1045.             ha->func.statupd = ips_statupd_copperhead_memio;
  1046.             ha->func.statinit = ips_statinit_memio;
  1047.             ha->func.reset = ips_reset_copperhead_memio;
  1048.             ha->func.intr = ips_intr_copperhead;
  1049.             ha->func.erasebios = ips_erase_bios_memio;
  1050.             ha->func.programbios = ips_program_bios_memio;
  1051.             ha->func.verifybios = ips_verify_bios_memio;
  1052.             ha->func.enableint = ips_enable_int_copperhead_memio;
  1054.             if (IPS_USE_I2O_DELIVER(ha))
  1055.                ha->func.issue = ips_issue_i2o_memio;
  1056.             else
  1057.                ha->func.issue = ips_issue_copperhead_memio;
  1058.          } else {
  1059.             /* copperhead */
  1060.             ha->func.isintr = ips_isintr_copperhead;
  1061.             ha->func.isinit = ips_isinit_copperhead;
  1062.             ha->func.init = ips_init_copperhead;
  1063.             ha->func.statupd = ips_statupd_copperhead;
  1064.             ha->func.statinit = ips_statinit;
  1065.             ha->func.reset = ips_reset_copperhead;
  1066.             ha->func.intr = ips_intr_copperhead;
  1067.             ha->func.erasebios = ips_erase_bios;
  1068.             ha->func.programbios = ips_program_bios;
  1069.             ha->func.verifybios = ips_verify_bios;
  1070.             ha->func.enableint = ips_enable_int_copperhead;
  1072.             if (IPS_USE_I2O_DELIVER(ha))
  1073.                ha->func.issue = ips_issue_i2o;
  1074.             else
  1075.                ha->func.issue = ips_issue_copperhead;
  1076.          }
  1078.          /*
  1079.           * Initialize the card if it isn't already
  1080.           */
  1081.          if (!(*ha->func.isinit)(ha)) {
  1082.             if (!(*ha->func.init)(ha)) {
  1083.                /*
  1084.                 * Initialization failed
  1085.                 */
  1086.                printk(KERN_WARNING "(%s%d) unable to initialize controller - skipping controllern",
  1087.                       ips_name, ips_next_controller);
  1089.                ha->active = 0;
  1090.                ips_free(ha);
  1091.                scsi_unregister(sh);
  1092.                ips_ha[ips_next_controller] = 0;
  1093.                ips_sh[ips_next_controller] = 0;
  1094.                ips_next_controller++;
  1095.                ips_num_controllers--;
  1097.                continue;
  1098.             }
  1099.          }
  1101.          /* install the interrupt handler */
  1102.          if (request_irq(irq, do_ipsintr, SA_SHIRQ, ips_name, ha)) {
  1103.             printk(KERN_WARNING "(%s%d) unable to install interrupt handler - skipping controllern",
  1104.                    ips_name, ips_next_controller);
  1106.             ha->active = 0;
  1107.             ips_free(ha);
  1108.             scsi_unregister(sh);
  1109.             ips_ha[ips_next_controller] = 0;
  1110.             ips_sh[ips_next_controller] = 0;
  1111.             ips_next_controller++;
  1112.             ips_num_controllers--;
  1114.             continue;
  1115.          }
  1117.          /*
  1118.           * Allocate a temporary SCB for initialization
  1119.           */
  1120.          ha->scbs = (ips_scb_t *) kmalloc(sizeof(ips_scb_t), GFP_KERNEL);
  1121.          if (!ha->scbs) {
  1122.             /* couldn't allocate a temp SCB */
  1123.             printk(KERN_WARNING "(%s%d) unable to allocate CCBs - skipping contollern",
  1124.                    ips_name, ips_next_controller);
  1126.             ha->active = 0;
  1127.             ips_free(ha);
  1128.             scsi_unregister(sh);
  1129.             ips_ha[ips_next_controller] = 0;
  1130.             ips_sh[ips_next_controller] = 0;
  1131.             free_irq(ha->irq, ha);
  1132.             ips_next_controller++;
  1133.             ips_num_controllers--;
  1135.             continue;
  1136.          }
  1138.          memset(ha->scbs, 0, sizeof(ips_scb_t));
  1139.          ha->scbs->sg_list = (IPS_SG_LIST *) kmalloc(sizeof(IPS_SG_LIST) * IPS_MAX_SG, GFP_KERNEL);
  1140.          if (!ha->scbs->sg_list) {
  1141.             /* couldn't allocate a temp SCB S/G list */
  1142.             printk(KERN_WARNING "(%s%d) unable to allocate CCBs - skipping contollern",
  1143.                    ips_name, ips_next_controller);
  1145.             ha->active = 0;
  1146.             ips_free(ha);
  1147.             scsi_unregister(sh);
  1148.             ips_ha[ips_next_controller] = 0;
  1149.             ips_sh[ips_next_controller] = 0;
  1150.             free_irq(ha->irq, ha);
  1151.             ips_next_controller++;
  1152.             ips_num_controllers--;
  1154.             continue;
  1155.          }
  1157.          ha->max_cmds = 1;
  1159.          ips_next_controller++;
  1160.       } while ((dev[i] = pci_find_device(IPS_VENDORID, deviceID[i], dev[i])));
  1161.    }
  1163.    /*
  1164.     * Do Phase 2 Initialization
  1165.     * Controller init
  1166.     */
  1167.    for (i = 0; i < ips_next_controller; i++) {
  1169.       if (ips_ha[i] == 0) {
  1170.          printk(KERN_WARNING "(%s%d) ignoring bad controllern",
  1171.                 ips_name, i);
  1172.          continue;
  1173.       }
  1175.       ha = ips_ha[i];
  1176.       sh = ips_sh[i];
  1178.       if (!ha->active) {
  1179.          scsi_unregister(sh);
  1180.          ips_ha[i] = NULL;
  1181.          ips_sh[i] = NULL;
  1183.          continue;
  1184.       }
  1186.       if (!ips_hainit(ha)) {
  1187.          printk(KERN_WARNING "(%s%d) unable to initialize controller - skippingn",
  1188.                 ips_name, i);
  1190.          ha->active = 0;
  1191.          ips_free(ha);
  1192.          free_irq(ha->irq, ha);
  1193.          scsi_unregister(sh);
  1194.          ips_ha[i] = NULL;
  1195.          ips_sh[i] = NULL;
  1196.          ips_num_controllers--;
  1198.          continue;
  1199.       }
  1201.       /*
  1202.        * Free the temporary SCB
  1203.        */
  1204.       kfree(ha->scbs->sg_list);
  1205.       kfree(ha->scbs);
  1206.       ha->scbs = NULL;
  1208.       /* allocate CCBs */
  1209.       if (!ips_allocatescbs(ha)) {
  1210.          printk(KERN_WARNING "(%s%d) unable to allocate CCBs - skipping contollern",
  1211.                 ips_name, i);
  1213.          ha->active = 0;
  1214.          ips_free(ha);
  1215.          free_irq(ha->irq, ha);
  1216.          scsi_unregister(sh);
  1217.          ips_ha[i] = NULL;
  1218.          ips_sh[i] = NULL;
  1219.          ips_num_controllers--;
  1221.          continue;
  1222.       }
  1224.       /* finish setting values */
  1225.       sh->max_id = ha->ntargets;
  1226.       sh->max_lun = ha->nlun;
  1227.       sh->max_channel = ha->nbus - 1;
  1228.       sh->can_queue = ha->max_cmds-1;
  1229.    }
  1231.    if (ips_num_controllers > 0)
  1232.       register_reboot_notifier(&ips_notifier);
  1234.    return (ips_num_controllers);
  1236. #else
  1238.    /* No PCI -- No ServeRAID */
  1239.    return (0);
  1240. #endif /* CONFIG_PCI */
  1241. }
  1243. /****************************************************************************/
  1244. /*                                                                          */
  1245. /* Routine Name: ips_release                                                */
  1246. /*                                                                          */
  1247. /* Routine Description:                                                     */
  1248. /*                                                                          */
  1249. /*   Remove a driver                                                        */
  1250. /*                                                                          */
  1251. /****************************************************************************/
  1252. int
  1253. ips_release(struct Scsi_Host *sh) {
  1254.    ips_scb_t *scb;
  1255.    ips_ha_t  *ha;
  1256.    int        i;
  1258.    METHOD_TRACE("ips_release", 1);
  1260.    for (i = 0; i < IPS_MAX_ADAPTERS && ips_sh[i] != sh; i++);
  1262.    if (i == IPS_MAX_ADAPTERS) {
  1263.       printk(KERN_WARNING "(%s) release, invalid Scsi_Host pointer.n",
  1264.             ips_name);
  1265. #if LINUX_VERSION_CODE >= LinuxVersionCode(2,4,0)
  1266.       BUG();
  1267. #endif
  1268.       return (FALSE);
  1269.    }
  1271.    ha = IPS_HA(sh);
  1273.    if (!ha)
  1274.       return (FALSE);
  1276.    /* flush the cache on the controller */
  1277.    scb = &ha->scbs[ha->max_cmds-1];
  1279.    ips_init_scb(ha, scb);
  1281.    scb->timeout = ips_cmd_timeout;
  1282.    scb->cdb[0] = IPS_CMD_FLUSH;
  1284.    scb->cmd.flush_cache.op_code = IPS_CMD_FLUSH;
  1285.    scb->cmd.flush_cache.command_id = IPS_COMMAND_ID(ha, scb);
  1286.    scb->cmd.flush_cache.state = IPS_NORM_STATE;
  1287.    scb->cmd.flush_cache.reserved = 0;
  1288.    scb->cmd.flush_cache.reserved2 = 0;
  1289.    scb->cmd.flush_cache.reserved3 = 0;
  1290.    scb->cmd.flush_cache.reserved4 = 0;
  1292.    printk(KERN_NOTICE "(%s%d) Flushing Cache.n", ips_name, ha->host_num);
  1294.    /* send command */
  1295.    if (ips_send_wait(ha, scb, ips_cmd_timeout, IPS_INTR_ON) == IPS_FAILURE)
  1296.       printk(KERN_NOTICE "(%s%d) Incomplete Flush.n", ips_name, ha->host_num);
  1298.    printk(KERN_NOTICE "(%s%d) Flushing Complete.n", ips_name, ha->host_num);
  1300.    ips_sh[i] = NULL;
  1301.    ips_ha[i] = NULL;
  1303.    /* free extra memory */
  1304.    ips_free(ha);
  1306.    /* Free I/O Region */
  1307.    if (ha->io_addr)
  1308.       release_region(ha->io_addr, ha->io_len);
  1310.    /* free IRQ */
  1311.    free_irq(ha->irq, ha);
  1313.    scsi_unregister(sh);
  1315.    ips_released_controllers++;
  1317.    if (ips_num_controllers == ips_released_controllers)
  1318.       unregister_reboot_notifier(&ips_notifier);
  1320.    return (FALSE);
  1321. }
  1323. /****************************************************************************/
  1324. /*                                                                          */
  1325. /* Routine Name: ips_halt                                                   */
  1326. /*                                                                          */
  1327. /* Routine Description:                                                     */
  1328. /*                                                                          */
  1329. /*   Perform cleanup when the system reboots                                */
  1330. /*                                                                          */
  1331. /****************************************************************************/
  1332. static int
  1333. ips_halt(struct notifier_block *nb, ulong event, void *buf) {
  1334.    ips_scb_t *scb;
  1335.    ips_ha_t  *ha;
  1336.    int        i;
  1338.    if ((event != SYS_RESTART) && (event != SYS_HALT) &&
  1339.        (event != SYS_POWER_OFF))
  1340.       return (NOTIFY_DONE);
  1342.    for (i = 0; i < ips_next_controller; i++) {
  1343.       ha = (ips_ha_t *) ips_ha[i];
  1345.       if (!ha)
  1346.          continue;
  1348.       if (!ha->active)
  1349.          continue;
  1351.       /* flush the cache on the controller */
  1352.       scb = &ha->scbs[ha->max_cmds-1];
  1354.       ips_init_scb(ha, scb);
  1356.       scb->timeout = ips_cmd_timeout;
  1357.       scb->cdb[0] = IPS_CMD_FLUSH;
  1359.       scb->cmd.flush_cache.op_code = IPS_CMD_FLUSH;
  1360.       scb->cmd.flush_cache.command_id = IPS_COMMAND_ID(ha, scb);
  1361.       scb->cmd.flush_cache.state = IPS_NORM_STATE;
  1362.       scb->cmd.flush_cache.reserved = 0;
  1363.       scb->cmd.flush_cache.reserved2 = 0;
  1364.       scb->cmd.flush_cache.reserved3 = 0;
  1365.       scb->cmd.flush_cache.reserved4 = 0;
  1367.       printk(KERN_NOTICE "(%s%d) Flushing Cache.n", ips_name, ha->host_num);
  1369.       /* send command */
  1370.       if (ips_send_wait(ha, scb, ips_cmd_timeout, IPS_INTR_ON) == IPS_FAILURE)
  1371.          printk(KERN_NOTICE "(%s%d) Incomplete Flush.n", ips_name, ha->host_num);
  1372.       else
  1373.          printk(KERN_NOTICE "(%s%d) Flushing Complete.n", ips_name, ha->host_num);
  1374.    }
  1376.    return (NOTIFY_OK);
  1377. }
  1379. /****************************************************************************/
  1380. /*                                                                          */
  1381. /* Routine Name: ips_eh_abort                                               */
  1382. /*                                                                          */
  1383. /* Routine Description:                                                     */
  1384. /*                                                                          */
  1385. /*   Abort a command (using the new error code stuff)                       */
  1386. /*                                                                          */
  1387. /****************************************************************************/
  1388. int
  1389. ips_eh_abort(Scsi_Cmnd *SC) {
  1390.    ips_ha_t         *ha;
  1391.    ips_copp_wait_item_t *item;
  1393.    METHOD_TRACE("ips_eh_abort", 1);
  1395.    if (!SC)
  1396.       return (FAILED);
  1398.    ha = (ips_ha_t *) SC->host->hostdata;
  1400.    if (!ha)
  1401.       return (FAILED);
  1403.    if (!ha->active)
  1404.       return (FAILED);
  1406.    if (SC->serial_number != SC->serial_number_at_timeout) {
  1407.       /* HMM, looks like a bogus command */
  1408.       DEBUG(1, "Abort called with bogus scsi command");
  1410.       return (FAILED);
  1411.    }
  1413.    if (test_and_set_bit(IPS_IN_ABORT, &ha->flags))
  1414.       return (FAILED);
  1416.    /* See if the command is on the copp queue */
  1417.    IPS_QUEUE_LOCK(&ha->copp_waitlist);
  1418.    item = ha->copp_waitlist.head;
  1419.    while ((item) && (item->scsi_cmd != SC))
  1420.       item = item->next;
  1421.    IPS_QUEUE_UNLOCK(&ha->copp_waitlist);
  1423.    if (item) {
  1424.       /* Found it */
  1425.       ips_removeq_copp(&ha->copp_waitlist, item);
  1426.       clear_bit(IPS_IN_ABORT, &ha->flags);
  1428.       return (SUCCESS);
  1429.    }
  1431.    /* See if the command is on the wait queue */
  1432.    if (ips_removeq_wait(&ha->scb_waitlist, SC)) {
  1433.       /* command not sent yet */
  1434.       clear_bit(IPS_IN_ABORT, &ha->flags);
  1436.       return (SUCCESS);
  1437.    } else {
  1438.       /* command must have already been sent */
  1439.       clear_bit(IPS_IN_ABORT, &ha->flags);
  1441.       return (FAILED);
  1442.    }
  1443. }
  1445. /****************************************************************************/
  1446. /*                                                                          */
  1447. /* Routine Name: ips_eh_reset                                               */
  1448. /*                                                                          */
  1449. /* Routine Description:                                                     */
  1450. /*                                                                          */
  1451. /*   Reset the controller (with new eh error code)                          */
  1452. /*                                                                          */
  1453. /* NOTE: this routine is called under the io_request_lock spinlock          */
  1454. /*                                                                          */
  1455. /****************************************************************************/
  1456. int
  1457. ips_eh_reset(Scsi_Cmnd *SC) {
  1458.    int                   ret;
  1459.    int                   i;
  1460.    ips_ha_t             *ha;
  1461.    ips_scb_t            *scb;
  1462.    ips_copp_wait_item_t *item;
  1463.    unsigned long         cpu_flags;
  1465.    METHOD_TRACE("ips_eh_reset", 1);
  1467. #ifdef NO_IPS_RESET
  1468.    return (FAILED);
  1469. #else
  1471.    if (!SC) {
  1472.       DEBUG(1, "Reset called with NULL scsi command");
  1474.       return (FAILED);
  1475.    }
  1477.    ha = (ips_ha_t *) SC->host->hostdata;
  1479.    if (!ha) {
  1480.       DEBUG(1, "Reset called with NULL ha struct");
  1482.       return (FAILED);
  1483.    }
  1485.    if (!ha->active)
  1486.       return (FAILED);
  1488.    if (test_and_set_bit(IPS_IN_RESET, &ha->flags))
  1489.       return (FAILED);
  1491.    /* See if the command is on the copp queue */
  1492.    IPS_QUEUE_LOCK(&ha->copp_waitlist);
  1493.    item = ha->copp_waitlist.head;
  1494.    while ((item) && (item->scsi_cmd != SC))
  1495.       item = item->next;
  1496.    IPS_QUEUE_UNLOCK(&ha->copp_waitlist);
  1498.    if (item) {
  1499.       /* Found it */
  1500.       ips_removeq_copp(&ha->copp_waitlist, item);
  1501.       clear_bit(IPS_IN_RESET, &ha->flags);
  1503.       return (SUCCESS);
  1504.    }
  1506.    /* See if the command is on the wait queue */
  1507.    if (ips_removeq_wait(&ha->scb_waitlist, SC)) {
  1508.       /* command not sent yet */
  1509.       clear_bit(IPS_IN_RESET, &ha->flags);
  1511.       return (SUCCESS);
  1512.    }
  1514.    /*
  1515.     * command must have already been sent
  1516.     * reset the controller
  1517.     */
  1518.    printk(KERN_NOTICE "(%s%d) Resetting controller.n",
  1519.           ips_name, ha->host_num);
  1520.    ret = (*ha->func.reset)(ha);
  1522.    if (!ret) {
  1523.       Scsi_Cmnd *scsi_cmd;
  1525.       printk(KERN_NOTICE
  1526.              "(%s%d) Controller reset failed - controller now offline.n",
  1527.              ips_name, ha->host_num);
  1529.       /* Now fail all of the active commands */
  1530.       DEBUG_VAR(1, "(%s%d) Failing active commands",
  1531.                 ips_name, ha->host_num);
  1533.       while ((scb = ips_removeq_scb_head(&ha->scb_activelist))) {
  1534.          scb->scsi_cmd->result = DID_ERROR << 16;
  1535.          scb->scsi_cmd->scsi_done(scb->scsi_cmd);
  1536.          ips_freescb(ha, scb);
  1537.       }
  1539.       /* Now fail all of the pending commands */
  1540.       DEBUG_VAR(1, "(%s%d) Failing pending commands",
  1541.                 ips_name, ha->host_num);
  1543.       while ((scsi_cmd = ips_removeq_wait_head(&ha->scb_waitlist))) {
  1544.          scsi_cmd->result = DID_ERROR;
  1545.          scsi_cmd->scsi_done(scsi_cmd);
  1546.       }
  1548.       ha->active = FALSE;
  1549.       clear_bit(IPS_IN_RESET, &ha->flags);
  1551.       return (FAILED);
  1552.    }
  1554.    if (!ips_clear_adapter(ha, IPS_INTR_IORL)) {
  1555.       Scsi_Cmnd *scsi_cmd;
  1557.       printk(KERN_NOTICE
  1558.              "(%s%d) Controller reset failed - controller now offline.n",
  1559.              ips_name, ha->host_num);
  1561.       /* Now fail all of the active commands */
  1562.       DEBUG_VAR(1, "(%s%d) Failing active commands",
  1563.                 ips_name, ha->host_num);
  1565.       while ((scb = ips_removeq_scb_head(&ha->scb_activelist))) {
  1566.          scb->scsi_cmd->result = DID_ERROR << 16;
  1567.          scb->scsi_cmd->scsi_done(scb->scsi_cmd);
  1568.          ips_freescb(ha, scb);
  1569.       }
  1571.       /* Now fail all of the pending commands */
  1572.       DEBUG_VAR(1, "(%s%d) Failing pending commands",
  1573.                 ips_name, ha->host_num);
  1575.       while ((scsi_cmd = ips_removeq_wait_head(&ha->scb_waitlist))) {
  1576.          scsi_cmd->result = DID_ERROR << 16;
  1577.          scsi_cmd->scsi_done(scsi_cmd);
  1578.       }
  1580.       ha->active = FALSE;
  1581.       clear_bit(IPS_IN_RESET, &ha->flags);
  1583.       return (FAILED);
  1584.    }
  1586.    /* FFDC */
  1587.    if (le32_to_cpu(ha->subsys->param[3]) & 0x300000) {
  1588.       struct timeval tv;
  1590.       do_gettimeofday(&tv);
  1591.       IPS_HA_LOCK(cpu_flags);
  1592.       ha->last_ffdc = tv.tv_sec;
  1593.       ha->reset_count++;
  1594.       IPS_HA_UNLOCK(cpu_flags);
  1595.       ips_ffdc_reset(ha, IPS_INTR_IORL);
  1596.    }
  1598.    /* Now fail all of the active commands */
  1599.    DEBUG_VAR(1, "(%s%d) Failing active commands",
  1600.              ips_name, ha->host_num);
  1602.    while ((scb = ips_removeq_scb_head(&ha->scb_activelist))) {
  1603.       scb->scsi_cmd->result = (DID_RESET << 16) | (SUGGEST_RETRY << 24);
  1604.       scb->scsi_cmd->scsi_done(scb->scsi_cmd);
  1605.       ips_freescb(ha, scb);
  1606.    }
  1608.    /* Reset DCDB active command bits */
  1609.    for (i = 1; i < ha->nbus; i++)
  1610.       ha->dcdb_active[i-1] = 0;
  1612.    /* Reset the number of active IOCTLs */
  1613.    IPS_HA_LOCK(cpu_flags);
  1614.    ha->num_ioctl = 0;
  1615.    IPS_HA_UNLOCK(cpu_flags);
  1617.    clear_bit(IPS_IN_RESET, &ha->flags);
  1619.    if (!test_bit(IPS_IN_INTR, &ha->flags)) {
  1620.       /*
  1621.        * Only execute the next command when
  1622.        * we are not being called from the
  1623.        * interrupt handler.  The interrupt
  1624.        * handler wants to do this and since
  1625.        * interrupts are turned off here....
  1626.        */
  1627.       ips_next(ha, IPS_INTR_IORL);
  1628.    }
  1630.    return (SUCCESS);
  1632. #endif /* NO_IPS_RESET */
  1634. }
  1636. /****************************************************************************/
  1637. /*                                                                          */
  1638. /* Routine Name: ips_queue                                                  */
  1639. /*                                                                          */
  1640. /* Routine Description:                                                     */
  1641. /*                                                                          */
  1642. /*   Send a command to the controller                                       */
  1643. /*                                                                          */
  1644. /* NOTE:                                                                    */
  1645. /*    Linux obtains io_request_lock before calling this function            */
  1646. /*                                                                          */
  1647. /****************************************************************************/
  1648. int
  1649. ips_queue(Scsi_Cmnd *SC, void (*done) (Scsi_Cmnd *)) {
  1650.    ips_ha_t         *ha;
  1651.    unsigned long     cpu_flags;
  1653.    METHOD_TRACE("ips_queue", 1);
  1655.    ha = (ips_ha_t *) SC->host->hostdata;
  1657.    if (!ha)
  1658.       return (1);
  1660.    if (!ha->active)
  1661.       return (DID_ERROR);
  1663. #ifndef NO_IPS_CMDLINE
  1664.    if (ips_is_passthru(SC)) {
  1665.       IPS_QUEUE_LOCK(&ha->copp_waitlist);
  1666.       if (ha->copp_waitlist.count == IPS_MAX_IOCTL_QUEUE) {
  1667.          IPS_QUEUE_UNLOCK(&ha->copp_waitlist);
  1668.          SC->result = DID_BUS_BUSY << 16;
  1669.          done(SC);
  1671.          return (0);
  1672.       } else {
  1673.          IPS_QUEUE_UNLOCK(&ha->copp_waitlist);
  1674.       }
  1675.    } else {
  1676. #endif
  1677.       IPS_QUEUE_LOCK(&ha->scb_waitlist);
  1678.       if (ha->scb_waitlist.count == IPS_MAX_QUEUE) {
  1679.          IPS_QUEUE_UNLOCK(&ha->scb_waitlist);
  1680.          SC->result = DID_BUS_BUSY << 16;
  1681.          done(SC);
  1683.          return (0);
  1684.       } else {
  1685.          IPS_QUEUE_UNLOCK(&ha->scb_waitlist);
  1686.       }
  1688. #ifndef NO_IPS_CMDLINE
  1689.    }
  1690. #endif
  1692.    SC->scsi_done = done;
  1694.    DEBUG_VAR(2, "(%s%d): ips_queue: cmd 0x%X (%d %d %d)",
  1695.              ips_name,
  1696.              ha->host_num,
  1697.              SC->cmnd[0],
  1698.              SC->channel,
  1699.              SC->target,
  1700.              SC->lun);
  1702.    /* Check for command to initiator IDs */
  1703.    if ((SC->channel > 0) && (SC->target == ha->ha_id[SC->channel])) {
  1704.       SC->result = DID_NO_CONNECT << 16;
  1705.       done(SC);
  1707.       return (0);
  1708.    }
  1710. #ifndef NO_IPS_CMDLINE
  1711.    if (ips_is_passthru(SC)) {
  1713.       ips_copp_wait_item_t *scratch;
  1715.       /* The IPS_IOCTL_NEW_COMMAND is only used to flash an adapter.  This should */
  1716.       /* never happen when the adapter is active.  Just in case, check here, and  */
  1717.       /* reject the command if anything else is going on.                         */
  1718.       if (SC->cmnd[0] == IPS_IOCTL_NEW_COMMAND) {
  1719.          if (ha->scb_activelist.count != 0) {
  1720.             /* printk( KERN_WARNING "New IOCTL Cmd Return BUSY: %d Cmds Activen", */
  1721.             /*                       ha->scb_activelist.count );                   */
  1722.             SC->result = DID_BUS_BUSY << 16;
  1723.             done(SC);
  1725.             return (0);
  1726.          }
  1727.       }
  1729.       /* allocate space for the scribble */
  1730.       scratch = kmalloc(sizeof(ips_copp_wait_item_t), GFP_ATOMIC);
  1732.       if (!scratch) {
  1733.          SC->result = DID_ERROR << 16;
  1734.          done(SC);
  1736.          return (0);
  1737.       }
  1739.       scratch->scsi_cmd = SC;
  1740.       sema_init(&ha->ioctl_sem, 0);
  1741.       scratch->sem = &ha->ioctl_sem;
  1742.       scratch->next = NULL;
  1744.       ips_putq_copp_tail(&ha->copp_waitlist, scratch);
  1745.    }
  1746.    else
  1747. #endif
  1748.       ips_putq_wait_tail(&ha->scb_waitlist, SC);
  1750.    IPS_HA_LOCK(cpu_flags);
  1751.    if ((!test_bit(IPS_IN_INTR, &ha->flags)) &&
  1752.        (!test_bit(IPS_IN_ABORT, &ha->flags)) &&
  1753.        (!test_bit(IPS_IN_RESET, &ha->flags))) {
  1754.       IPS_HA_UNLOCK(cpu_flags);
  1755.       ips_next(ha, IPS_INTR_IORL);
  1756.    } else {
  1757.       IPS_HA_UNLOCK(cpu_flags);
  1758.    }
  1760.    /*
  1761.     * If this request was a new style IOCTL wait
  1762.     * for it to finish.
  1763.     *
  1764.     * NOTE: we relinquished the lock above so this should
  1765.     * not cause contention problems
  1766.     */
  1767.    if (ips_is_passthru(SC) && SC->cmnd[0] == IPS_IOCTL_NEW_COMMAND) {
  1768.       char      *user_area;
  1769.       char      *kern_area;
  1770.       u_int32_t  datasize;
  1772.       /* free io_request_lock */
  1773.       spin_unlock_irq(&io_request_lock);
  1775.       /* wait for the command to finish */
  1776.       down(&ha->ioctl_sem);
  1778.       /* reobtain the lock */
  1779.       spin_lock_irq(&io_request_lock);
  1781.       /* command finished -- copy back */
  1782.       user_area = *((char **) &SC->cmnd[4]);
  1783.       kern_area = ha->ioctl_data;
  1784.       datasize = *((u_int32_t *) &SC->cmnd[8]);
  1786.       if (datasize) {
  1787.          if (copy_to_user(user_area, kern_area, datasize) > 0) {
  1788.             DEBUG_VAR(1, "(%s%d) passthru failed - unable to copy out user data",
  1789.                       ips_name, ha->host_num);
  1790.             SC->result = DID_ERROR << 16;
  1791.          }
  1792.       }
  1794.       SC->scsi_done(SC);
  1795.    }
  1797.    /* If We were using the CD Boot Flash Buffer, Restore the Old Values */
  1798.    if ( ips_FlashData == ha->ioctl_data ) {                               
  1799.       ha->ioctl_data = ha->save_ioctl_data;                           
  1800.       ha->ioctl_order = ha->save_ioctl_order;                          
  1801.       ha->ioctl_datasize = ha->save_ioctl_datasize;                       
  1802.       ips_FlashDataInUse = 0;                                             
  1803.    }
  1805.    return (0);
  1806. }
  1808. /****************************************************************************/
  1809. /*                                                                          */
  1810. /* Routine Name: ips_biosparam                                              */
  1811. /*                                                                          */
  1812. /* Routine Description:                                                     */
  1813. /*                                                                          */
  1814. /*   Set bios geometry for the controller                                   */
  1815. /*                                                                          */
  1816. /****************************************************************************/
  1817. int
  1818. ips_biosparam(Disk *disk, kdev_t dev, int geom[]) {
  1819.    ips_ha_t         *ha;
  1820.    int               heads;
  1821.    int               sectors;
  1822.    int               cylinders;
  1824.    METHOD_TRACE("ips_biosparam", 1);
  1826.    ha = (ips_ha_t *) disk->device->host->hostdata;
  1828.    if (!ha)
  1829.       /* ?!?! host adater info invalid */
  1830.       return (0);
  1832.    if (!ha->active)
  1833.       return (0);
  1835.    if (!ips_read_adapter_status(ha, IPS_INTR_ON))
  1836.       /* ?!?! Enquiry command failed */
  1837.       return (0);
  1839.    if ((disk->capacity > 0x400000) &&
  1840.        ((ha->enq->ucMiscFlag & 0x8) == 0)) {
  1841.       heads = IPS_NORM_HEADS;
  1842.       sectors = IPS_NORM_SECTORS;
  1843.    } else {
  1844.       heads = IPS_COMP_HEADS;
  1845.       sectors = IPS_COMP_SECTORS;
  1846.    }
  1848.    cylinders = disk->capacity / (heads * sectors);
  1850.    DEBUG_VAR(2, "Geometry: heads: %d, sectors: %d, cylinders: %d",
  1851.              heads, sectors, cylinders);
  1853.    geom[0] = heads;
  1854.    geom[1] = sectors;
  1855.    geom[2] = cylinders;
  1857.    return (0);
  1858. }
  1860. /****************************************************************************/
  1861. /*                                                                          */
  1862. /* Routine Name: ips_select_queue_depth                                     */
  1863. /*                                                                          */
  1864. /* Routine Description:                                                     */
  1865. /*                                                                          */
  1866. /*   Select queue depths for the devices on the contoller                   */
  1867. /*                                                                          */
  1868. /****************************************************************************/
  1869. static void
  1870. ips_select_queue_depth(struct Scsi_Host *host, Scsi_Device *scsi_devs) {
  1871.    Scsi_Device *device;
  1872.    ips_ha_t    *ha;
  1873.    int          count = 0;
  1874.    int          min;
  1876.    ha = IPS_HA(host);
  1877.    min = ha->max_cmds / 4;
  1879.    for (device = scsi_devs; device; device = device->next) {
  1880.      if (device->host == host) {
  1881.         if ((device->channel == 0) && (device->type == 0))
  1882.            count++;
  1883.      }
  1884.    }
  1886.    for (device = scsi_devs; device; device = device->next) {
  1887.       if (device->host == host) {
  1888.          if ((device->channel == 0) && (device->type == 0)) {
  1889.             device->queue_depth = ( ha->max_cmds - 1 ) / count;
  1890.             if (device->queue_depth < min) 
  1891.                device->queue_depth = min;
  1892.          }
  1893.          else {
  1894.             device->queue_depth = 2;
  1895.          }
  1897.          if (device->queue_depth < 2)
  1898.             device->queue_depth = 2;
  1899.       }
  1900.    }
  1901. }
  1903. /****************************************************************************/
  1904. /*                                                                          */
  1905. /* Routine Name: do_ipsintr                                                 */
  1906. /*                                                                          */
  1907. /* Routine Description:                                                     */
  1908. /*                                                                          */
  1909. /*   Wrapper for the interrupt handler                                      */
  1910. /*                                                                          */
  1911. /****************************************************************************/
  1912. void
  1913. do_ipsintr(int irq, void *dev_id, struct pt_regs *regs) {
  1914.    ips_ha_t         *ha;
  1915.    unsigned long     cpu_flags;
  1917.    METHOD_TRACE("do_ipsintr", 2);
  1919.    ha = (ips_ha_t *) dev_id;
  1921.    spin_lock_irqsave(&io_request_lock, cpu_flags);
  1923.    if (test_and_set_bit(IPS_IN_INTR, &ha->flags)) {
  1924.       spin_unlock_irqrestore(&io_request_lock, cpu_flags);
  1926.       return ;
  1927.    }
  1929.    if (!ha) {
  1930.       clear_bit(IPS_IN_INTR, &ha->flags);
  1931.       spin_unlock_irqrestore(&io_request_lock, cpu_flags);
  1933.       return;
  1934.    }
  1936.    if (!ha->active) {
  1937.       clear_bit(IPS_IN_INTR, &ha->flags);
  1938.       spin_unlock_irqrestore(&io_request_lock, cpu_flags);
  1940.       return;
  1941.    }
  1943.    (*ha->func.intr)(ha);
  1945.    clear_bit(IPS_IN_INTR, &ha->flags);
  1947.    spin_unlock_irqrestore(&io_request_lock, cpu_flags);
  1949.    /* start the next command */
  1950.    ips_next(ha, IPS_INTR_ON);
  1951. }
  1953. /****************************************************************************/
  1954. /*                                                                          */
  1955. /* Routine Name: ips_intr_copperhead                                        */
  1956. /*                                                                          */
  1957. /* Routine Description:                                                     */
  1958. /*                                                                          */
  1959. /*   Polling interrupt handler                                              */
  1960. /*                                                                          */
  1961. /*   ASSUMES interrupts are disabled                                        */
  1962. /*                                                                          */
  1963. /****************************************************************************/
  1964. void
  1965. ips_intr_copperhead(ips_ha_t *ha) {
  1966.    ips_stat_t       *sp;
  1967.    ips_scb_t        *scb;
  1968.    IPS_STATUS        cstatus;
  1969.    int               intrstatus;
  1970.    unsigned long     cpu_flags;
  1972.    METHOD_TRACE("ips_intr", 2);
  1974.    if (!ha)
  1975.       return;
  1977.    if (!ha->active)
  1978.       return;
  1980.    IPS_HA_LOCK(cpu_flags);
  1982.    intrstatus = (*ha->func.isintr)(ha);
  1984.    if (!intrstatus) {
  1985.       /*
  1986.        * Unexpected/Shared interrupt
  1987.        */
  1988.       IPS_HA_UNLOCK(cpu_flags);
  1990.       return;
  1991.    }
  1993.    while (TRUE) {
  1994.       sp = &ha->sp;
  1996.       intrstatus = (*ha->func.isintr)(ha);
  1998.       if (!intrstatus)
  1999.          break;
  2000.       else
  2001.          cstatus.value = (*ha->func.statupd)(ha);
  2003.       if (cstatus.fields.command_id > (IPS_MAX_CMDS - 1)) {
  2004.          /* Spurious Interupt ? */
  2005.          continue;
  2006.       }
  2008.       ips_chkstatus(ha, &cstatus);
  2009.       scb = (ips_scb_t *) sp->scb_addr;
  2011.       /*
  2012.        * use the callback function to finish things up
  2013.        * NOTE: interrupts are OFF for this
  2014.        */
  2015.       IPS_HA_UNLOCK(cpu_flags);
  2016.       (*scb->callback) (ha, scb);
  2017.       IPS_HA_LOCK(cpu_flags);
  2018.    } /* end while */
  2020.    IPS_HA_UNLOCK(cpu_flags);
  2021. }
  2023. /****************************************************************************/
  2024. /*                                                                          */
  2025. /* Routine Name: ips_intr_morpheus                                          */
  2026. /*                                                                          */
  2027. /* Routine Description:                                                     */
  2028. /*                                                                          */
  2029. /*   Polling interrupt handler                                              */
  2030. /*                                                                          */
  2031. /*   ASSUMES interrupts are disabled                                        */
  2032. /*                                                                          */
  2033. /****************************************************************************/
  2034. void
  2035. ips_intr_morpheus(ips_ha_t *ha) {
  2036.    ips_stat_t       *sp;
  2037.    ips_scb_t        *scb;
  2038.    IPS_STATUS        cstatus;
  2039.    int               intrstatus;
  2040.    unsigned long     cpu_flags;
  2042.    METHOD_TRACE("ips_intr_morpheus", 2);
  2044.    if (!ha)
  2045.       return;
  2047.    if (!ha->active)
  2048.       return;
  2050.    IPS_HA_LOCK(cpu_flags);
  2052.    intrstatus = (*ha->func.isintr)(ha);
  2054.    if (!intrstatus) {
  2055.       /*
  2056.        * Unexpected/Shared interrupt
  2057.        */
  2058.       IPS_HA_UNLOCK(cpu_flags);
  2060.       return;
  2061.    }
  2063.    while (TRUE) {
  2064.       sp = &ha->sp;
  2066.       intrstatus = (*ha->func.isintr)(ha);
  2068.       if (!intrstatus)
  2069.          break;
  2070.       else
  2071.          cstatus.value = (*ha->func.statupd)(ha);
  2073.       if (cstatus.value == 0xffffffff)
  2074.          /* No more to process */
  2075.          break;
  2077.       if (cstatus.fields.command_id > (IPS_MAX_CMDS - 1)) {
  2078.          printk(KERN_WARNING "(%s%d) Spurious interrupt; no ccb.n",
  2079.                 ips_name, ha->host_num);
  2081.          continue;
  2082.       }
  2084.       ips_chkstatus(ha, &cstatus);
  2085.       scb = (ips_scb_t *) sp->scb_addr;
  2087.       /*
  2088.        * use the callback function to finish things up
  2089.        * NOTE: interrupts are OFF for this
  2090.        */
  2091.       IPS_HA_UNLOCK(cpu_flags);
  2092.       (*scb->callback) (ha, scb);
  2093.       IPS_HA_LOCK(cpu_flags);
  2094.    } /* end while */
  2096.    IPS_HA_UNLOCK(cpu_flags);
  2097. }
  2099. /****************************************************************************/
  2100. /*                                                                          */
  2101. /* Routine Name: ips_info                                                   */
  2102. /*                                                                          */
  2103. /* Routine Description:                                                     */
  2104. /*                                                                          */
  2105. /*   Return info about the driver                                           */
  2106. /*                                                                          */
  2107. /****************************************************************************/
  2108. const char *
  2109. ips_info(struct Scsi_Host *SH) {
  2110.    static char  buffer[256];
  2111.    char        *bp;
  2112.    ips_ha_t    *ha;
  2114.    METHOD_TRACE("ips_info", 1);
  2116.    ha = IPS_HA(SH);
  2118.    if (!ha)
  2119.       return (NULL);
  2121.    bp = &buffer[0];
  2122.    memset(bp, 0, sizeof(buffer));
  2124.    sprintf(bp, "%s%s%s", "IBM PCI ServeRAID ", IPS_VERSION_HIGH, IPS_VERSION_LOW );
  2126.    if (ha->ad_type > 0 &&
  2127.        ha->ad_type <= MAX_ADAPTER_NAME) {
  2128.       strcat(bp, " <");
  2129.       strcat(bp, ips_adapter_name[ha->ad_type-1]);
  2130.       strcat(bp, ">");
  2131.    }
  2133.    return (bp);
  2134. }
  2136. /****************************************************************************/
  2137. /*                                                                          */
  2138. /* Routine Name: ips_proc_info                                              */
  2139. /*                                                                          */
  2140. /* Routine Description:                                                     */
  2141. /*                                                                          */
  2142. /*   The passthru interface for the driver                                  */
  2143. /*                                                                          */
  2144. /****************************************************************************/
  2145. int
  2146. ips_proc_info(char *buffer, char **start, off_t offset,
  2147.               int length, int hostno, int func) {
  2148.    int           i;
  2149.    int           ret;
  2150.    ips_ha_t     *ha = NULL;
  2152.    METHOD_TRACE("ips_proc_info", 1);
  2154.    /* Find our host structure */
  2155.    for (i = 0; i < ips_next_controller; i++) {
  2156.       if (ips_sh[i]) {
  2157.          if (ips_sh[i]->host_no == hostno) {
  2158.             ha = (ips_ha_t *) ips_sh[i]->hostdata;
  2159.             break;
  2160.          }
  2161.       }
  2162.    }
  2164.    if (!ha)
  2165.       return (-EINVAL);
  2167.    if (func) {
  2168.       /* write */
  2169.       return (0);
  2170.    } else {
  2171.       /* read */
  2172.       if (start)
  2173.          *start = buffer;
  2175.       ret = ips_host_info(ha, buffer, offset, length);
  2177.       return (ret);
  2178.    }
  2179. }
  2181. /*--------------------------------------------------------------------------*/
  2182. /* Helper Functions                                                         */
  2183. /*--------------------------------------------------------------------------*/
  2185. #ifndef NO_IPS_CMDLINE
  2187. /****************************************************************************/
  2188. /*                                                                          */
  2189. /* Routine Name: ips_is_passthru                                            */
  2190. /*                                                                          */
  2191. /* Routine Description:                                                     */
  2192. /*                                                                          */
  2193. /*   Determine if the specified SCSI command is really a passthru command   */
  2194. /*                                                                          */
  2195. /****************************************************************************/
  2196. static int
  2197. ips_is_passthru(Scsi_Cmnd *SC) {
  2198.    METHOD_TRACE("ips_is_passthru", 1);
  2200.    if (!SC)
  2201.       return (0);
  2203.    if (((SC->cmnd[0] == IPS_IOCTL_COMMAND) || (SC->cmnd[0] == IPS_IOCTL_NEW_COMMAND)) &&
  2204.        (SC->channel == 0) &&
  2205.        (SC->target == IPS_ADAPTER_ID) &&
  2206.        (SC->lun == 0) &&
  2207.        (SC->request_bufflen) &&
  2208.        (!SC->use_sg) &&
  2209.        (((char *) SC->request_buffer)[0] == 'C') &&
  2210.        (((char *) SC->request_buffer)[1] == 'O') &&
  2211.        (((char *) SC->request_buffer)[2] == 'P') &&
  2212.        (((char *) SC->request_buffer)[3] == 'P')) {
  2213.       return (1);
  2214.    } else {
  2215.       return (0);
  2216.    }
  2217. }
  2219. /****************************************************************************/
  2220. /*                                                                          */
  2221. /* Routine Name: ips_make_passthru                                          */
  2222. /*                                                                          */
  2223. /* Routine Description:                                                     */
  2224. /*                                                                          */
  2225. /*   Make a passthru command out of the info in the Scsi block              */
  2226. /*                                                                          */
  2227. /****************************************************************************/
  2228. static int
  2229. ips_make_passthru(ips_ha_t *ha, Scsi_Cmnd *SC, ips_scb_t *scb, int intr) {
  2230.    IPS_NVRAM_P5    nvram;
  2231.    ips_passthru_t *pt;
  2233.    METHOD_TRACE("ips_make_passthru", 1);
  2235.    if (!SC->request_bufflen || !SC->request_buffer) {
  2236.       /* no data */
  2237.       DEBUG_VAR(1, "(%s%d) No passthru structure",
  2238.                 ips_name, ha->host_num);
  2240.       return (IPS_FAILURE);
  2241.    }
  2243.    if (SC->request_bufflen < sizeof(ips_passthru_t)) {
  2244.       /* wrong size */
  2245.       DEBUG_VAR(1, "(%s%d) Passthru structure wrong size",
  2246.              ips_name, ha->host_num);
  2248.       return (IPS_FAILURE);
  2249.    }
  2251.    if ((((char *) SC->request_buffer)[0] != 'C') ||
  2252.        (((char *) SC->request_buffer)[1] != 'O') ||
  2253.        (((char *) SC->request_buffer)[2] != 'P') ||
  2254.        (((char *) SC->request_buffer)[3] != 'P')) {
  2255.       /* signature doesn't match */
  2256.       DEBUG_VAR(1, "(%s%d) Wrong signature on passthru structure.",
  2257.                 ips_name, ha->host_num);
  2259.       return (IPS_FAILURE);
  2260.    }
  2262.    pt = (ips_passthru_t *) SC->request_buffer;
  2264.    /*
  2265.     * Some notes about the passthru interface used
  2266.     *
  2267.     * IF the scsi op_code == 0x0d then we assume
  2268.     * that the data came along with/goes with the
  2269.     * packet we received from the sg driver. In this
  2270.     * case the CmdBSize field of the pt structure is
  2271.     * used for the size of the buffer.
  2272.     *
  2273.     * IF the scsi op_code == 0x81 then we assume that
  2274.     * we will need our own buffer and we will copy the
  2275.     * data to/from the user buffer passed in the scsi
  2276.     * command.  The data address resides at offset 4
  2277.     * in the scsi command.  The length of the data resides
  2278.     * at offset 8 in the scsi command.
  2279.     */
  2281.    switch (pt->CoppCmd) {
  2282.    case IPS_NUMCTRLS:
  2283.       memcpy(SC->request_buffer + sizeof(ips_passthru_t),
  2284.              &ips_num_controllers, sizeof(int));
  2285.       SC->result = DID_OK << 16;
  2287.       return (IPS_SUCCESS_IMM);
  2289.    case IPS_CTRLINFO:
  2290.       memcpy(SC->request_buffer + sizeof(ips_passthru_t),
  2291.              ha, sizeof(ips_ha_t));
  2292.       SC->result = DID_OK << 16;
  2294.       return (IPS_SUCCESS_IMM);
  2296.    case IPS_COPPUSRCMD:
  2297.    case IPS_COPPIOCCMD:
  2298.       if (SC->cmnd[0] == IPS_IOCTL_COMMAND) {
  2299.          if (SC->request_bufflen < (sizeof(ips_passthru_t) + pt->CmdBSize)) {
  2300.             /* wrong size */
  2301.             DEBUG_VAR(1, "(%s%d) Passthru structure wrong size",
  2302.                       ips_name, ha->host_num);
  2304.             return (IPS_FAILURE);
  2305.          }
  2307.          if (ips_usrcmd(ha, pt, scb))
  2308.             return (IPS_SUCCESS);
  2309.          else
  2310.             return (IPS_FAILURE);
  2311.       } else if (SC->cmnd[0] == IPS_IOCTL_NEW_COMMAND) {
  2312.          char      *user_area;
  2313.          char      *kern_area;
  2314.          u_int32_t  datasize;
  2316.          if (SC->request_bufflen < (sizeof(ips_passthru_t))) {
  2317.             /* wrong size */
  2318.             DEBUG_VAR(1, "(%s%d) Passthru structure wrong size",
  2319.                       ips_name, ha->host_num);
  2321.             SC->result = DID_ERROR << 16;
  2323.             return (IPS_FAILURE);
  2324.          }
  2326.          /* IF it's OK to Use the "CD BOOT" Flash Buffer, then you can     */
  2327.          /* avoid allocating a huge buffer per adapter ( which can fail ). */
  2328.          if ( (ips_FlashData) &&                                            
  2329.               (pt->CmdBSize == IPS_IMAGE_SIZE) &&                                   
  2330.               (ips_FlashDataInUse == 0) ) {                                 
  2331.             ips_FlashDataInUse = 1;                                         
  2332.             ha->save_ioctl_data  = ha->ioctl_data;                          
  2333.             ha->save_ioctl_order = ha->ioctl_order;                         
  2334.             ha->save_ioctl_datasize = ha->ioctl_datasize;                   
  2335.             ha->ioctl_data  = ips_FlashData;                                
  2336.             ha->ioctl_order = 7;                                            
  2337.             ha->ioctl_datasize = IPS_IMAGE_SIZE;                                    
  2338.          }  
  2340.          if ((pt->CoppCP.cmd.nvram.op_code == IPS_CMD_RW_NVRAM_PAGE) &&
  2341.              (pt->CoppCP.cmd.nvram.page == 5) &&
  2342.              (pt->CoppCP.cmd.nvram.write == 0)) {
  2344.             datasize = *((u_int32_t *) &scb->scsi_cmd->cmnd[8]);
  2346.             if (datasize < sizeof(IPS_NVRAM_P5)) {
  2347.                pt->BasicStatus = 0x0B;
  2348.                pt->ExtendedStatus = 0x00;
  2349.                SC->result = DID_ERROR << 16;
  2351.             return (IPS_FAILURE);
  2352.       }
  2354.             ips_get_bios_version(ha, IPS_INTR_IORL);
  2355.             ips_create_nvrampage5(ha, &nvram);
  2357.             user_area = *((char **) &scb->scsi_cmd->cmnd[4]);
  2358.             kern_area = (char *) &nvram;
  2359.             datasize = *((u_int32_t *) &scb->scsi_cmd->cmnd[8]);
  2361.             if (datasize > sizeof(IPS_NVRAM_P5))
  2362.                datasize = sizeof(IPS_NVRAM_P5);
  2364.             /* Copy out the buffer */
  2365.             if (copy_to_user((void *) user_area, (void *) kern_area, datasize) > 0) {
  2366.                pt->BasicStatus = 0x0B;
  2367.                pt->ExtendedStatus = 0x00;
  2368.                SC->result = DID_ERROR << 16;
  2370.                return (EFAULT);
  2371.             }
  2373.             pt->BasicStatus = 0x00;
  2374.             pt->ExtendedStatus = 0x00;
  2375.             SC->result = DID_OK << 16;
  2377.             return (IPS_SUCCESS_IMM);
  2378.          }
  2380.          /*
  2381.           * IPSSEND flashing BIOS
  2382.           */
  2383.          if ((pt->CoppCP.cmd.flashfw.op_code == IPS_CMD_RW_BIOSFW) &&
  2384.              (pt->CoppCP.cmd.flashfw.type == 1) &&
  2385.              (pt->CoppCP.cmd.flashfw.direction == 2) &&
  2386.              (ha->device_id == IPS_DEVICEID_COPPERHEAD)) {
  2387.             struct tq_struct  task;
  2388.             IPS_FLASH_DATA    flash_data;
  2390.             /* We only support one packet */
  2391.             if (pt->CoppCP.cmd.flashfw.total_packets != 1) {
  2392.                pt->BasicStatus = 0x0B;
  2393.                pt->ExtendedStatus = 0x00;
  2394.                SC->result = DID_ERROR << 16;
  2396.                return (IPS_FAILURE);
  2397.             }
  2399.             /* copy in the size/buffer ptr from the scsi command */
  2400.             memcpy(&pt->CmdBuffer, &SC->cmnd[4], 4);
  2401.             memcpy(&pt->CmdBSize, &SC->cmnd[8], 4);
  2403.             if (pt->CmdBSize > le32_to_cpu(pt->CoppCP.cmd.flashfw.count)) {
  2404.                pt->CmdBSize = le32_to_cpu(pt->CoppCP.cmd.flashfw.count);
  2405.             } else {
  2406.                /* ERROR: Command/Buffer mismatch */
  2407.                pt->BasicStatus = 0x0B;
  2408.                pt->ExtendedStatus = 0x00;
  2409.                SC->result = DID_ERROR << 16;
  2411.                return (IPS_FAILURE);
  2412.             }
  2414.       if ((!ha->func.programbios) ||
  2415.           (!ha->func.erasebios) ||
  2416.                 (!ha->func.verifybios)) {
  2417.                pt->BasicStatus = 0x0B;
  2418.                pt->ExtendedStatus = 0x00;
  2419.                SC->result = DID_ERROR << 16;
  2421.                return (IPS_FAILURE);
  2422.             }
  2424.             /* must have a buffer */
  2425.             if ((!pt->CmdBSize) || (!pt->CmdBuffer)) {
  2426.                pt->BasicStatus = 0x0B;
  2427.                pt->ExtendedStatus = 0x00;
  2428.                SC->result = DID_ERROR << 16;
  2430.                return (IPS_FAILURE);
  2431.             }
  2433.             /* make sure buffer is big enough */
  2434.             if (pt->CmdBSize > ha->ioctl_datasize) {
  2435.                void *bigger_struct;
  2436.                u_int32_t count;
  2437.                u_int32_t order;
  2439.                /* try to allocate a bigger struct */
  2440.                for (count = PAGE_SIZE, order = 0;
  2441.                     count < pt->CmdBSize;
  2442.                     order++, count <<= 1);
  2444.                bigger_struct = (void *) __get_free_pages(GFP_ATOMIC, order);
  2445.                if (bigger_struct) {
  2446.                   /* free the old memory */
  2447.                   free_pages((unsigned long) ha->ioctl_data, ha->ioctl_order);
  2449.                   /* use the new memory */
  2450.                   ha->ioctl_data = (char *) bigger_struct;
  2451.                   ha->ioctl_order = order;
  2452.                   ha->ioctl_datasize = count;
  2453.                } else {
  2454.                   pt->BasicStatus = 0x0B;
  2455.                   pt->ExtendedStatus = 0x00;
  2456.                   SC->result = DID_ERROR << 16;
  2458.                   spin_unlock(&ha->ips_lock);
  2460.                   return (IPS_FAILURE);
  2461.                }
  2462.             }
  2464.             /* copy in the buffer */
  2465.             if (copy_from_user(ha->ioctl_data, pt->CmdBuffer, pt->CmdBSize) > 0) {
  2466.                DEBUG_VAR(1, "(%s%d) flash bios failed - unable to copy user buffer",
  2467.                          ips_name, ha->host_num);
  2468.                pt->BasicStatus = 0x0B;
  2469.                pt->ExtendedStatus = 0x00;
  2470.                SC->result = DID_ERROR << 16;
  2472.                return (IPS_FAILURE);
  2473.             }
  2475.             flash_data.userbuffer = pt->CmdBuffer;
  2476.             flash_data.usersize = pt->CmdBSize;
  2477.             flash_data.kernbuffer = ha->ioctl_data;
  2478.             flash_data.kernsize = ha->ioctl_datasize;
  2479.             flash_data.offset = 0;
  2480.             flash_data.SC = (void *) SC;
  2481.             flash_data.pt = (void *) pt;
  2482.             flash_data.ha = (void *) ha;
  2483.             sema_init( &ha->flash_ioctl_sem, 0 );
  2484.             flash_data.sem = &ha->flash_ioctl_sem;
  2486.             task.sync = 0;
  2487.             task.routine = ips_scheduled_flash_bios;
  2488.             task.data = (void *) &flash_data;
  2490.             /* Unlock the master lock */
  2491.             spin_unlock_irq(&io_request_lock);
  2493.             queue_task(&task, &tq_immediate);
  2494.             mark_bh(IMMEDIATE_BH);
  2495.             
  2496.             /* Wait for the flash to complete */
  2497.             down(&ha->flash_ioctl_sem);
  2499.             /* Obtain the master lock */
  2500.             spin_lock_irq(&io_request_lock);
  2502.             return (flash_data.retcode);
  2503.          }
  2505.          /*
  2506.           * IPSSEND flashing BIOS in sectioned mode
  2507.           */
  2508.          if ((pt->CoppCP.cmd.flashbios.op_code == IPS_CMD_RW_BIOSFW) &&
  2509.              (pt->CoppCP.cmd.flashbios.type == 1) &&
  2510.              (pt->CoppCP.cmd.flashbios.direction == 4) &&
  2511.              (ha->device_id == IPS_DEVICEID_COPPERHEAD)) {
  2512.             struct tq_struct  task;
  2513.             IPS_FLASH_DATA    flash_data;
  2515.       /* copy in the size/buffer ptr from the scsi command */
  2516.       memcpy(&pt->CmdBuffer, &SC->cmnd[4], 4);
  2517.       memcpy(&pt->CmdBSize, &SC->cmnd[8], 4);
  2519.             if (pt->CmdBSize > le32_to_cpu(pt->CoppCP.cmd.flashbios.count)) {
  2520.                pt->CmdBSize = le32_to_cpu(pt->CoppCP.cmd.flashbios.count);
  2521.             } else {
  2522.                /* ERROR: Command/Buffer mismatch */
  2523.                pt->BasicStatus = 0x0B;
  2524.                pt->ExtendedStatus = 0x00;
  2525.                SC->result = DID_ERROR << 16;
  2527.                return (IPS_FAILURE);
  2528.             }
  2530.             /* Update the Card BIOS */
  2531.             if ((!ha->func.programbios) ||