/drivers/scsi/ips.c

https://bitbucket.org/abioy/linux · C · 7245 lines · 4494 code · 1179 blank · 1572 comment · 970 complexity · 6d296e885505925d4a54f4a10c45cbc1 MD5 · raw file

Large files are truncated click here to view the full file

    

  1. /*****************************************************************************/
    2. 

  2. /* ips.c -- driver for the Adaptec / IBM ServeRAID controller                */
    3. 

  3. /*                                                                           */
    4. 

  4. /* Written By: Keith Mitchell, IBM Corporation                               */
    5. 

  5. /*             Jack Hammer, Adaptec, Inc.                                    */
    6. 

  6. /*             David Jeffery, Adaptec, Inc.                                  */
    7. 

  7. /*                                                                           */
    8. 

  8. /* Copyright (C) 2000 IBM Corporation                                        */
    9. 

  9. /* Copyright (C) 2002,2003 Adaptec, Inc.                                     */
    10. 

  10. /*                                                                           */
    11. 

  11. /* This program is free software; you can redistribute it and/or modify      */
    12. 

  12. /* it under the terms of the GNU General Public License as published by      */
    13. 

  13. /* the Free Software Foundation; either version 2 of the License, or         */
    14. 

  14. /* (at your option) any later version.                                       */
    15. 

  15. /*                                                                           */
    16. 

  16. /* This program is distributed in the hope that it will be useful,           */
    17. 

  17. /* but WITHOUT ANY WARRANTY; without even the implied warranty of            */
    18. 

  18. /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             */
    19. 

  19. /* GNU General Public License for more details.                              */
    20. 

  20. /*                                                                           */
    21. 

  21. /* NO WARRANTY                                                               */
    22. 

  22. /* THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR        */
    23. 

  23. /* CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT      */
    24. 

  24. /* LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,      */
    25. 

  25. /* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is    */
    26. 

  26. /* solely responsible for determining the appropriateness of using and       */
    27. 

  27. /* distributing the Program and assumes all risks associated with its        */
    28. 

  28. /* exercise of rights under this Agreement, including but not limited to     */
    29. 

  29. /* the risks and costs of program errors, damage to or loss of data,         */
    30. 

  30. /* programs or equipment, and unavailability or interruption of operations.  */
    31. 

  31. /*                                                                           */
    32. 

  32. /* DISCLAIMER OF LIABILITY                                                   */
    33. 

  33. /* NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY   */
    34. 

  34. /* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL        */
    35. 

  35. /* DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND   */
    36. 

  36. /* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR     */
    37. 

  37. /* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE    */
    38. 

  38. /* USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED  */
    39. 

  39. /* HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES             */
    40. 

  40. /*                                                                           */
    41. 

  41. /* You should have received a copy of the GNU General Public License         */
    42. 

  42. /* along with this program; if not, write to the Free Software               */
    43. 

  43. /* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
    44. 

  44. /*                                                                           */
    45. 

  45. /* Bugs/Comments/Suggestions about this driver should be mailed to:          */
    46. 

  46. /*      ipslinux@adaptec.com        	                                     */
    47. 

  47. /*                                                                           */
    48. 

  48. /* For system support issues, contact your local IBM Customer support.       */
    49. 

  49. /* Directions to find IBM Customer Support for each country can be found at: */
    50. 

  50. /*      http://www.ibm.com/planetwide/                                       */
    51. 

  51. /*                                                                           */
    52. 

  52. /*****************************************************************************/
    53. 

  53. 

  54. /*****************************************************************************/
    55. 

  55. /* Change Log                                                                */
    56. 

  56. /*                                                                           */
    57. 

  57. /* 0.99.02  - Breakup commands that are bigger than 8 * the stripe size      */
    58. 

  58. /* 0.99.03  - Make interrupt routine handle all completed request on the     */
    59. 

  59. /*            adapter not just the first one                                 */
    60. 

  60. /*          - Make sure passthru commands get woken up if we run out of      */
    61. 

  61. /*            SCBs                                                           */
    62. 

  62. /*          - Send all of the commands on the queue at once rather than      */
    63. 

  63. /*            one at a time since the card will support it.                  */
    64. 

  64. /* 0.99.04  - Fix race condition in the passthru mechanism -- this required  */
    65. 

  65. /*            the interface to the utilities to change                       */
    66. 

  66. /*          - Fix error recovery code                                        */
    67. 

  67. /* 0.99.05  - Fix an oops when we get certain passthru commands              */
    68. 

  68. /* 1.00.00  - Initial Public Release                                         */
    69. 

  69. /*            Functionally equivalent to 0.99.05                             */
    70. 

  70. /* 3.60.00  - Bump max commands to 128 for use with firmware 3.60            */
    71. 

  71. /*          - Change version to 3.60 to coincide with release numbering.     */
    72. 

  72. /* 3.60.01  - Remove bogus error check in passthru routine                   */
    73. 

  73. /* 3.60.02  - Make DCDB direction based on lookup table                      */
    74. 

  74. /*          - Only allow one DCDB command to a SCSI ID at a time             */
    75. 

  75. /* 4.00.00  - Add support for ServeRAID 4                                    */
    76. 

  76. /* 4.00.01  - Add support for First Failure Data Capture                     */
    77. 

  77. /* 4.00.02  - Fix problem with PT DCDB with no buffer                        */
    78. 

  78. /* 4.00.03  - Add alternative passthru interface                             */
    79. 

  79. /*          - Add ability to flash BIOS                                      */
    80. 

  80. /* 4.00.04  - Rename structures/constants to be prefixed with IPS_           */
    81. 

  81. /* 4.00.05  - Remove wish_block from init routine                            */
    82. 

  82. /*          - Use linux/spinlock.h instead of asm/spinlock.h for kernels     */
    83. 

  83. /*            2.3.18 and later                                               */
    84. 

  84. /*          - Sync with other changes from the 2.3 kernels                   */
    85. 

  85. /* 4.00.06  - Fix timeout with initial FFDC command                          */
    86. 

  86. /* 4.00.06a - Port to 2.4 (trivial) -- Christoph Hellwig <hch@infradead.org> */
    87. 

  87. /* 4.10.00  - Add support for ServeRAID 4M/4L                                */
    88. 

  88. /* 4.10.13  - Fix for dynamic unload and proc file system                    */
    89. 

  89. /* 4.20.03  - Rename version to coincide with new release schedules          */
    90. 

  90. /*            Performance fixes                                              */
    91. 

  91. /*            Fix truncation of /proc files with cat                         */
    92. 

  92. /*            Merge in changes through kernel 2.4.0test1ac21                 */
    93. 

  93. /* 4.20.13  - Fix some failure cases / reset code                            */
    94. 

  94. /*          - Hook into the reboot_notifier to flush the controller cache    */
    95. 

  95. /* 4.50.01  - Fix problem when there is a hole in logical drive numbering    */
    96. 

  96. /* 4.70.09  - Use a Common ( Large Buffer ) for Flashing from the JCRM CD    */
    97. 

  97. /*          - Add IPSSEND Flash Support                                      */
    98. 

  98. /*          - Set Sense Data for Unknown SCSI Command                        */
    99. 

  99. /*          - Use Slot Number from NVRAM Page 5                              */
    100. 

  100. /*          - Restore caller's DCDB Structure                                */
    101. 

  101. /* 4.70.12  - Corrective actions for bad controller ( during initialization )*/
    102. 

  102. /* 4.70.13  - Don't Send CDB's if we already know the device is not present  */
    103. 

  103. /*          - Don't release HA Lock in ips_next() until SC taken off queue   */
    104. 

  104. /*          - Unregister SCSI device in ips_release()                        */
    105. 

  105. /* 4.70.15  - Fix Breakup for very large ( non-SG ) requests in ips_done()   */
    106. 

  106. /* 4.71.00  - Change all memory allocations to not use GFP_DMA flag          */
    107. 

  107. /*            Code Clean-Up for 2.4.x kernel                                 */
    108. 

  108. /* 4.72.00  - Allow for a Scatter-Gather Element to exceed MAX_XFER Size     */
    109. 

  109. /* 4.72.01  - I/O Mapped Memory release ( so "insmod ips" does not Fail )    */
    110. 

  110. /*          - Don't Issue Internal FFDC Command if there are Active Commands */
    111. 

  111. /*          - Close Window for getting too many IOCTL's active               */
    112. 

  112. /* 4.80.00  - Make ia64 Safe                                                 */
    113. 

  113. /* 4.80.04  - Eliminate calls to strtok() if 2.4.x or greater                */
    114. 

  114. /*          - Adjustments to Device Queue Depth                              */
    115. 

  115. /* 4.80.14  - Take all semaphores off stack                                  */
    116. 

  116. /*          - Clean Up New_IOCTL path                                        */
    117. 

  117. /* 4.80.20  - Set max_sectors in Scsi_Host structure ( if >= 2.4.7 kernel )  */
    118. 

  118. /*          - 5 second delay needed after resetting an i960 adapter          */
    119. 

  119. /* 4.80.26  - Clean up potential code problems ( Arjan's recommendations )   */
    120. 

  120. /* 4.90.01  - Version Matching for FirmWare, BIOS, and Driver                */
    121. 

  121. /* 4.90.05  - Use New PCI Architecture to facilitate Hot Plug Development    */
    122. 

  122. /* 4.90.08  - Increase Delays in Flashing ( Trombone Only - 4H )             */
    123. 

  123. /* 4.90.08  - Data Corruption if First Scatter Gather Element is > 64K       */
    124. 

  124. /* 4.90.11  - Don't actually RESET unless it's physically required           */
    125. 

  125. /*          - Remove unused compile options                                  */
    126. 

  126. /* 5.00.01  - Sarasota ( 5i ) adapters must always be scanned first          */
    127. 

  127. /*          - Get rid on IOCTL_NEW_COMMAND code                              */
    128. 

  128. /*          - Add Extended DCDB Commands for Tape Support in 5I              */
    129. 

  129. /* 5.10.12  - use pci_dma interfaces, update for 2.5 kernel changes          */
    130. 

  130. /* 5.10.15  - remove unused code (sem, macros, etc.)                         */
    131. 

  131. /* 5.30.00  - use __devexit_p()                                              */
    132. 

  132. /* 6.00.00  - Add 6x Adapters and Battery Flash                              */
    133. 

  133. /* 6.10.00  - Remove 1G Addressing Limitations                               */
    134. 

  134. /* 6.11.xx  - Get VersionInfo buffer off the stack !              DDTS 60401 */
    135. 

  135. /* 6.11.xx  - Make Logical Drive Info structure safe for DMA      DDTS 60639 */
    136. 

  136. /* 7.10.18  - Add highmem_io flag in SCSI Templete for 2.4 kernels           */
    137. 

  137. /*          - Fix path/name for scsi_hosts.h include for 2.6 kernels         */
    138. 

  138. /*          - Fix sort order of 7k                                           */
    139. 

  139. /*          - Remove 3 unused "inline" functions                             */
    140. 

  140. /* 7.12.xx  - Use STATIC functions whereever possible                        */
    141. 

  141. /*          - Clean up deprecated MODULE_PARM calls                          */
    142. 

  142. /* 7.12.05  - Remove Version Matching per IBM request                        */
    143. 

  143. /*****************************************************************************/
    144. 

  144. 

  145. /*
    146. 

  146.  * Conditional Compilation directives for this driver:
    147. 

  147.  *
    148. 

  148.  * IPS_DEBUG            - Turn on debugging info
    149. 

  149.  *
    150. 

  150.  * Parameters:
    151. 

  151.  *
    152. 

  152.  * debug:<number>       - Set debug level to <number>
    153. 

  153.  *                        NOTE: only works when IPS_DEBUG compile directive is used.
    154. 

  154.  *       1              - Normal debug messages
    155. 

  155.  *       2              - Verbose debug messages
    156. 

  156.  *       11             - Method trace (non interrupt)
    157. 

  157.  *       12             - Method trace (includes interrupt)
    158. 

  158.  *
    159. 

  159.  * noi2o                - Don't use I2O Queues (ServeRAID 4 only)
    160. 

  160.  * nommap               - Don't use memory mapped I/O
    161. 

  161.  * ioctlsize            - Initial size of the IOCTL buffer
    162. 

  162.  */
    163. 

  163. 

  164. #include <asm/io.h>
    165. 

  165. #include <asm/byteorder.h>
    166. 

  166. #include <asm/page.h>
    167. 

  167. #include <linux/stddef.h>
    168. 

  168. #include <linux/string.h>
    169. 

  169. #include <linux/errno.h>
    170. 

  170. #include <linux/kernel.h>
    171. 

  171. #include <linux/ioport.h>
    172. 

  172. #include <linux/slab.h>
    173. 

  173. #include <linux/delay.h>
    174. 

  174. #include <linux/pci.h>
    175. 

  175. #include <linux/proc_fs.h>
    176. 

  176. #include <linux/reboot.h>
    177. 

  177. #include <linux/interrupt.h>
    178. 

  178. 

  179. #include <linux/blkdev.h>
    180. 

  180. #include <linux/types.h>
    181. 

  181. #include <linux/dma-mapping.h>
    182. 

  182. 

  183. #include <scsi/sg.h>
    184. 

  184. #include "scsi.h"
    185. 

  185. #include <scsi/scsi_host.h>
    186. 

  186. 

  187. #include "ips.h"
    188. 

  188. 

  189. #include <linux/module.h>
    190. 

  190. 

  191. #include <linux/stat.h>
    192. 

  192. 

  193. #include <linux/spinlock.h>
    194. 

  194. #include <linux/init.h>
    195. 

  195. 

  196. #include <linux/smp.h>
    197. 

  197. 

  198. #ifdef MODULE
    199. 

  199. static char *ips = NULL;
    200. 

  200. module_param(ips, charp, 0);
    201. 

  201. #endif
    202. 

  202. 

  203. /*
    204. 

  204.  * DRIVER_VER
    205. 

  205.  */
    206. 

  206. #define IPS_VERSION_HIGH        IPS_VER_MAJOR_STRING "." IPS_VER_MINOR_STRING
    207. 

  207. #define IPS_VERSION_LOW         "." IPS_VER_BUILD_STRING " "
    208. 

  208. 

  209. #if !defined(__i386__) && !defined(__ia64__) && !defined(__x86_64__)
    210. 

  210. #warning "This driver has only been tested on the x86/ia64/x86_64 platforms"
    211. 

  211. #endif
    212. 

  212. 

  213. #define IPS_DMA_DIR(scb) ((!scb->scsi_cmd || ips_is_passthru(scb->scsi_cmd) || \
    214. 

  214.                          DMA_NONE == scb->scsi_cmd->sc_data_direction) ? \
    215. 

  215.                          PCI_DMA_BIDIRECTIONAL : \
    216. 

  216.                          scb->scsi_cmd->sc_data_direction)
    217. 

  217. 

  218. #ifdef IPS_DEBUG
    219. 

  219. #define METHOD_TRACE(s, i)    if (ips_debug >= (i+10)) printk(KERN_NOTICE s "\n");
    220. 

  220. #define DEBUG(i, s)           if (ips_debug >= i) printk(KERN_NOTICE s "\n");
    221. 

  221. #define DEBUG_VAR(i, s, v...) if (ips_debug >= i) printk(KERN_NOTICE s "\n", v);
    222. 

  222. #else
    223. 

  223. #define METHOD_TRACE(s, i)
    224. 

  224. #define DEBUG(i, s)
    225. 

  225. #define DEBUG_VAR(i, s, v...)
    226. 

  226. #endif
    227. 

  227. 

  228. /*
    229. 

  229.  * Function prototypes
    230. 

  230.  */
    231. 

  231. static int ips_detect(struct scsi_host_template *);
    232. 

  232. static int ips_release(struct Scsi_Host *);
    233. 

  233. static int ips_eh_abort(struct scsi_cmnd *);
    234. 

  234. static int ips_eh_reset(struct scsi_cmnd *);
    235. 

  235. static int ips_queue(struct scsi_cmnd *, void (*)(struct scsi_cmnd *));
    236. 

  236. static const char *ips_info(struct Scsi_Host *);
    237. 

  237. static irqreturn_t do_ipsintr(int, void *);
    238. 

  238. static int ips_hainit(ips_ha_t *);
    239. 

  239. static int ips_map_status(ips_ha_t *, ips_scb_t *, ips_stat_t *);
    240. 

  240. static int ips_send_wait(ips_ha_t *, ips_scb_t *, int, int);
    241. 

  241. static int ips_send_cmd(ips_ha_t *, ips_scb_t *);
    242. 

  242. static int ips_online(ips_ha_t *, ips_scb_t *);
    243. 

  243. static int ips_inquiry(ips_ha_t *, ips_scb_t *);
    244. 

  244. static int ips_rdcap(ips_ha_t *, ips_scb_t *);
    245. 

  245. static int ips_msense(ips_ha_t *, ips_scb_t *);
    246. 

  246. static int ips_reqsen(ips_ha_t *, ips_scb_t *);
    247. 

  247. static int ips_deallocatescbs(ips_ha_t *, int);
    248. 

  248. static int ips_allocatescbs(ips_ha_t *);
    249. 

  249. static int ips_reset_copperhead(ips_ha_t *);
    250. 

  250. static int ips_reset_copperhead_memio(ips_ha_t *);
    251. 

  251. static int ips_reset_morpheus(ips_ha_t *);
    252. 

  252. static int ips_issue_copperhead(ips_ha_t *, ips_scb_t *);
    253. 

  253. static int ips_issue_copperhead_memio(ips_ha_t *, ips_scb_t *);
    254. 

  254. static int ips_issue_i2o(ips_ha_t *, ips_scb_t *);
    255. 

  255. static int ips_issue_i2o_memio(ips_ha_t *, ips_scb_t *);
    256. 

  256. static int ips_isintr_copperhead(ips_ha_t *);
    257. 

  257. static int ips_isintr_copperhead_memio(ips_ha_t *);
    258. 

  258. static int ips_isintr_morpheus(ips_ha_t *);
    259. 

  259. static int ips_wait(ips_ha_t *, int, int);
    260. 

  260. static int ips_write_driver_status(ips_ha_t *, int);
    261. 

  261. static int ips_read_adapter_status(ips_ha_t *, int);
    262. 

  262. static int ips_read_subsystem_parameters(ips_ha_t *, int);
    263. 

  263. static int ips_read_config(ips_ha_t *, int);
    264. 

  264. static int ips_clear_adapter(ips_ha_t *, int);
    265. 

  265. static int ips_readwrite_page5(ips_ha_t *, int, int);
    266. 

  266. static int ips_init_copperhead(ips_ha_t *);
    267. 

  267. static int ips_init_copperhead_memio(ips_ha_t *);
    268. 

  268. static int ips_init_morpheus(ips_ha_t *);
    269. 

  269. static int ips_isinit_copperhead(ips_ha_t *);
    270. 

  270. static int ips_isinit_copperhead_memio(ips_ha_t *);
    271. 

  271. static int ips_isinit_morpheus(ips_ha_t *);
    272. 

  272. static int ips_erase_bios(ips_ha_t *);
    273. 

  273. static int ips_program_bios(ips_ha_t *, char *, uint32_t, uint32_t);
    274. 

  274. static int ips_verify_bios(ips_ha_t *, char *, uint32_t, uint32_t);
    275. 

  275. static int ips_erase_bios_memio(ips_ha_t *);
    276. 

  276. static int ips_program_bios_memio(ips_ha_t *, char *, uint32_t, uint32_t);
    277. 

  277. static int ips_verify_bios_memio(ips_ha_t *, char *, uint32_t, uint32_t);
    278. 

  278. static int ips_flash_copperhead(ips_ha_t *, ips_passthru_t *, ips_scb_t *);
    279. 

  279. static int ips_flash_bios(ips_ha_t *, ips_passthru_t *, ips_scb_t *);
    280. 

  280. static int ips_flash_firmware(ips_ha_t *, ips_passthru_t *, ips_scb_t *);
    281. 

  281. static void ips_free_flash_copperhead(ips_ha_t * ha);
    282. 

  282. static void ips_get_bios_version(ips_ha_t *, int);
    283. 

  283. static void ips_identify_controller(ips_ha_t *);
    284. 

  284. static void ips_chkstatus(ips_ha_t *, IPS_STATUS *);
    285. 

  285. static void ips_enable_int_copperhead(ips_ha_t *);
    286. 

  286. static void ips_enable_int_copperhead_memio(ips_ha_t *);
    287. 

  287. static void ips_enable_int_morpheus(ips_ha_t *);
    288. 

  288. static int ips_intr_copperhead(ips_ha_t *);
    289. 

  289. static int ips_intr_morpheus(ips_ha_t *);
    290. 

  290. static void ips_next(ips_ha_t *, int);
    291. 

  291. static void ipsintr_blocking(ips_ha_t *, struct ips_scb *);
    292. 

  292. static void ipsintr_done(ips_ha_t *, struct ips_scb *);
    293. 

  293. static void ips_done(ips_ha_t *, ips_scb_t *);
    294. 

  294. static void ips_free(ips_ha_t *);
    295. 

  295. static void ips_init_scb(ips_ha_t *, ips_scb_t *);
    296. 

  296. static void ips_freescb(ips_ha_t *, ips_scb_t *);
    297. 

  297. static void ips_setup_funclist(ips_ha_t *);
    298. 

  298. static void ips_statinit(ips_ha_t *);
    299. 

  299. static void ips_statinit_memio(ips_ha_t *);
    300. 

  300. static void ips_fix_ffdc_time(ips_ha_t *, ips_scb_t *, time_t);
    301. 

  301. static void ips_ffdc_reset(ips_ha_t *, int);
    302. 

  302. static void ips_ffdc_time(ips_ha_t *);
    303. 

  303. static uint32_t ips_statupd_copperhead(ips_ha_t *);
    304. 

  304. static uint32_t ips_statupd_copperhead_memio(ips_ha_t *);
    305. 

  305. static uint32_t ips_statupd_morpheus(ips_ha_t *);
    306. 

  306. static ips_scb_t *ips_getscb(ips_ha_t *);
    307. 

  307. static void ips_putq_scb_head(ips_scb_queue_t *, ips_scb_t *);
    308. 

  308. static void ips_putq_wait_tail(ips_wait_queue_t *, struct scsi_cmnd *);
    309. 

  309. static void ips_putq_copp_tail(ips_copp_queue_t *,
    310. 

  310. 				      ips_copp_wait_item_t *);
    311. 

  311. static ips_scb_t *ips_removeq_scb_head(ips_scb_queue_t *);
    312. 

  312. static ips_scb_t *ips_removeq_scb(ips_scb_queue_t *, ips_scb_t *);
    313. 

  313. static struct scsi_cmnd *ips_removeq_wait_head(ips_wait_queue_t *);
    314. 

  314. static struct scsi_cmnd *ips_removeq_wait(ips_wait_queue_t *,
    315. 

  315. 					  struct scsi_cmnd *);
    316. 

  316. static ips_copp_wait_item_t *ips_removeq_copp(ips_copp_queue_t *,
    317. 

  317. 						     ips_copp_wait_item_t *);
    318. 

  318. static ips_copp_wait_item_t *ips_removeq_copp_head(ips_copp_queue_t *);
    319. 

  319. 

  320. static int ips_is_passthru(struct scsi_cmnd *);
    321. 

  321. static int ips_make_passthru(ips_ha_t *, struct scsi_cmnd *, ips_scb_t *, int);
    322. 

  322. static int ips_usrcmd(ips_ha_t *, ips_passthru_t *, ips_scb_t *);
    323. 

  323. static void ips_cleanup_passthru(ips_ha_t *, ips_scb_t *);
    324. 

  324. static void ips_scmd_buf_write(struct scsi_cmnd * scmd, void *data,
    325. 

  325. 			       unsigned int count);
    326. 

  326. static void ips_scmd_buf_read(struct scsi_cmnd * scmd, void *data,
    327. 

  327. 			      unsigned int count);
    328. 

  328. 

  329. static int ips_proc_info(struct Scsi_Host *, char *, char **, off_t, int, int);
    330. 

  330. static int ips_host_info(ips_ha_t *, char *, off_t, int);
    331. 

  331. static void copy_mem_info(IPS_INFOSTR *, char *, int);
    332. 

  332. static int copy_info(IPS_INFOSTR *, char *, ...);
    333. 

  333. static int ips_abort_init(ips_ha_t * ha, int index);
    334. 

  334. static int ips_init_phase2(int index);
    335. 

  335. 

  336. static int ips_init_phase1(struct pci_dev *pci_dev, int *indexPtr);
    337. 

  337. static int ips_register_scsi(int index);
    338. 

  338. 

  339. static int  ips_poll_for_flush_complete(ips_ha_t * ha);
    340. 

  340. static void ips_flush_and_reset(ips_ha_t *ha);
    341. 

  341. 

  342. /*
    343. 

  343.  * global variables
    344. 

  344.  */
    345. 

  345. static const char ips_name[] = "ips";
    346. 

  346. static struct Scsi_Host *ips_sh[IPS_MAX_ADAPTERS];	/* Array of host controller structures */
    347. 

  347. static ips_ha_t *ips_ha[IPS_MAX_ADAPTERS];	/* Array of HA structures */
    348. 

  348. static unsigned int ips_next_controller;
    349. 

  349. static unsigned int ips_num_controllers;
    350. 

  350. static unsigned int ips_released_controllers;
    351. 

  351. static int ips_hotplug;
    352. 

  352. static int ips_cmd_timeout = 60;
    353. 

  353. static int ips_reset_timeout = 60 * 5;
    354. 

  354. static int ips_force_memio = 1;		/* Always use Memory Mapped I/O    */
    355. 

  355. static int ips_force_i2o = 1;	/* Always use I2O command delivery */
    356. 

  356. static int ips_ioctlsize = IPS_IOCTL_SIZE;	/* Size of the ioctl buffer        */
    357. 

  357. static int ips_cd_boot;			/* Booting from Manager CD         */
    358. 

  358. static char *ips_FlashData = NULL;	/* CD Boot - Flash Data Buffer      */
    359. 

  359. static dma_addr_t ips_flashbusaddr;
    360. 

  360. static long ips_FlashDataInUse;		/* CD Boot - Flash Data In Use Flag */
    361. 

  361. static uint32_t MaxLiteCmds = 32;	/* Max Active Cmds for a Lite Adapter */
    362. 

  362. static struct scsi_host_template ips_driver_template = {
    363. 

  363. 	.detect			= ips_detect,
    364. 

  364. 	.release		= ips_release,
    365. 

  365. 	.info			= ips_info,
    366. 

  366. 	.queuecommand		= ips_queue,
    367. 

  367. 	.eh_abort_handler	= ips_eh_abort,
    368. 

  368. 	.eh_host_reset_handler	= ips_eh_reset,
    369. 

  369. 	.proc_name		= "ips",
    370. 

  370. 	.proc_info		= ips_proc_info,
    371. 

  371. 	.slave_configure	= ips_slave_configure,
    372. 

  372. 	.bios_param		= ips_biosparam,
    373. 

  373. 	.this_id		= -1,
    374. 

  374. 	.sg_tablesize		= IPS_MAX_SG,
    375. 

  375. 	.cmd_per_lun		= 3,
    376. 

  376. 	.use_clustering		= ENABLE_CLUSTERING,
    377. 

  377. };
    378. 

  378. 

  379. 

  380. /* This table describes all ServeRAID Adapters */
    381. 

  381. static struct  pci_device_id  ips_pci_table[] = {
    382. 

  382. 	{ 0x1014, 0x002E, PCI_ANY_ID, PCI_ANY_ID, 0, 0 },
    383. 

  383. 	{ 0x1014, 0x01BD, PCI_ANY_ID, PCI_ANY_ID, 0, 0 },
    384. 

  384. 	{ 0x9005, 0x0250, PCI_ANY_ID, PCI_ANY_ID, 0, 0 },
    385. 

  385. 	{ 0, }
    386. 

  386. };
    387. 

  387. 

  388. MODULE_DEVICE_TABLE( pci, ips_pci_table );
    389. 

  389. 

  390. static char ips_hot_plug_name[] = "ips";
    391. 

  391. 

  392. static int __devinit  ips_insert_device(struct pci_dev *pci_dev, const struct pci_device_id *ent);
    393. 

  393. static void __devexit ips_remove_device(struct pci_dev *pci_dev);
    394. 

  394. 

  395. static struct pci_driver ips_pci_driver = {
    396. 

  396. 	.name		= ips_hot_plug_name,
    397. 

  397. 	.id_table	= ips_pci_table,
    398. 

  398. 	.probe		= ips_insert_device,
    399. 

  399. 	.remove		= __devexit_p(ips_remove_device),
    400. 

  400. };
    401. 

  401. 

  402. 

  403. /*
    404. 

  404.  * Necessary forward function protoypes
    405. 

  405.  */
    406. 

  406. static int ips_halt(struct notifier_block *nb, ulong event, void *buf);
    407. 

  407. 

  408. #define MAX_ADAPTER_NAME 15
    409. 

  409. 

  410. static char ips_adapter_name[][30] = {
    411. 

  411. 	"ServeRAID",
    412. 

  412. 	"ServeRAID II",
    413. 

  413. 	"ServeRAID on motherboard",
    414. 

  414. 	"ServeRAID on motherboard",
    415. 

  415. 	"ServeRAID 3H",
    416. 

  416. 	"ServeRAID 3L",
    417. 

  417. 	"ServeRAID 4H",
    418. 

  418. 	"ServeRAID 4M",
    419. 

  419. 	"ServeRAID 4L",
    420. 

  420. 	"ServeRAID 4Mx",
    421. 

  421. 	"ServeRAID 4Lx",
    422. 

  422. 	"ServeRAID 5i",
    423. 

  423. 	"ServeRAID 5i",
    424. 

  424. 	"ServeRAID 6M",
    425. 

  425. 	"ServeRAID 6i",
    426. 

  426. 	"ServeRAID 7t",
    427. 

  427. 	"ServeRAID 7k",
    428. 

  428. 	"ServeRAID 7M"
    429. 

  429. };
    430. 

  430. 

  431. static struct notifier_block ips_notifier = {
    432. 

  432. 	ips_halt, NULL, 0
    433. 

  433. };
    434. 

  434. 

  435. /*
    436. 

  436.  * Direction table
    437. 

  437.  */
    438. 

  438. static char ips_command_direction[] = {
    439. 

  439. 	IPS_DATA_NONE, IPS_DATA_NONE, IPS_DATA_IN, IPS_DATA_IN, IPS_DATA_OUT,
    440. 

  440. 	IPS_DATA_IN, IPS_DATA_IN, IPS_DATA_OUT, IPS_DATA_IN, IPS_DATA_UNK,
    441. 

  441. 	IPS_DATA_OUT, IPS_DATA_OUT, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
    442. 

  442. 	IPS_DATA_IN, IPS_DATA_NONE, IPS_DATA_NONE, IPS_DATA_IN, IPS_DATA_OUT,
    443. 

  443. 	IPS_DATA_IN, IPS_DATA_OUT, IPS_DATA_NONE, IPS_DATA_NONE, IPS_DATA_OUT,
    444. 

  444. 	IPS_DATA_NONE, IPS_DATA_IN, IPS_DATA_NONE, IPS_DATA_IN, IPS_DATA_OUT,
    445. 

  445. 	IPS_DATA_NONE, IPS_DATA_UNK, IPS_DATA_IN, IPS_DATA_UNK, IPS_DATA_IN,
    446. 

  446. 	IPS_DATA_UNK, IPS_DATA_OUT, IPS_DATA_IN, IPS_DATA_UNK, IPS_DATA_UNK,
    447. 

  447. 	IPS_DATA_IN, IPS_DATA_IN, IPS_DATA_OUT, IPS_DATA_NONE, IPS_DATA_UNK,
    448. 

  448. 	IPS_DATA_IN, IPS_DATA_OUT, IPS_DATA_OUT, IPS_DATA_OUT, IPS_DATA_OUT,
    449. 

  449. 	IPS_DATA_OUT, IPS_DATA_NONE, IPS_DATA_IN, IPS_DATA_NONE, IPS_DATA_NONE,
    450. 

  450. 	IPS_DATA_IN, IPS_DATA_OUT, IPS_DATA_OUT, IPS_DATA_OUT, IPS_DATA_OUT,
    451. 

  451. 	IPS_DATA_IN, IPS_DATA_OUT, IPS_DATA_IN, IPS_DATA_OUT, IPS_DATA_OUT,
    452. 

  452. 	IPS_DATA_OUT, IPS_DATA_IN, IPS_DATA_IN, IPS_DATA_IN, IPS_DATA_NONE,
    453. 

  453. 	IPS_DATA_UNK, IPS_DATA_NONE, IPS_DATA_NONE, IPS_DATA_NONE, IPS_DATA_UNK,
    454. 

  454. 	IPS_DATA_NONE, IPS_DATA_OUT, IPS_DATA_IN, IPS_DATA_UNK, IPS_DATA_UNK,
    455. 

  455. 	IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
    456. 

  456. 	IPS_DATA_OUT, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
    457. 

  457. 	IPS_DATA_IN, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
    458. 

  458. 	IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
    459. 

  459. 	IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
    460. 

  460. 	IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
    461. 

  461. 	IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
    462. 

  462. 	IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
    463. 

  463. 	IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
    464. 

  464. 	IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
    465. 

  465. 	IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
    466. 

  466. 	IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
    467. 

  467. 	IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
    468. 

  468. 	IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
    469. 

  469. 	IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
    470. 

  470. 	IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
    471. 

  471. 	IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
    472. 

  472. 	IPS_DATA_NONE, IPS_DATA_NONE, IPS_DATA_UNK, IPS_DATA_IN, IPS_DATA_NONE,
    473. 

  473. 	IPS_DATA_OUT, IPS_DATA_UNK, IPS_DATA_NONE, IPS_DATA_UNK, IPS_DATA_OUT,
    474. 

  474. 	IPS_DATA_OUT, IPS_DATA_OUT, IPS_DATA_OUT, IPS_DATA_OUT, IPS_DATA_NONE,
    475. 

  475. 	IPS_DATA_UNK, IPS_DATA_IN, IPS_DATA_OUT, IPS_DATA_IN, IPS_DATA_IN,
    476. 

  476. 	IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
    477. 

  477. 	IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
    478. 

  478. 	IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
    479. 

  479. 	IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
    480. 

  480. 	IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
    481. 

  481. 	IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
    482. 

  482. 	IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
    483. 

  483. 	IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
    484. 

  484. 	IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
    485. 

  485. 	IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_OUT,
    486. 

  486. 	IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
    487. 

  487. 	IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
    488. 

  488. 	IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
    489. 

  489. 	IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK
    490. 

  490. };
    491. 

  491. 

  492. 

  493. /****************************************************************************/
    494. 

  494. /*                                                                          */
    495. 

  495. /* Routine Name: ips_setup                                                  */
    496. 

  496. /*                                                                          */
    497. 

  497. /* Routine Description:                                                     */
    498. 

  498. /*                                                                          */
    499. 

  499. /*   setup parameters to the driver                                         */
    500. 

  500. /*                                                                          */
    501. 

  501. /****************************************************************************/
    502. 

  502. static int
    503. 

  503. ips_setup(char *ips_str)
    504. 

  504. {
    505. 

  505. 

  506. 	int i;
    507. 

  507. 	char *key;
    508. 

  508. 	char *value;
    509. 

  509. 	IPS_OPTION options[] = {
    510. 

  510. 		{"noi2o", &ips_force_i2o, 0},
    511. 

  511. 		{"nommap", &ips_force_memio, 0},
    512. 

  512. 		{"ioctlsize", &ips_ioctlsize, IPS_IOCTL_SIZE},
    513. 

  513. 		{"cdboot", &ips_cd_boot, 0},
    514. 

  514. 		{"maxcmds", &MaxLiteCmds, 32},
    515. 

  515. 	};
    516. 

  516. 

  517. 	/* Don't use strtok() anymore ( if 2.4 Kernel or beyond ) */
    518. 

  518. 	/* Search for value */
    519. 

  519. 	while ((key = strsep(&ips_str, ",."))) {
    520. 

  520. 		if (!*key)
    521. 

  521. 			continue;
    522. 

  522. 		value = strchr(key, ':');
    523. 

  523. 		if (value)
    524. 

  524. 			*value++ = '\0';
    525. 

  525. 		/*
    526. 

  526. 		 * We now have key/value pairs.
    527. 

  527. 		 * Update the variables
    528. 

  528. 		 */
    529. 

  529. 		for (i = 0; i < ARRAY_SIZE(options); i++) {
    530. 

  530. 			if (strnicmp
    531. 

  531. 			    (key, options[i].option_name,
    532. 

  532. 			     strlen(options[i].option_name)) == 0) {
    533. 

  533. 				if (value)
    534. 

  534. 					*options[i].option_flag =
    535. 

  535. 					    simple_strtoul(value, NULL, 0);
    536. 

  536. 				else
    537. 

  537. 					*options[i].option_flag =
    538. 

  538. 					    options[i].option_value;
    539. 

  539. 				break;
    540. 

  540. 			}
    541. 

  541. 		}
    542. 

  542. 	}
    543. 

  543. 

  544. 	return (1);
    545. 

  545. }
    546. 

  546. 

  547. __setup("ips=", ips_setup);
    548. 

  548. 

  549. /****************************************************************************/
    550. 

  550. /*                                                                          */
    551. 

  551. /* Routine Name: ips_detect                                                 */
    552. 

  552. /*                                                                          */
    553. 

  553. /* Routine Description:                                                     */
    554. 

  554. /*                                                                          */
    555. 

  555. /*   Detect and initialize the driver                                       */
    556. 

  556. /*                                                                          */
    557. 

  557. /* NOTE: this routine is called under the io_request_lock spinlock          */
    558. 

  558. /*                                                                          */
    559. 

  559. /****************************************************************************/
    560. 

  560. static int
    561. 

  561. ips_detect(struct scsi_host_template * SHT)
    562. 

  562. {
    563. 

  563. 	int i;
    564. 

  564. 

  565. 	METHOD_TRACE("ips_detect", 1);
    566. 

  566. 

  567. #ifdef MODULE
    568. 

  568. 	if (ips)
    569. 

  569. 		ips_setup(ips);
    570. 

  570. #endif
    571. 

  571. 

  572. 	for (i = 0; i < ips_num_controllers; i++) {
    573. 

  573. 		if (ips_register_scsi(i))
    574. 

  574. 			ips_free(ips_ha[i]);
    575. 

  575. 		ips_released_controllers++;
    576. 

  576. 	}
    577. 

  577. 	ips_hotplug = 1;
    578. 

  578. 	return (ips_num_controllers);
    579. 

  579. }
    580. 

  580. 

  581. /****************************************************************************/
    582. 

  582. /*   configure the function pointers to use the functions that will work    */
    583. 

  583. /*   with the found version of the adapter                                  */
    584. 

  584. /****************************************************************************/
    585. 

  585. static void
    586. 

  586. ips_setup_funclist(ips_ha_t * ha)
    587. 

  587. {
    588. 

  588. 

  589. 	/*
    590. 

  590. 	 * Setup Functions
    591. 

  591. 	 */
    592. 

  592. 	if (IPS_IS_MORPHEUS(ha) || IPS_IS_MARCO(ha)) {
    593. 

  593. 		/* morpheus / marco / sebring */
    594. 

  594. 		ha->func.isintr = ips_isintr_morpheus;
    595. 

  595. 		ha->func.isinit = ips_isinit_morpheus;
    596. 

  596. 		ha->func.issue = ips_issue_i2o_memio;
    597. 

  597. 		ha->func.init = ips_init_morpheus;
    598. 

  598. 		ha->func.statupd = ips_statupd_morpheus;
    599. 

  599. 		ha->func.reset = ips_reset_morpheus;
    600. 

  600. 		ha->func.intr = ips_intr_morpheus;
    601. 

  601. 		ha->func.enableint = ips_enable_int_morpheus;
    602. 

  602. 	} else if (IPS_USE_MEMIO(ha)) {
    603. 

  603. 		/* copperhead w/MEMIO */
    604. 

  604. 		ha->func.isintr = ips_isintr_copperhead_memio;
    605. 

  605. 		ha->func.isinit = ips_isinit_copperhead_memio;
    606. 

  606. 		ha->func.init = ips_init_copperhead_memio;
    607. 

  607. 		ha->func.statupd = ips_statupd_copperhead_memio;
    608. 

  608. 		ha->func.statinit = ips_statinit_memio;
    609. 

  609. 		ha->func.reset = ips_reset_copperhead_memio;
    610. 

  610. 		ha->func.intr = ips_intr_copperhead;
    611. 

  611. 		ha->func.erasebios = ips_erase_bios_memio;
    612. 

  612. 		ha->func.programbios = ips_program_bios_memio;
    613. 

  613. 		ha->func.verifybios = ips_verify_bios_memio;
    614. 

  614. 		ha->func.enableint = ips_enable_int_copperhead_memio;
    615. 

  615. 		if (IPS_USE_I2O_DELIVER(ha))
    616. 

  616. 			ha->func.issue = ips_issue_i2o_memio;
    617. 

  617. 		else
    618. 

  618. 			ha->func.issue = ips_issue_copperhead_memio;
    619. 

  619. 	} else {
    620. 

  620. 		/* copperhead */
    621. 

  621. 		ha->func.isintr = ips_isintr_copperhead;
    622. 

  622. 		ha->func.isinit = ips_isinit_copperhead;
    623. 

  623. 		ha->func.init = ips_init_copperhead;
    624. 

  624. 		ha->func.statupd = ips_statupd_copperhead;
    625. 

  625. 		ha->func.statinit = ips_statinit;
    626. 

  626. 		ha->func.reset = ips_reset_copperhead;
    627. 

  627. 		ha->func.intr = ips_intr_copperhead;
    628. 

  628. 		ha->func.erasebios = ips_erase_bios;
    629. 

  629. 		ha->func.programbios = ips_program_bios;
    630. 

  630. 		ha->func.verifybios = ips_verify_bios;
    631. 

  631. 		ha->func.enableint = ips_enable_int_copperhead;
    632. 

  632. 

  633. 		if (IPS_USE_I2O_DELIVER(ha))
    634. 

  634. 			ha->func.issue = ips_issue_i2o;
    635. 

  635. 		else
    636. 

  636. 			ha->func.issue = ips_issue_copperhead;
    637. 

  637. 	}
    638. 

  638. }
    639. 

  639. 

  640. /****************************************************************************/
    641. 

  641. /*                                                                          */
    642. 

  642. /* Routine Name: ips_release                                                */
    643. 

  643. /*                                                                          */
    644. 

  644. /* Routine Description:                                                     */
    645. 

  645. /*                                                                          */
    646. 

  646. /*   Remove a driver                                                        */
    647. 

  647. /*                                                                          */
    648. 

  648. /****************************************************************************/
    649. 

  649. static int
    650. 

  650. ips_release(struct Scsi_Host *sh)
    651. 

  651. {
    652. 

  652. 	ips_scb_t *scb;
    653. 

  653. 	ips_ha_t *ha;
    654. 

  654. 	int i;
    655. 

  655. 

  656. 	METHOD_TRACE("ips_release", 1);
    657. 

  657. 

  658. 	scsi_remove_host(sh);
    659. 

  659. 

  660. 	for (i = 0; i < IPS_MAX_ADAPTERS && ips_sh[i] != sh; i++) ;
    661. 

  661. 

  662. 	if (i == IPS_MAX_ADAPTERS) {
    663. 

  663. 		printk(KERN_WARNING
    664. 

  664. 		       "(%s) release, invalid Scsi_Host pointer.\n", ips_name);
    665. 

  665. 		BUG();
    666. 

  666. 		return (FALSE);
    667. 

  667. 	}
    668. 

  668. 

  669. 	ha = IPS_HA(sh);
    670. 

  670. 

  671. 	if (!ha)
    672. 

  672. 		return (FALSE);
    673. 

  673. 

  674. 	/* flush the cache on the controller */
    675. 

  675. 	scb = &ha->scbs[ha->max_cmds - 1];
    676. 

  676. 

  677. 	ips_init_scb(ha, scb);
    678. 

  678. 

  679. 	scb->timeout = ips_cmd_timeout;
    680. 

  680. 	scb->cdb[0] = IPS_CMD_FLUSH;
    681. 

  681. 

  682. 	scb->cmd.flush_cache.op_code = IPS_CMD_FLUSH;
    683. 

  683. 	scb->cmd.flush_cache.command_id = IPS_COMMAND_ID(ha, scb);
    684. 

  684. 	scb->cmd.flush_cache.state = IPS_NORM_STATE;
    685. 

  685. 	scb->cmd.flush_cache.reserved = 0;
    686. 

  686. 	scb->cmd.flush_cache.reserved2 = 0;
    687. 

  687. 	scb->cmd.flush_cache.reserved3 = 0;
    688. 

  688. 	scb->cmd.flush_cache.reserved4 = 0;
    689. 

  689. 

  690. 	IPS_PRINTK(KERN_WARNING, ha->pcidev, "Flushing Cache.\n");
    691. 

  691. 

  692. 	/* send command */
    693. 

  693. 	if (ips_send_wait(ha, scb, ips_cmd_timeout, IPS_INTR_ON) == IPS_FAILURE)
    694. 

  694. 		IPS_PRINTK(KERN_WARNING, ha->pcidev, "Incomplete Flush.\n");
    695. 

  695. 

  696. 	IPS_PRINTK(KERN_WARNING, ha->pcidev, "Flushing Complete.\n");
    697. 

  697. 

  698. 	ips_sh[i] = NULL;
    699. 

  699. 	ips_ha[i] = NULL;
    700. 

  700. 

  701. 	/* free extra memory */
    702. 

  702. 	ips_free(ha);
    703. 

  703. 

  704. 	/* free IRQ */
    705. 

  705. 	free_irq(ha->pcidev->irq, ha);
    706. 

  706. 

  707. 	scsi_host_put(sh);
    708. 

  708. 

  709. 	ips_released_controllers++;
    710. 

  710. 

  711. 	return (FALSE);
    712. 

  712. }
    713. 

  713. 

  714. /****************************************************************************/
    715. 

  715. /*                                                                          */
    716. 

  716. /* Routine Name: ips_halt                                                   */
    717. 

  717. /*                                                                          */
    718. 

  718. /* Routine Description:                                                     */
    719. 

  719. /*                                                                          */
    720. 

  720. /*   Perform cleanup when the system reboots                                */
    721. 

  721. /*                                                                          */
    722. 

  722. /****************************************************************************/
    723. 

  723. static int
    724. 

  724. ips_halt(struct notifier_block *nb, ulong event, void *buf)
    725. 

  725. {
    726. 

  726. 	ips_scb_t *scb;
    727. 

  727. 	ips_ha_t *ha;
    728. 

  728. 	int i;
    729. 

  729. 

  730. 	if ((event != SYS_RESTART) && (event != SYS_HALT) &&
    731. 

  731. 	    (event != SYS_POWER_OFF))
    732. 

  732. 		return (NOTIFY_DONE);
    733. 

  733. 

  734. 	for (i = 0; i < ips_next_controller; i++) {
    735. 

  735. 		ha = (ips_ha_t *) ips_ha[i];
    736. 

  736. 

  737. 		if (!ha)
    738. 

  738. 			continue;
    739. 

  739. 

  740. 		if (!ha->active)
    741. 

  741. 			continue;
    742. 

  742. 

  743. 		/* flush the cache on the controller */
    744. 

  744. 		scb = &ha->scbs[ha->max_cmds - 1];
    745. 

  745. 

  746. 		ips_init_scb(ha, scb);
    747. 

  747. 

  748. 		scb->timeout = ips_cmd_timeout;
    749. 

  749. 		scb->cdb[0] = IPS_CMD_FLUSH;
    750. 

  750. 

  751. 		scb->cmd.flush_cache.op_code = IPS_CMD_FLUSH;
    752. 

  752. 		scb->cmd.flush_cache.command_id = IPS_COMMAND_ID(ha, scb);
    753. 

  753. 		scb->cmd.flush_cache.state = IPS_NORM_STATE;
    754. 

  754. 		scb->cmd.flush_cache.reserved = 0;
    755. 

  755. 		scb->cmd.flush_cache.reserved2 = 0;
    756. 

  756. 		scb->cmd.flush_cache.reserved3 = 0;
    757. 

  757. 		scb->cmd.flush_cache.reserved4 = 0;
    758. 

  758. 

  759. 		IPS_PRINTK(KERN_WARNING, ha->pcidev, "Flushing Cache.\n");
    760. 

  760. 

  761. 		/* send command */
    762. 

  762. 		if (ips_send_wait(ha, scb, ips_cmd_timeout, IPS_INTR_ON) ==
    763. 

  763. 		    IPS_FAILURE)
    764. 

  764. 			IPS_PRINTK(KERN_WARNING, ha->pcidev,
    765. 

  765. 				   "Incomplete Flush.\n");
    766. 

  766. 		else
    767. 

  767. 			IPS_PRINTK(KERN_WARNING, ha->pcidev,
    768. 

  768. 				   "Flushing Complete.\n");
    769. 

  769. 	}
    770. 

  770. 

  771. 	return (NOTIFY_OK);
    772. 

  772. }
    773. 

  773. 

  774. /****************************************************************************/
    775. 

  775. /*                                                                          */
    776. 

  776. /* Routine Name: ips_eh_abort                                               */
    777. 

  777. /*                                                                          */
    778. 

  778. /* Routine Description:                                                     */
    779. 

  779. /*                                                                          */
    780. 

  780. /*   Abort a command (using the new error code stuff)                       */
    781. 

  781. /* Note: this routine is called under the io_request_lock                   */
    782. 

  782. /****************************************************************************/
    783. 

  783. int ips_eh_abort(struct scsi_cmnd *SC)
    784. 

  784. {
    785. 

  785. 	ips_ha_t *ha;
    786. 

  786. 	ips_copp_wait_item_t *item;
    787. 

  787. 	int ret;
    788. 

  788. 	struct Scsi_Host *host;
    789. 

  789. 

  790. 	METHOD_TRACE("ips_eh_abort", 1);
    791. 

  791. 

  792. 	if (!SC)
    793. 

  793. 		return (FAILED);
    794. 

  794. 

  795. 	host = SC->device->host;
    796. 

  796. 	ha = (ips_ha_t *) SC->device->host->hostdata;
    797. 

  797. 

  798. 	if (!ha)
    799. 

  799. 		return (FAILED);
    800. 

  800. 

  801. 	if (!ha->active)
    802. 

  802. 		return (FAILED);
    803. 

  803. 

  804. 	spin_lock(host->host_lock);
    805. 

  805. 

  806. 	/* See if the command is on the copp queue */
    807. 

  807. 	item = ha->copp_waitlist.head;
    808. 

  808. 	while ((item) && (item->scsi_cmd != SC))
    809. 

  809. 		item = item->next;
    810. 

  810. 

  811. 	if (item) {
    812. 

  812. 		/* Found it */
    813. 

  813. 		ips_removeq_copp(&ha->copp_waitlist, item);
    814. 

  814. 		ret = (SUCCESS);
    815. 

  815. 

  816. 		/* See if the command is on the wait queue */
    817. 

  817. 	} else if (ips_removeq_wait(&ha->scb_waitlist, SC)) {
    818. 

  818. 		/* command not sent yet */
    819. 

  819. 		ret = (SUCCESS);
    820. 

  820. 	} else {
    821. 

  821. 		/* command must have already been sent */
    822. 

  822. 		ret = (FAILED);
    823. 

  823. 	}
    824. 

  824. 

  825. 	spin_unlock(host->host_lock);
    826. 

  826. 	return ret;
    827. 

  827. }
    828. 

  828. 

  829. /****************************************************************************/
    830. 

  830. /*                                                                          */
    831. 

  831. /* Routine Name: ips_eh_reset                                               */
    832. 

  832. /*                                                                          */
    833. 

  833. /* Routine Description:                                                     */
    834. 

  834. /*                                                                          */
    835. 

  835. /*   Reset the controller (with new eh error code)                          */
    836. 

  836. /*                                                                          */
    837. 

  837. /* NOTE: this routine is called under the io_request_lock spinlock          */
    838. 

  838. /*                                                                          */
    839. 

  839. /****************************************************************************/
    840. 

  840. static int __ips_eh_reset(struct scsi_cmnd *SC)
    841. 

  841. {
    842. 

  842. 	int ret;
    843. 

  843. 	int i;
    844. 

  844. 	ips_ha_t *ha;
    845. 

  845. 	ips_scb_t *scb;
    846. 

  846. 	ips_copp_wait_item_t *item;
    847. 

  847. 

  848. 	METHOD_TRACE("ips_eh_reset", 1);
    849. 

  849. 

  850. #ifdef NO_IPS_RESET
    851. 

  851. 	return (FAILED);
    852. 

  852. #else
    853. 

  853. 

  854. 	if (!SC) {
    855. 

  855. 		DEBUG(1, "Reset called with NULL scsi command");
    856. 

  856. 

  857. 		return (FAILED);
    858. 

  858. 	}
    859. 

  859. 

  860. 	ha = (ips_ha_t *) SC->device->host->hostdata;
    861. 

  861. 

  862. 	if (!ha) {
    863. 

  863. 		DEBUG(1, "Reset called with NULL ha struct");
    864. 

  864. 

  865. 		return (FAILED);
    866. 

  866. 	}
    867. 

  867. 

  868. 	if (!ha->active)
    869. 

  869. 		return (FAILED);
    870. 

  870. 

  871. 	/* See if the command is on the copp queue */
    872. 

  872. 	item = ha->copp_waitlist.head;
    873. 

  873. 	while ((item) && (item->scsi_cmd != SC))
    874. 

  874. 		item = item->next;
    875. 

  875. 

  876. 	if (item) {
    877. 

  877. 		/* Found it */
    878. 

  878. 		ips_removeq_copp(&ha->copp_waitlist, item);
    879. 

  879. 		return (SUCCESS);
    880. 

  880. 	}
    881. 

  881. 

  882. 	/* See if the command is on the wait queue */
    883. 

  883. 	if (ips_removeq_wait(&ha->scb_waitlist, SC)) {
    884. 

  884. 		/* command not sent yet */
    885. 

  885. 		return (SUCCESS);
    886. 

  886. 	}
    887. 

  887. 

  888. 	/* An explanation for the casual observer:                              */
    889. 

  889. 	/* Part of the function of a RAID controller is automatic error         */
    890. 

  890. 	/* detection and recovery.  As such, the only problem that physically   */
    891. 

  891. 	/* resetting an adapter will ever fix is when, for some reason,         */
    892. 

  892. 	/* the driver is not successfully communicating with the adapter.       */
    893. 

  893. 	/* Therefore, we will attempt to flush this adapter.  If that succeeds, */
    894. 

  894. 	/* then there's no real purpose in a physical reset. This will complete */
    895. 

  895. 	/* much faster and avoids any problems that might be caused by a        */
    896. 

  896. 	/* physical reset ( such as having to fail all the outstanding I/O's ). */
    897. 

  897. 

  898. 	if (ha->ioctl_reset == 0) {	/* IF Not an IOCTL Requested Reset */
    899. 

  899. 		scb = &ha->scbs[ha->max_cmds - 1];
    900. 

  900. 

  901. 		ips_init_scb(ha, scb);
    902. 

  902. 

  903. 		scb->timeout = ips_cmd_timeout;
    904. 

  904. 		scb->cdb[0] = IPS_CMD_FLUSH;
    905. 

  905. 

  906. 		scb->cmd.flush_cache.op_code = IPS_CMD_FLUSH;
    907. 

  907. 		scb->cmd.flush_cache.command_id = IPS_COMMAND_ID(ha, scb);
    908. 

  908. 		scb->cmd.flush_cache.state = IPS_NORM_STATE;
    909. 

  909. 		scb->cmd.flush_cache.reserved = 0;
    910. 

  910. 		scb->cmd.flush_cache.reserved2 = 0;
    911. 

  911. 		scb->cmd.flush_cache.reserved3 = 0;
    912. 

  912. 		scb->cmd.flush_cache.reserved4 = 0;
    913. 

  913. 

  914. 		/* Attempt the flush command */
    915. 

  915. 		ret = ips_send_wait(ha, scb, ips_cmd_timeout, IPS_INTR_IORL);
    916. 

  916. 		if (ret == IPS_SUCCESS) {
    917. 

  917. 			IPS_PRINTK(KERN_NOTICE, ha->pcidev,
    918. 

  918. 				   "Reset Request - Flushed Cache\n");
    919. 

  919. 			return (SUCCESS);
    920. 

  920. 		}
    921. 

  921. 	}
    922. 

  922. 

  923. 	/* Either we can't communicate with the adapter or it's an IOCTL request */
    924. 

  924. 	/* from a utility.  A physical reset is needed at this point.            */
    925. 

  925. 

  926. 	ha->ioctl_reset = 0;	/* Reset the IOCTL Requested Reset Flag */
    927. 

  927. 

  928. 	/*
    929. 

  929. 	 * command must have already been sent
    930. 

  930. 	 * reset the controller
    931. 

  931. 	 */
    932. 

  932. 	IPS_PRINTK(KERN_NOTICE, ha->pcidev, "Resetting controller.\n");
    933. 

  933. 	ret = (*ha->func.reset) (ha);
    934. 

  934. 

  935. 	if (!ret) {
    936. 

  936. 		struct scsi_cmnd *scsi_cmd;
    937. 

  937. 

  938. 		IPS_PRINTK(KERN_NOTICE, ha->pcidev,
    939. 

  939. 			   "Controller reset failed - controller now offline.\n");
    940. 

  940. 

  941. 		/* Now fail all of the active commands */
    942. 

  942. 		DEBUG_VAR(1, "(%s%d) Failing active commands",
    943. 

  943. 			  ips_name, ha->host_num);
    944. 

  944. 

  945. 		while ((scb = ips_removeq_scb_head(&ha->scb_activelist))) {
    946. 

  946. 			scb->scsi_cmd->result = DID_ERROR << 16;
    947. 

  947. 			scb->scsi_cmd->scsi_done(scb->scsi_cmd);
    948. 

  948. 			ips_freescb(ha, scb);
    949. 

  949. 		}
    950. 

  950. 

  951. 		/* Now fail all of the pending commands */
    952. 

  952. 		DEBUG_VAR(1, "(%s%d) Failing pending commands",
    953. 

  953. 			  ips_name, ha->host_num);
    954. 

  954. 

  955. 		while ((scsi_cmd = ips_removeq_wait_head(&ha->scb_waitlist))) {
    956. 

  956. 			scsi_cmd->result = DID_ERROR;
    957. 

  957. 			scsi_cmd->scsi_done(scsi_cmd);
    958. 

  958. 		}
    959. 

  959. 

  960. 		ha->active = FALSE;
    961. 

  961. 		return (FAILED);
    962. 

  962. 	}
    963. 

  963. 

  964. 	if (!ips_clear_adapter(ha, IPS_INTR_IORL)) {
    965. 

  965. 		struct scsi_cmnd *scsi_cmd;
    966. 

  966. 

  967. 		IPS_PRINTK(KERN_NOTICE, ha->pcidev,
    968. 

  968. 			   "Controller reset failed - controller now offline.\n");
    969. 

  969. 

  970. 		/* Now fail all of the active commands */
    971. 

  971. 		DEBUG_VAR(1, "(%s%d) Failing active commands",
    972. 

  972. 			  ips_name, ha->host_num);
    973. 

  973. 

  974. 		while ((scb = ips_removeq_scb_head(&ha->scb_activelist))) {
    975. 

  975. 			scb->scsi_cmd->result = DID_ERROR << 16;
    976. 

  976. 			scb->scsi_cmd->scsi_done(scb->scsi_cmd);
    977. 

  977. 			ips_freescb(ha, scb);
    978. 

  978. 		}
    979. 

  979. 

  980. 		/* Now fail all of the pending commands */
    981. 

  981. 		DEBUG_VAR(1, "(%s%d) Failing pending commands",
    982. 

  982. 			  ips_name, ha->host_num);
    983. 

  983. 

  984. 		while ((scsi_cmd = ips_removeq_wait_head(&ha->scb_waitlist))) {
    985. 

  985. 			scsi_cmd->result = DID_ERROR << 16;
    986. 

  986. 			scsi_cmd->scsi_done(scsi_cmd);
    987. 

  987. 		}
    988. 

  988. 

  989. 		ha->active = FALSE;
    990. 

  990. 		return (FAILED);
    991. 

  991. 	}
    992. 

  992. 

  993. 	/* FFDC */
    994. 

  994. 	if (le32_to_cpu(ha->subsys->param[3]) & 0x300000) {
    995. 

  995. 		struct timeval tv;
    996. 

  996. 

  997. 		do_gettimeofday(&tv);
    998. 

  998. 		ha->last_ffdc = tv.tv_sec;
    999. 

  999. 		ha->reset_count++;
    1000. 

  1000. 		ips_ffdc_reset(ha, IPS_INTR_IORL);
    1001. 

  1001. 	}
    1002. 

  1002. 

  1003. 	/* Now fail all of the active commands */
    1004. 

  1004. 	DEBUG_VAR(1, "(%s%d) Failing active commands", ips_name, ha->host_num);
    1005. 

  1005. 

  1006. 	while ((scb = ips_removeq_scb_head(&ha->scb_activelist))) {
    1007. 

  1007. 		scb->scsi_cmd->result = DID_RESET << 16;
    1008. 

  1008. 		scb->scsi_cmd->scsi_done(scb->scsi_cmd);
    1009. 

  1009. 		ips_freescb(ha, scb);
    1010. 

  1010. 	}
    1011. 

  1011. 

  1012. 	/* Reset DCDB active command bits */
    1013. 

  1013. 	for (i = 1; i < ha->nbus; i++)
    1014. 

  1014. 		ha->dcdb_active[i - 1] = 0;
    1015. 

  1015. 

  1016. 	/* Reset the number of active IOCTLs */
    1017. 

  1017. 	ha->num_ioctl = 0;
    1018. 

  1018. 

  1019. 	ips_next(ha, IPS_INTR_IORL);
    1020. 

  1020. 

  1021. 	return (SUCCESS);
    1022. 

  1022. #endif				/* NO_IPS_RESET */
    1023. 

  1023. 

  1024. }
    1025. 

  1025. 

  1026. static int ips_eh_reset(struct scsi_cmnd *SC)
    1027. 

  1027. {
    1028. 

  1028. 	int rc;
    1029. 

  1029. 

  1030. 	spin_lock_irq(SC->device->host->host_lock);
    1031. 

  1031. 	rc = __ips_eh_reset(SC);
    1032. 

  1032. 	spin_unlock_irq(SC->device->host->host_lock);
    1033. 

  1033. 

  1034. 	return rc;
    1035. 

  1035. }
    1036. 

  1036. 

  1037. /****************************************************************************/
    1038. 

  1038. /*                                                                          */
    1039. 

  1039. /* Routine Name: ips_queue                                                  */
    1040. 

  1040. /*                                                                          */
    1041. 

  1041. /* Routine Description:                                                     */
    1042. 

  1042. /*                                                                          */
    1043. 

  1043. /*   Send a command to the controller                                       */
    1044. 

  1044. /*                                                                          */
    1045. 

  1045. /* NOTE:                                                                    */
    1046. 

  1046. /*    Linux obtains io_request_lock before calling this function            */
    1047. 

  1047. /*                                                                          */
    1048. 

  1048. /****************************************************************************/
    1049. 

  1049. static int ips_queue(struct scsi_cmnd *SC, void (*done) (struct scsi_cmnd *))
    1050. 

  1050. {
    1051. 

  1051. 	ips_ha_t *ha;
    1052. 

  1052. 	ips_passthru_t *pt;
    1053. 

  1053. 

  1054. 	METHOD_TRACE("ips_queue", 1);
    1055. 

  1055. 

  1056. 	ha = (ips_ha_t *) SC->device->host->hostdata;
    1057. 

  1057. 

  1058. 	if (!ha)
    1059. 

  1059. 		return (1);
    1060. 

  1060. 

  1061. 	if (!ha->active)
    1062. 

  1062. 		return (DID_ERROR);
    1063. 

  1063. 

  1064. 	if (ips_is_passthru(SC)) {
    1065. 

  1065. 		if (ha->copp_waitlist.count == IPS_MAX_IOCTL_QUEUE) {
    1066. 

  1066. 			SC->result = DID_BUS_BUSY << 16;
    1067. 

  1067. 			done(SC);
    1068. 

  1068. 

  1069. 			return (0);
    1070. 

  1070. 		}
    1071. 

  1071. 	} else if (ha->scb_waitlist.count == IPS_MAX_QUEUE) {
    1072. 

  1072. 		SC->result = DID_BUS_BUSY << 16;
    1073. 

  1073. 		done(SC);
    1074. 

  1074. 

  1075. 		return (0);
    1076. 

  1076. 	}
    1077. 

  1077. 

  1078. 	SC->scsi_done = done;
    1079. 

  1079. 

  1080. 	DEBUG_VAR(2, "(%s%d): ips_queue: cmd 0x%X (%d %d %d)",
    1081. 

  1081. 		  ips_name,
    1082. 

  1082. 		  ha->host_num,
    1083. 

  1083. 		  SC->cmnd[0],
    1084. 

  1084. 		  SC->device->channel, SC->device->id, SC->device->lun);
    1085. 

  1085. 

  1086. 	/* Check for command to initiator IDs */
    1087. 

  1087. 	if ((scmd_channel(SC) > 0)
    1088. 

  1088. 	    && (scmd_id(SC) == ha->ha_id[scmd_channel(SC)])) {
    1089. 

  1089. 		SC->result = DID_NO_CONNECT << 16;
    1090. 

  1090. 		done(SC);
    1091. 

  1091. 

  1092. 		return (0);
    1093. 

  1093. 	}
    1094. 

  1094. 

  1095. 	if (ips_is_passthru(SC)) {
    1096. 

  1096. 

  1097. 		ips_copp_wait_item_t *scratch;
    1098. 

  1098. 

  1099. 		/* A Reset IOCTL is only sent by the boot CD in extreme cases.           */
    1100. 

  1100. 		/* There can never be any system activity ( network or disk ), but check */
    1101. 

  1101. 		/* anyway just as a good practice.                                       */
    1102. 

  1102. 		pt = (ips_passthru_t *) scsi_sglist(SC);
    1103. 

  1103. 		if ((pt->CoppCP.cmd.reset.op_code == IPS_CMD_RESET_CHANNEL) &&
    1104. 

  1104. 		    (pt->CoppCP.cmd.reset.adapter_flag == 1)) {
    1105. 

  1105. 			if (ha->scb_activelist.count != 0) {
    1106. 

  1106. 				SC->result = DID_BUS_BUSY << 16;
    1107. 

  1107. 				done(SC);
    1108. 

  1108. 				return (0);
    1109. 

  1109. 			}
    1110. 

  1110. 			ha->ioctl_reset = 1;	/* This reset request is from an IOCTL */
    1111. 

  1111. 			__ips_eh_reset(SC);
    1112. 

  1112. 			SC->result = DID_OK << 16;
    1113. 

  1113. 			SC->scsi_done(SC);
    1114. 

  1114. 			return (0);
    1115. 

  1115. 		}
    1116. 

  1116. 

  1117. 		/* allocate space for the scribble */
    1118. 

  1118. 		scratch = kmalloc(sizeof (ips_copp_wait_item_t), GFP_ATOMIC);
    1119. 

  1119. 

  1120. 		if (!scratch) {
    1121. 

  1121. 			SC->result = DID_ERROR << 16;
    1122. 

  1122. 			done(SC);
    1123. 

  1123. 

  1124. 			return (0);
    1125. 

  1125. 		}
    1126. 

  1126. 

  1127. 		scratch->scsi_cmd = SC;
    1128. 

  1128. 		scratch->next = NULL;
    1129. 

  1129. 

  1130. 		ips_putq_copp_tail(&ha->copp_waitlist, scratch);
    1131. 

  1131. 	} else {
    1132. 

  1132. 		ips_putq_wait_tail(&ha->scb_waitlist, SC);
    1133. 

  1133. 	}
    1134. 

  1134. 

  1135. 	ips_next(ha, IPS_INTR_IORL);
    1136. 

  1136. 

  1137. 	return (0);
    1138. 

  1138. }
    1139. 

  1139. 

  1140. /****************************************************************************/
    1141. 

  1141. /*                                                                          */
    1142. 

  1142. /* Routine Name: ips_biosparam                                              */
    1143. 

  1143. /*                                                                          */
    1144. 

  1144. /* Routine Description:                                                     */
    1145. 

  1145. /*                                                                          */
    1146. 

  1146. /*   Set bios geometry for the controller                                   */
    1147. 

  1147. /*                                                                          */
    1148. 

  1148. /****************************************************************************/
    1149. 

  1149. static int ips_biosparam(struct scsi_device *sdev, struct block_device *bdev,
    1150. 

  1150. 			 sector_t capacity, int geom[])
    1151. 

  1151. {
    1152. 

  1152. 	ips_ha_t *ha = (ips_ha_t *) sdev->host->hostdata;
    1153. 

  1153. 	int heads;
    1154. 

  1154. 	int sectors;
    1155. 

  1155. 	int cylinders;
    1156. 

  1156. 

  1157. 	METHOD_TRACE("ips_biosparam", 1);
    1158. 

  1158. 

  1159. 	if (!ha)
    1160. 

  1160. 		/* ?!?! host adater info invalid */
    1161. 

  1161. 		return (0);
    1162. 

  1162. 

  1163. 	if (!ha->active)
    1164. 

  1164. 		return (0);
    1165. 

  1165. 

  1166. 	if (!ips_read_adapter_status(ha, IPS_INTR_ON))
    1167. 

  1167. 		/* ?!?! Enquiry command failed */
    1168. 

  1168. 		return (0);
    1169. 

  1169. 

  1170. 	if ((capacity > 0x400000) && ((ha->enq->ucMiscFlag & 0x8) == 0)) {
    1171. 

  1171. 		heads = IPS_NORM_HEADS;
    1172. 

  1172. 		sectors = IPS_NORM_SECTORS;
    1173. 

  1173. 	} else {
    1174. 

  1174. 		heads = IPS_COMP_HEADS;
    1175. 

  1175. 		sectors = IPS_COMP_SECTORS;
    1176. 

  1176. 	}
    1177. 

  1177. 

  1178. 	cylinders = (unsigned long) capacity / (heads * sectors);
    1179. 

  1179. 

  1180. 	DEBUG_VAR(2, "Geometry: heads: %d, sectors: %d, cylinders: %d",
    1181. 

  1181. 		  heads, sectors, cylinders);
    1182. 

  1182. 

  1183. 	geom[0] = heads;
    1184. 

  1184. 	geom[1] = sectors;
    1185. 

  1185. 	geom[2] = cylinders;
    1186. 

  1186. 

  1187. 	return (0);
    1188. 

  1188. }
    1189. 

  1189. 

  1190. /****************************************************************************/
    1191. 

  1191. /*                                                                          */
    1192. 

  1192. /* Routine Name: ips_slave_configure                                        */
    1193. 

  1193. /*                                                                          */
    1194. 

  1194. /* Routine Description:                                                     */
    1195. 

  1195. /*                                                                          */
    1196. 

  1196. /*   Set queue depths on devices once scan is complete                      */
    1197. 

  1197. /*                                                                          */
    1198. 

  1198. /****************************************************************************/
    1199. 

  1199. static int
    1200. 

  1200. ips_slave_configure(struct scsi_device * SDptr)
    1201. 

  1201. {
    1202. 

  1202. 	ips_ha_t *ha;
    1203. 

  1203. 	int min;
    1204. 

  1204. 

  1205. 	ha = IPS_HA(SDptr->host);
    1206. 

  1206. 	if (SDptr->tagged_supported && SDptr->type == TYPE_DISK) {
    1207. 

  1207. 		min = ha->max_cmds / 2;
    1208. 

  1208. 		if (ha->enq->ucLogDriveCount <= 2)
    1209. 

  1209. 			min = ha->max_cmds - 1;
    1210. 

  1210. 		scsi_adjust_queue_depth(SDptr, MSG_ORDERED_TAG, min);
    1211. 

  1211. 	}
    1212. 

  1212. 

  1213. 	SDptr->skip_ms_page_8 = 1;
    1214. 

  1214. 	SDptr->skip_ms_page_3f = 1;
    1215. 

  1215. 	return 0;
    1216. 

  1216. }
    1217. 

  1217. 

  1218. /****************************************************************************/
    1219. 

  1219. /*                                                                          */
    1220. 

  1220. /* Routine Name: do_ipsintr                                                 */
    1221. 

  1221. /*                                                                          */
    1222. 

  1222. /* Routine Description:                                                     */
    1223. 

  1223. /*                                                                          */
    1224. 

  1224. /*   Wrapper for the interrupt handler                                      */
    1225. 

  1225. /*                                                                          */
    1226. 

  1226. /****************************************************************************/
    1227. 

  1227. static irqreturn_t
    1228. 

  1228. do_ipsintr(int irq, void *dev_id)
    1229. 

  1229. {
    1230. 

  1230. 	ips_ha_t *ha;
    1231. 

  1231. 	struct Scsi_Host *host;
    1232. 

  1232. 	int irqstatus;
    1233. 

  1233. 

  1234. 	METHOD_TRACE("do_ipsintr", 2);
    1235. 

  1235. 

  1236. 	ha = (ips_ha_t *) dev_id;
    1237. 

  1237. 	if (!ha)
    1238. 

  1238. 		return IRQ_NONE;
    1239. 

  1239. 	host = ips_sh[ha->host_num];
    1240. 

  1240. 	/* interrupt during initialization */
    1241. 

  1241. 	if (!host) {
    1242. 

  1242. 		(*ha->func.intr) (ha);
    1243. 

  1243. 		return IRQ_HANDLED;
    1244. 

  1244. 	}
    1245. 

  1245. 

  1246. 	spin_lock(host->host_lock);
    1247. 

  1247. 

  1248. 	if (!ha->active) {
    1249. 

  1249. 		spin_unlock(host->host_lock);
    1250. 

  1250. 		return IRQ_HANDLED;
    1251. 

  1251. 	}
    1252. 

  1252. 

  1253. 	irqstatus = (*ha->func.intr) (ha);
    1254. 

  1254. 

  1255. 	spin_unlock(host->host_lock);
    1256. 

  1256. 

  1257. 	/* start the next command */
    1258. 

  1258. 	ips_next(ha, IPS_INTR_ON);
    1259. 

  1259. 	return IRQ_RETVAL(irqstatus);
    1260. 

  1260. }
    1261. 

  1261. 

  1262. /****************************************************************************/
    1263. 

  1263. /*                                                                          */
    1264. 

  1264. /* Routine Name: ips_intr_copperhead                                        */
    1265. 

  1265. /*                                                                          */
    1266. 

  1266. /* Routine Description:                                                     */
    1267. 

  1267. /*                                                                          */
    1268. 

  1268. /*   Polling interrupt handler                                              */
    1269. 

  1269. /*                                                                          */
    1270. 

  1270. /*   ASSUMES interrupts are disabled                                        */
    1271. 

  1271. /*…
    1272.