drivers/scsi/ips.c

Name: Public Git Hosting - davej-history.git/blob - drivers/scsi/ips.c
Rating: 4.5 (3919 reviews)
 1 /*****************************************************************************/
 2 /* ips.c -- driver for the IBM ServeRAID controller */
 3 /* */
 4 /* Written By: Keith Mitchell, IBM Corporation */
 5 /* */
 6 /* Copyright (C) 1999 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 should be mailed to: */
 43 /* ipslinux@us.ibm.com */
 44 /* */
 45 /*****************************************************************************/
 46
 47 /*****************************************************************************/
 48 /* Change Log */
 49 /* */
 50 /* 0.99.02 - Breakup commands that are bigger than 8 * the stripe size */
 51 /* 0.99.03 - Make interrupt routine handle all completed request on the */
 52 /* adapter not just the first one */
 53 /* - Make sure passthru commands get woken up if we run out of */
 54 /* SCBs */
 55 /* - Send all of the commands on the queue at once rather than */
 56 /* one at a time since the card will support it. */
 57 /* 0.99.04 - Fix race condition in the passthru mechanism -- this required */
 58 /* the interface to the utilities to change */
 59 /* - Fix error recovery code */
 60 /* 0.99.05 - Fix an oops when we get certain passthru commands */
 61 /* 1.00.00 - Initial Public Release */
 62 /* Functionally equivalent to 0.99.05 */
 63 /* */
 64 /*****************************************************************************/
 65
 66 /*
 67  * Conditional Compilation directives for this driver:
 68  *
 69  * NO_IPS_RESET - Don't reset the controller (no matter what)
 70  * IPS_DEBUG - More verbose error messages
 71  * IPS_PCI_PROBE_DEBUG - Print out more detail on the PCI probe
 72  *
 73  */
 74
 75 #if defined (MODULE)
 76 #include <linux/module.h>
 77 #endif/* MODULE */
 78
 79 #include <asm/io.h>
 80 #include <asm/byteorder.h>
 81 #include <linux/stddef.h>
 82 #include <linux/version.h>
 83 #include <linux/string.h>
 84 #include <linux/errno.h>
 85 #include <linux/kernel.h>
 86 #include <linux/ioport.h>
 87 #include <linux/malloc.h>
 88 #include <linux/delay.h>
 89 #include <linux/sched.h>
 90 #include <linux/pci.h>
 91 #include <linux/proc_fs.h>
 92
 93 #include <linux/blk.h>
 94 #include <linux/types.h>
 95
 96 #ifndef NO_IPS_CMDLINE
 97 #include <scsi/sg.h>
 98 #endif
 99
 100 #include"sd.h"
 101 #include"scsi.h"
 102 #include"hosts.h"
 103 #include"ips.h"
 104
 105 #include <linux/stat.h>
 106 #include <linux/config.h>
 107 #include <linux/spinlock.h>
 108 #include <linux/smp.h>
 109
 110 /*
 111  * DRIVER_VER
 112  */
 113 #define IPS_VERSION_HIGH"1.00"/* MUST be 4 chars */
 114 #define IPS_VERSION_LOW".00 "/* MUST be 4 chars */
 115
 116 struct proc_dir_entry proc_scsi_ips = {
 117 #if !defined(PROC_SCSI_IPS)
 118 0,/* Use dynamic inode allocation */
 119 #else
 120  PROC_SCSI_IPS,
 121 #endif
 122 3,"ips",
 123  S_IFDIR | S_IRUGO | S_IXUGO,2
 124 };
 125
 126 #if LINUX_VERSION_CODE < LinuxVersionCode(2,1,93)
 127 #include <linux/bios32.h>
 128 #endif
 129
 130 #if !defined(__i386__)
 131 #error"This driver has only been tested on the x86 platform"
 132 #endif
 133
 134 #if LINUX_VERSION_CODE < LinuxVersionCode(2,2,0)
 135 #error"This driver only works with kernel 2.2.0 and later"
 136 #endif
 137
 138 #if !defined(NO_IPS_CMDLINE) && ((SG_BIG_BUFF < 8192) || !defined(SG_BIG_BUFF))
 139 #error"To use the command-line interface you need to define SG_BIG_BUFF"
 140 #endif
 141
 142 #if IPS_DEBUG >= 12
 143 #define DBG(s) printk(KERN_NOTICE s"\n"); MDELAY(2*ONE_SEC)
 144 #elif IPS_DEBUG >= 11
 145 #define DBG(s) printk(KERN_NOTICE s"\n")
 146 #else
 147 #define DBG(s)
 148 #endif
 149
 150 /*
 151  * global variables
 152  */
 153 static const char* ips_name ="ips";
 154 static struct Scsi_Host * ips_sh[IPS_MAX_ADAPTERS];/* Array of host controller structures */
 155 static ips_ha_t * ips_ha[IPS_MAX_ADAPTERS];/* Array of HA structures */
 156 static unsigned int ips_num_controllers =0;
 157 static int ips_cmd_timeout =60;
 158 static int ips_reset_timeout =60*5;
 159
 160 #define MAX_ADAPTER_NAME 6
 161
 162 static char ips_adapter_name[][30] = {
 163 "ServeRAID",
 164 "ServeRAID II",
 165 "ServeRAID on motherboard",
 166 "ServeRAID on motherboard",
 167 "ServeRAID 3H",
 168 "ServeRAID 3L"
 169 };
 170
 171 /*
 172  * Function prototypes
 173  */
 174 intips_detect(Scsi_Host_Template *);
 175 intips_release(struct Scsi_Host *);
 176 intips_abort(Scsi_Cmnd *);
 177 intips_reset(Scsi_Cmnd *,unsigned int);
 178 intips_eh_abort(Scsi_Cmnd *);
 179 intips_eh_reset(Scsi_Cmnd *);
 180 intips_queue(Scsi_Cmnd *,void(*) (Scsi_Cmnd *));
 181 intips_biosparam(Disk *, kdev_t,int*);
 182 const char*ips_info(struct Scsi_Host *);
 183 voiddo_ipsintr(int,void*,struct pt_regs *);
 184 static intips_hainit(ips_ha_t *);
 185 static intips_map_status(ips_scb_t *, ips_stat_t *);
 186 static intips_send(ips_ha_t *, ips_scb_t *, scb_callback);
 187 static intips_send_wait(ips_ha_t *, ips_scb_t *,int);
 188 static intips_send_cmd(ips_ha_t *, ips_scb_t *);
 189 static intips_chkstatus(ips_ha_t *);
 190 static intips_online(ips_ha_t *, ips_scb_t *);
 191 static intips_inquiry(ips_ha_t *, ips_scb_t *);
 192 static intips_rdcap(ips_ha_t *, ips_scb_t *);
 193 static intips_msense(ips_ha_t *, ips_scb_t *);
 194 static intips_reqsen(ips_ha_t *, ips_scb_t *);
 195 static intips_allocatescbs(ips_ha_t *);
 196 static intips_reset_adapter(ips_ha_t *);
 197 static intips_statupd(ips_ha_t *);
 198 static intips_issue(ips_ha_t *, ips_scb_t *);
 199 static intips_isintr(ips_ha_t *);
 200 static intips_wait(ips_ha_t *,int,int);
 201 static intips_write_driver_status(ips_ha_t *);
 202 static intips_read_adapter_status(ips_ha_t *);
 203 static intips_read_subsystem_parameters(ips_ha_t *);
 204 static intips_read_config(ips_ha_t *);
 205 static intips_clear_adapter(ips_ha_t *);
 206 static intips_readwrite_page5(ips_ha_t *,int);
 207 static voidips_intr(ips_ha_t *);
 208 static voidips_next(ips_ha_t *);
 209 static voidipsintr_blocking(ips_ha_t *,struct ips_scb *);
 210 static voidipsintr_done(ips_ha_t *,struct ips_scb *);
 211 static voidips_done(ips_ha_t *, ips_scb_t *);
 212 static voidips_free(ips_ha_t *);
 213 static voidips_init_scb(ips_ha_t *, ips_scb_t *);
 214 static voidips_freescb(ips_ha_t *, ips_scb_t *);
 215 static voidips_statinit(ips_ha_t *);
 216 static ips_scb_t *ips_getscb(ips_ha_t *);
 217 staticinlinevoidips_putq_scb_head(ips_scb_queue_t *, ips_scb_t *);
 218 staticinlinevoidips_putq_scb_tail(ips_scb_queue_t *, ips_scb_t *);
 219 staticinline ips_scb_t *ips_removeq_scb_head(ips_scb_queue_t *);
 220 staticinline ips_scb_t *ips_removeq_scb(ips_scb_queue_t *, ips_scb_t *);
 221 staticinlinevoidips_putq_wait_head(ips_wait_queue_t *, Scsi_Cmnd *);
 222 staticinlinevoidips_putq_wait_tail(ips_wait_queue_t *, Scsi_Cmnd *);
 223 staticinline Scsi_Cmnd *ips_removeq_wait_head(ips_wait_queue_t *);
 224 staticinline Scsi_Cmnd *ips_removeq_wait(ips_wait_queue_t *, Scsi_Cmnd *);
 225
 226 #ifndef NO_IPS_CMDLINE
 227 static intips_is_passthru(Scsi_Cmnd *);
 228 static intips_make_passthru(ips_ha_t *, Scsi_Cmnd *, ips_scb_t *);
 229 static intips_usrcmd(ips_ha_t *, ips_passthru_t *, ips_scb_t *);
 230 #endif
 231
 232 intips_proc_info(char*,char**, off_t,int,int,int);
 233 static intips_host_info(ips_ha_t *,char*, off_t,int);
 234 static voidcopy_mem_info(INFOSTR *,char*,int);
 235 static intcopy_info(INFOSTR *,char*, ...);
 236
 237 /*--------------------------------------------------------------------------*/
 238 /* Exported Functions */
 239 /*--------------------------------------------------------------------------*/
 240
 241 /****************************************************************************/
 242 /* */
 243 /* Routine Name: ips_detect */
 244 /* */
 245 /* Routine Description: */
 246 /* */
 247 /* Detect and initialize the driver */
 248 /* */
 249 /****************************************************************************/
 250 int
 251 ips_detect(Scsi_Host_Template *SHT) {
 252 struct Scsi_Host *sh;
 253  ips_ha_t *ha;
 254  u32 io_addr;
 255  u16 planer;
 256  u8 bus;
 257  u8 func;
 258  u8 irq;
 259 int index;
 260 struct pci_dev *dev = NULL;
 261
 262 DBG("ips_detect");
 263
 264  SHT->proc_info = ips_proc_info;
 265  SHT->proc_dir = &proc_scsi_ips;
 266
 267 #if defined(CONFIG_PCI)
 268
 269 /* initalize number of controllers */
 270  ips_num_controllers =0;
 271
 272 if(!pci_present())
 273 return(0);
 274
 275 for(index =0; index < IPS_MAX_ADAPTERS; index++) {
 276
 277 if(!(dev =pci_find_device(IPS_VENDORID, IPS_DEVICEID, dev)))
 278 break;
 279
 280 /* stuff that we get in dev */
 281  irq = dev->irq;
 282  bus = dev->bus->number;
 283  func = dev->devfn;
 284  io_addr = dev->resource[0].start;
 285
 286 /* get planer status */
 287 if(pci_read_config_word(dev,0x04, &planer)) {
 288 printk(KERN_WARNING "(%s%d) can't get planer status.\n",
 289  ips_name, index);
 290
 291 continue;
 292 }
 293
 294 /* check I/O address */
 295 if((dev->resource[0].flags & PCI_BASE_ADDRESS_SPACE) != PCI_BASE_ADDRESS_SPACE_IO)
 296 continue;
 297
 298 /* check to see if an onboard planer controller is disabled */
 299 if(!(planer &0x000C)) {
 300
 301 #ifdef IPS_PCI_PROBE_DEBUG
 302 printk(KERN_NOTICE "(%s%d) detect, Onboard ServeRAID disabled by BIOS\n",
 303  ips_name, index);
 304 #endif
 305
 306 continue;
 307 }
 308
 309 #ifdef IPS_PCI_PROBE_DEBUG
 310 printk(KERN_NOTICE "(%s%d) detect bus %d, func %x, irq %d, io %x\n",
 311  ips_name, index, bus, func, irq, io_addr);
 312 #endif
 313
 314 /* found a controller */
 315  sh =scsi_register(SHT,sizeof(ips_ha_t));
 316
 317 if(sh == NULL) {
 318 printk(KERN_WARNING "(%s%d) Unable to register controller with SCSI subsystem - skipping controller\n",
 319  ips_name, index);
 320
 321 continue;
 322 }
 323
 324  ha =HA(sh);
 325 memset(ha,0,sizeof(ips_ha_t));
 326
 327 /* Initialize spin lock */
 328 spin_lock_init(&ha->scb_lock);
 329 spin_lock_init(&ha->copp_lock);
 330
 331  ips_sh[ips_num_controllers] = sh;
 332  ips_ha[ips_num_controllers] = ha;
 333  ips_num_controllers++;
 334  ha->active =1;
 335
 336  ha->enq =kmalloc(sizeof(ENQCMD), GFP_KERNEL|GFP_DMA);
 337
 338 if(!ha->enq) {
 339 printk(KERN_WARNING "(%s%d) Unable to allocate host inquiry structure - skipping contoller\n",
 340  ips_name, index);
 341
 342  ha->active =0;
 343
 344 continue;
 345 }
 346
 347  ha->adapt =kmalloc(sizeof(ADAPTER_AREA), GFP_KERNEL|GFP_DMA);
 348
 349 if(!ha->adapt) {
 350 printk(KERN_WARNING "(%s%d) Unable to allocate host adapt structure - skipping controller\n",
 351  ips_name, index);
 352
 353  ha->active =0;
 354
 355 continue;
 356 }
 357
 358  ha->conf =kmalloc(sizeof(CONFCMD), GFP_KERNEL|GFP_DMA);
 359
 360 if(!ha->conf) {
 361 printk(KERN_WARNING "(%s%d) Unable to allocate host conf structure - skipping controller\n",
 362  ips_name, index);
 363
 364  ha->active =0;
 365
 366 continue;
 367 }
 368
 369  ha->nvram =kmalloc(sizeof(NVRAM_PAGE5), GFP_KERNEL|GFP_DMA);
 370
 371 if(!ha->nvram) {
 372 printk(KERN_WARNING "(%s%d) Unable to allocate host nvram structure - skipping controller\n",
 373  ips_name, index);
 374
 375  ha->active =0;
 376
 377 continue;
 378 }
 379
 380  ha->subsys =kmalloc(sizeof(SUBSYS_PARAM), GFP_KERNEL|GFP_DMA);
 381
 382 if(!ha->subsys) {
 383 printk(KERN_WARNING "(%s%d) Unable to allocate host subsystem structure - skipping controller\n",
 384  ips_name, index);
 385
 386  ha->active =0;
 387
 388 continue;
 389 }
 390
 391  ha->dummy =kmalloc(sizeof(BASIC_IO_CMD), GFP_KERNEL|GFP_DMA);
 392
 393 if(!ha->dummy) {
 394 printk(KERN_WARNING "(%s%d) Unable to allocate host dummy structure - skipping controller\n",
 395  ips_name, index);
 396
 397  ha->active =0;
 398
 399 continue;
 400 }
 401
 402 /* Store away needed values for later use */
 403  sh->io_port = io_addr;
 404  sh->n_io_port =255;
 405  sh->unique_id = io_addr;
 406  sh->irq = irq;
 407  sh->select_queue_depths = NULL;
 408  sh->sg_tablesize = sh->hostt->sg_tablesize;
 409  sh->can_queue = sh->hostt->can_queue;
 410  sh->cmd_per_lun = sh->hostt->cmd_per_lun;
 411  sh->unchecked_isa_dma = sh->hostt->unchecked_isa_dma;
 412  sh->use_clustering = sh->hostt->use_clustering;
 413  sh->wish_block = FALSE;
 414
 415 /* Store info in HA structure */
 416  ha->io_addr = io_addr;
 417  ha->irq = irq;
 418  ha->host_num = index;
 419
 420 /* install the interrupt handler */
 421 if(request_irq(irq, do_ipsintr, SA_SHIRQ, ips_name, ha)) {
 422 printk(KERN_WARNING "(%s%d) unable to install interrupt handler - skipping controller\n",
 423  ips_name, index);
 424
 425  ha->active =0;
 426
 427 continue;
 428 }
 429
 430 /*
 431  * Allocate a temporary SCB for initialization
 432  */
 433  ha->scbs = (ips_scb_t *)kmalloc(sizeof(ips_scb_t), GFP_KERNEL|GFP_DMA);
 434 if(!ha->scbs) {
 435 /* couldn't allocate a temp SCB */
 436 printk(KERN_WARNING "(%s%d) unable to allocate CCBs - skipping contoller\n",
 437  ips_name, index);
 438
 439  ha->active =0;
 440
 441 continue;
 442 }
 443
 444 memset(ha->scbs,0,sizeof(ips_scb_t));
 445  ha->scbs->sg_list = (SG_LIST *)kmalloc(sizeof(SG_LIST) * MAX_SG_ELEMENTS, GFP_KERNEL|GFP_DMA);
 446 if(!ha->scbs->sg_list) {
 447 /* couldn't allocate a temp SCB S/G list */
 448 printk(KERN_WARNING "(%s%d) unable to allocate CCBs - skipping contoller\n",
 449  ips_name, index);
 450
 451  ha->active =0;
 452
 453 continue;
 454 }
 455
 456  ha->max_cmds =1;
 457
 458 if(!ips_hainit(ha)) {
 459 printk(KERN_WARNING "(%s%d) unable to initialize controller - skipping\n",
 460  ips_name, index);
 461
 462  ha->active =0;
 463
 464 continue;
 465 }
 466
 467 /*
 468  * Free the temporary SCB
 469  */
 470 kfree(ha->scbs->sg_list);
 471 kfree(ha->scbs);
 472  ha->scbs = NULL;
 473
 474 /* allocate CCBs */
 475 if(!ips_allocatescbs(ha)) {
 476 printk(KERN_WARNING "(%s%d) unable to allocate CCBs - skipping contoller\n",
 477  ips_name, index);
 478
 479  ha->active =0;
 480
 481 continue;
 482 }
 483
 484 /* finish setting values */
 485  sh->max_id = ha->ntargets;
 486  sh->max_lun = ha->nlun;
 487  sh->max_channel = ha->nbus;
 488  sh->can_queue = ha->max_cmds-1;
 489 }/* end for */
 490
 491 return(ips_num_controllers);
 492
 493 #else
 494
 495 /* No PCI -- No ServeRAID */
 496 return(0);
 497 #endif/* CONFIG_PCI */
 498 }
 499
 500 /****************************************************************************/
 501 /* */
 502 /* Routine Name: ips_release */
 503 /* */
 504 /* Routine Description: */
 505 /* */
 506 /* Remove a driver */
 507 /* */
 508 /****************************************************************************/
 509 int
 510 ips_release(struct Scsi_Host *sh) {
 511  ips_scb_t *scb;
 512  ips_ha_t *ha;
 513 int i;
 514
 515 DBG("ips_release");
 516
 517 for(i =0; i < IPS_MAX_ADAPTERS && ips_sh[i] != sh; i++);
 518
 519 if(i == IPS_MAX_ADAPTERS)
 520 panic("(%s) release, invalid Scsi_Host pointer.\n",
 521  ips_name);
 522
 523  ha =HA(sh);
 524
 525 if(!ha)
 526 return(FALSE);
 527
 528 /* flush the cache on the controller */
 529  scb = &ha->scbs[ha->max_cmds-1];
 530
 531 ips_init_scb(ha, scb);
 532
 533  scb->timeout = ips_cmd_timeout;
 534  scb->cdb[0] = FLUSH_CACHE;
 535
 536  scb->cmd.flush_cache.op_code = FLUSH_CACHE;
 537  scb->cmd.flush_cache.command_id =IPS_COMMAND_ID(ha, scb);
 538  scb->cmd.flush_cache.state = NORM_STATE;
 539  scb->cmd.flush_cache.reserved =0;
 540  scb->cmd.flush_cache.reserved2 =0;
 541  scb->cmd.flush_cache.reserved3 =0;
 542  scb->cmd.flush_cache.reserved4 =0;
 543
 544 printk("(%s%d) Flushing Cache.\n", ips_name, ha->host_num);
 545
 546 /* send command */
 547 if(ips_send_wait(ha, scb, ips_cmd_timeout) == IPS_FAILURE)
 548 printk("(%s%d) Incomplete Flush.\n", ips_name, ha->host_num);
 549
 550 printk("(%s%d) Flushing Complete.\n", ips_name, ha->host_num);
 551
 552  ips_sh[i] = NULL;
 553  ips_ha[i] = NULL;
 554
 555 /* free extra memory */
 556 ips_free(ha);
 557
 558 /* free IRQ */
 559 free_irq(ha->irq, ha);
 560
 561 /* unregister with SCSI sub system */
 562 scsi_unregister(sh);
 563
 564 return(FALSE);
 565 }
 566
 567 /****************************************************************************/
 568 /* */
 569 /* Routine Name: ips_eh_abort */
 570 /* */
 571 /* Routine Description: */
 572 /* */
 573 /* Abort a command (using the new error code stuff) */
 574 /* */
 575 /****************************************************************************/
 576 int
 577 ips_eh_abort(Scsi_Cmnd *SC) {
 578  ips_ha_t *ha;
 579
 580 DBG("ips_eh_abort");
 581
 582 if(!SC)
 583 return(FAILED);
 584
 585  ha = (ips_ha_t *) SC->host->hostdata;
 586
 587 if(!ha)
 588 return(FAILED);
 589
 590 if(!ha->active)
 591 return(FAILED);
 592
 593 if(SC->serial_number != SC->serial_number_at_timeout) {
 594 /* HMM, looks like a bogus command */
 595 #if IPS_DEBUG >= 1
 596 printk(KERN_NOTICE "Abort called with bogus scsi command\n");
 597 #endif
 598
 599 return(FAILED);
 600 }
 601
 602 if(test_and_set_bit(IPS_IN_ABORT, &ha->flags))
 603 return(FAILED);
 604
 605 /* See if the command is on the wait queue */
 606 if(ips_removeq_wait(&ha->scb_waitlist, SC) ||
 607 ips_removeq_wait(&ha->copp_waitlist, SC)) {
 608 /* command not sent yet */
 609 clear_bit(IPS_IN_ABORT, &ha->flags);
 610
 611 return(SUCCESS);
 612 }else{
 613 /* command must have already been sent */
 614 clear_bit(IPS_IN_ABORT, &ha->flags);
 615
 616 return(FAILED);
 617 }
 618 }
 619
 620 /****************************************************************************/
 621 /* */
 622 /* Routine Name: ips_abort */
 623 /* */
 624 /* Routine Description: */
 625 /* */
 626 /* Abort a command */
 627 /* */
 628 /****************************************************************************/
 629 int
 630 ips_abort(Scsi_Cmnd *SC) {
 631  ips_ha_t *ha;
 632
 633 DBG("ips_abort");
 634
 635 if(!SC)
 636 return(SCSI_ABORT_SNOOZE);
 637
 638  ha = (ips_ha_t *) SC->host->hostdata;
 639
 640 if(!ha)
 641 return(SCSI_ABORT_SNOOZE);
 642
 643 if(!ha->active)
 644 return(SCSI_ABORT_SNOOZE);
 645
 646 if(SC->serial_number != SC->serial_number_at_timeout) {
 647 /* HMM, looks like a bogus command */
 648 #if IPS_DEBUG >= 1
 649 printk(KERN_NOTICE "Abort called with bogus scsi command\n");
 650 #endif
 651
 652 return(SCSI_ABORT_NOT_RUNNING);
 653 }
 654
 655 if(test_and_set_bit(IPS_IN_ABORT, &ha->flags))
 656 return(SCSI_ABORT_SNOOZE);
 657
 658 /* See if the command is on the wait queue */
 659 if(ips_removeq_wait(&ha->scb_waitlist, SC) ||
 660 ips_removeq_wait(&ha->copp_waitlist, SC)) {
 661 /* command not sent yet */
 662 clear_bit(IPS_IN_ABORT, &ha->flags);
 663
 664 return(SCSI_ABORT_PENDING);
 665 }else{
 666 /* command must have already been sent */
 667 clear_bit(IPS_IN_ABORT, &ha->flags);
 668
 669 return(SCSI_ABORT_SNOOZE);
 670 }
 671 }
 672
 673 /****************************************************************************/
 674 /* */
 675 /* Routine Name: ips_eh_reset */
 676 /* */
 677 /* Routine Description: */
 678 /* */
 679 /* Reset the controller (with new eh error code) */
 680 /* */
 681 /****************************************************************************/
 682 int
 683 ips_eh_reset(Scsi_Cmnd *SC) {
 684  ips_ha_t *ha;
 685  ips_scb_t *scb;
 686
 687 DBG("ips_eh_reset");
 688
 689 #ifdef NO_IPS_RESET
 690 return(FAILED);
 691 #else
 692
 693 if(!SC) {
 694
 695 #if IPS_DEBUG >= 1
 696 printk(KERN_NOTICE "Reset called with NULL scsi command\n");
 697 #endif
 698
 699 return(FAILED);
 700 }
 701
 702  ha = (ips_ha_t *) SC->host->hostdata;
 703
 704 if(!ha) {
 705
 706 #if IPS_DEBUG >= 1
 707 printk(KERN_NOTICE "Reset called with NULL ha struct\n");
 708 #endif
 709
 710 return(FAILED);
 711 }
 712
 713 if(!ha->active)
 714 return(FAILED);
 715
 716 if(test_and_set_bit(IPS_IN_RESET, &ha->flags))
 717 return(FAILED);
 718
 719 /* See if the command is on the waiting queue */
 720 if(ips_removeq_wait(&ha->scb_waitlist, SC) ||
 721 ips_removeq_wait(&ha->copp_waitlist, SC)) {
 722 /* command not sent yet */
 723 clear_bit(IPS_IN_ABORT, &ha->flags);
 724
 725 return(SUCCESS);
 726 }
 727
 728 /*
 729  * command must have already been sent
 730  * reset the controller
 731  */
 732 if(!ips_reset_adapter(ha)) {
 733 clear_bit(IPS_IN_RESET, &ha->flags);
 734
 735 return(FAILED);
 736 }
 737
 738 if(!ips_clear_adapter(ha)) {
 739 clear_bit(IPS_IN_RESET, &ha->flags);
 740
 741 return(FAILED);
 742 }
 743
 744 /* Now fail all of the active commands */
 745 #if IPS_DEBUG >= 1
 746 printk(KERN_WARNING "(%s%d) Failing active commands\n",
 747  ips_name, ha->host_num);
 748 #endif
 749 while((scb =ips_removeq_scb_head(&ha->scb_activelist))) {
 750  scb->scsi_cmd->result = DID_RESET <<16;
 751  scb->scsi_cmd->scsi_done(scb->scsi_cmd);
 752 ips_freescb(ha, scb);
 753 }
 754
 755 /* Reset the number of active IOCTLs */
 756  ha->num_ioctl =0;
 757
 758 clear_bit(IPS_IN_RESET, &ha->flags);
 759
 760 if(!test_bit(IPS_IN_INTR, &ha->flags)) {
 761 /*
 762  * Only execute the next command when
 763  * we are not being called from the
 764  * interrupt handler. The interrupt
 765  * handler wants to do this and since
 766  * interrupts are turned off here....
 767  */
 768 ips_next(ha);
 769 }
 770
 771 return(SUCCESS);
 772
 773 #endif/* NO_IPS_RESET */
 774
 775 }
 776
 777 /****************************************************************************/
 778 /* */
 779 /* Routine Name: ips_reset */
 780 /* */
 781 /* Routine Description: */
 782 /* */
 783 /* Reset the controller */
 784 /* */
 785 /****************************************************************************/
 786 int
 787 ips_reset(Scsi_Cmnd *SC,unsigned int flags) {
 788  ips_ha_t *ha;
 789  ips_scb_t *scb;
 790
 791 DBG("ips_reset");
 792
 793 #ifdef NO_IPS_RESET
 794 return(SCSI_RESET_SNOOZE);
 795 #else
 796
 797 if(!SC) {
 798
 799 #if IPS_DEBUG >= 1
 800 printk(KERN_NOTICE "Reset called with NULL scsi command\n");
 801 #endif
 802
 803 return(SCSI_RESET_SNOOZE);
 804 }
 805
 806  ha = (ips_ha_t *) SC->host->hostdata;
 807
 808 if(!ha) {
 809
 810 #if IPS_DEBUG >= 1
 811 printk(KERN_NOTICE "Reset called with NULL ha struct\n");
 812 #endif
 813
 814 return(SCSI_RESET_SNOOZE);
 815 }
 816
 817 if(!ha->active)
 818 return(SCSI_RESET_SNOOZE);
 819
 820 if(test_and_set_bit(IPS_IN_RESET, &ha->flags))
 821 return(SCSI_RESET_SNOOZE);
 822
 823 /* See if the command is on the waiting queue */
 824 if(ips_removeq_wait(&ha->scb_waitlist, SC) ||
 825 ips_removeq_wait(&ha->copp_waitlist, SC)) {
 826 /* command not sent yet */
 827 clear_bit(IPS_IN_ABORT, &ha->flags);
 828
 829 return(SCSI_RESET_SNOOZE);
 830 }
 831
 832 /* reset the controller */
 833 if(!ips_reset_adapter(ha)) {
 834 clear_bit(IPS_IN_RESET, &ha->flags);
 835
 836 return(SCSI_RESET_ERROR);
 837 }
 838
 839 if(!ips_clear_adapter(ha)) {
 840 clear_bit(IPS_IN_RESET, &ha->flags);
 841
 842 return(SCSI_RESET_ERROR);
 843 }
 844
 845 /* Now fail all of the active commands */
 846 #if IPS_DEBUG >= 1
 847 printk(KERN_WARNING "(%s%d) Failing active commands\n",
 848  ips_name, ha->host_num);
 849 #endif
 850 while((scb =ips_removeq_scb_head(&ha->scb_activelist))) {
 851  scb->scsi_cmd->result = DID_RESET <<16;
 852  scb->scsi_cmd->scsi_done(scb->scsi_cmd);
 853 ips_freescb(ha, scb);
 854 }
 855
 856 /* Reset the number of active IOCTLs */
 857  ha->num_ioctl =0;
 858
 859 clear_bit(IPS_IN_RESET, &ha->flags);
 860
 861 if(!test_bit(IPS_IN_INTR, &ha->flags)) {
 862 /*
 863  * Only execute the next command when
 864  * we are not being called from the
 865  * interrupt handler. The interrupt
 866  * handler wants to do this and since
 867  * interrupts are turned off here....
 868  */
 869 ips_next(ha);
 870 }
 871
 872 return(SCSI_RESET_SUCCESS);
 873
 874 #endif/* NO_IPS_RESET */
 875
 876 }
 877
 878 /****************************************************************************/
 879 /* */
 880 /* Routine Name: ips_queue */
 881 /* */
 882 /* Routine Description: */
 883 /* */
 884 /* Send a command to the controller */
 885 /* */
 886 /****************************************************************************/
 887 int
 888 ips_queue(Scsi_Cmnd *SC,void(*done) (Scsi_Cmnd *)) {
 889  ips_ha_t *ha;
 890
 891 DBG("ips_queue");
 892
 893  ha = (ips_ha_t *) SC->host->hostdata;
 894
 895 if(!ha)
 896 return(1);
 897
 898 if(!ha->active)
 899 return(1);
 900
 901 #ifndef NO_IPS_CMDLINE
 902 if(ips_is_passthru(SC)) {
 903 if(ha->copp_waitlist.count == IPS_MAX_IOCTL_QUEUE) {
 904  SC->result = DID_BUS_BUSY <<16;
 905 done(SC);
 906
 907 return(0);
 908 }
 909 }else{
 910 #endif
 911 if(ha->scb_waitlist.count == IPS_MAX_QUEUE) {
 912  SC->result = DID_BUS_BUSY <<16;
 913 done(SC);
 914
 915 return(0);
 916 }
 917
 918 #ifndef NO_IPS_CMDLINE
 919 }
 920 #endif
 921
 922  SC->scsi_done = done;
 923
 924 #if IPS_DEBUG >= 10
 925 printk(KERN_NOTICE "%s: ips_queue: cmd 0x%X (%d %d %d)\n",
 926  ips_name,
 927  SC->cmnd[0],
 928  SC->channel,
 929  SC->target,
 930  SC->lun);
 931 #if IPS_DEBUG >= 11
 932 MDELAY(2*ONE_SEC);
 933 #endif
 934 #endif
 935
 936 #ifndef NO_IPS_CMDLINE
 937 if(ips_is_passthru(SC))
 938 ips_putq_wait_tail(&ha->copp_waitlist, SC);
 939 else
 940 #endif
 941 ips_putq_wait_tail(&ha->scb_waitlist, SC);
 942
 943 if((!test_bit(IPS_IN_INTR, &ha->flags)) &&
 944 (!test_bit(IPS_IN_ABORT, &ha->flags)) &&
 945 (!test_bit(IPS_IN_RESET, &ha->flags)))
 946 ips_next(ha);
 947
 948 return(0);
 949 }
 950
 951 /****************************************************************************/
 952 /* */
 953 /* Routine Name: ips_biosparam */
 954 /* */
 955 /* Routine Description: */
 956 /* */
 957 /* Set bios geometry for the controller */
 958 /* */
 959 /****************************************************************************/
 960 int
 961 ips_biosparam(Disk *disk, kdev_t dev,int geom[]) {
 962  ips_ha_t *ha;
 963 int heads;
 964 int sectors;
 965 int cylinders;
 966
 967 DBG("ips_biosparam");
 968
 969  ha = (ips_ha_t *) disk->device->host->hostdata;
 970
 971 if(!ha)
 972 /* ?!?! host adater info invalid */
 973 return(0);
 974
 975 if(!ha->active)
 976 return(0);
 977
 978 if(!ips_read_adapter_status(ha))
 979 /* ?!?! Enquiry command failed */
 980 return(0);
 981
 982 if((disk->capacity >0x400000) &&
 983 ((ha->enq->ucMiscFlag &0x8) ==0)) {
 984  heads = NORM_MODE_HEADS;
 985  sectors = NORM_MODE_SECTORS;
 986 }else{
 987  heads = COMP_MODE_HEADS;
 988  sectors = COMP_MODE_SECTORS;
 989 }
 990
 991  cylinders = disk->capacity / (heads * sectors);
 992
 993 #if IPS_DEBUG >= 2
 994 printk(KERN_NOTICE "Geometry: heads: %d, sectors: %d, cylinders: %d\n",
 995  heads, sectors, cylinders);
 996 #endif
 997
 998  geom[0] = heads;
 999  geom[1] = sectors;
1000  geom[2] = cylinders;
1001
1002 return(0);
1003 }
1004
1005 /****************************************************************************/
1006 /* */
1007 /* Routine Name: do_ipsintr */
1008 /* */
1009 /* Routine Description: */
1010 /* */
1011 /* Wrapper for the interrupt handler */
1012 /* */
1013 /****************************************************************************/
1014 void
1015 do_ipsintr(int irq,void*dev_id,struct pt_regs *regs) {
1016  ips_ha_t *ha;
1017 unsigned int cpu_flags;
1018
1019 DBG("do_ipsintr");
1020
1021  ha = (ips_ha_t *) dev_id;
1022
1023 spin_lock_irqsave(&io_request_lock, cpu_flags);
1024
1025 if(test_and_set_bit(IPS_IN_INTR, &ha->flags)) {
1026 spin_unlock_irqrestore(&io_request_lock, cpu_flags);
1027
1028 return;
1029 }
1030
1031 if(!ha) {
1032 clear_bit(IPS_IN_INTR, &ha->flags);
1033 spin_unlock_irqrestore(&io_request_lock, cpu_flags);
1034
1035 return;
1036 }
1037
1038 if(!ha->active) {
1039 clear_bit(IPS_IN_INTR, &ha->flags);
1040 spin_unlock_irqrestore(&io_request_lock, cpu_flags);
1041
1042 return;
1043 }
1044
1045 ips_intr(ha);
1046
1047 clear_bit(IPS_IN_INTR, &ha->flags);
1048
1049 spin_unlock_irqrestore(&io_request_lock, cpu_flags);
1050 }
1051
1052 /****************************************************************************/
1053 /* */
1054 /* Routine Name: ips_intr */
1055 /* */
1056 /* Routine Description: */
1057 /* */
1058 /* Polling interrupt handler */
1059 /* */
1060 /* ASSUMES interrupts are disabled */
1061 /* */
1062 /****************************************************************************/
1063 void
1064 ips_intr(ips_ha_t *ha) {
1065  ips_stat_t *sp;
1066  ips_scb_t *scb;
1067 int status;
1068
1069 DBG("ips_intr");
1070
1071 if(!ha)
1072 return;
1073
1074 if(!ha->active)
1075 return;
1076
1077 while(ips_isintr(ha)) {
1078  sp = &ha->sp;
1079
1080 if((status =ips_chkstatus(ha)) <0) {
1081 /* unexpected interrupt - no ccb */
1082 printk(KERN_WARNING "(%s%d) Spurious interrupt; no ccb.\n",
1083  ips_name, ha->host_num);
1084 continue;
1085 }
1086
1087  scb = (ips_scb_t *) sp->scb_addr;
1088
1089 /*
1090  * use the callback function to finish things up
1091  * NOTE: interrupts are OFF for this
1092  */
1093 (*scb->callback) (ha, scb);
1094 }
1095
1096 clear_bit(IPS_IN_INTR, &ha->flags);
1097 }
1098
1099 /****************************************************************************/
1100 /* */
1101 /* Routine Name: ips_info */
1102 /* */
1103 /* Routine Description: */
1104 /* */
1105 /* Return info about the driver */
1106 /* */
1107 /****************************************************************************/
1108 const char*
1109 ips_info(struct Scsi_Host *SH) {
1110 static char buffer[256];
1111 char*bp;
1112  ips_ha_t *ha;
1113
1114 DBG("ips_info");
1115
1116  ha =HA(SH);
1117
1118 if(!ha)
1119 return(NULL);
1120
1121  bp = &buffer[0];
1122 memset(bp,0,sizeof(buffer));
1123
1124 strcpy(bp,"IBM PCI ServeRAID ");
1125 strcat(bp, IPS_VERSION_HIGH);
1126 strcat(bp, IPS_VERSION_LOW);
1127
1128 if(ha->ad_type >0&&
1129  ha->ad_type <= MAX_ADAPTER_NAME) {
1130 strcat(bp," <");
1131 strcat(bp, ips_adapter_name[ha->ad_type-1]);
1132 strcat(bp,">");
1133 }
1134
1135 return(bp);
1136 }
1137
1138 /****************************************************************************/
1139 /* */
1140 /* Routine Name: ips_proc_info */
1141 /* */
1142 /* Routine Description: */
1143 /* */
1144 /* The passthru interface for the driver */
1145 /* */
1146 /****************************************************************************/
1147 int
1148 ips_proc_info(char*buffer,char**start, off_t offset,
1149 int length,int hostno,int func) {
1150 int i;
1151 int ret;
1152  ips_ha_t *ha = NULL;
1153
1154 DBG("ips_proc_info");
1155
1156 /* Find our host structure */
1157 for(i =0; i < ips_num_controllers; i++) {
1158 if(ips_sh[i] && ips_sh[i]->host_no == hostno) {
1159  ha = (ips_ha_t *) ips_sh[i]->hostdata;
1160
1161 break;
1162 }
1163 }
1164
1165 if(!ha)
1166 return(-EINVAL);
1167
1168 if(func) {
1169 /* write */
1170 return(0);
1171 }else{
1172 /* read */
1173 if(start)
1174 *start = buffer;
1175
1176  ret =ips_host_info(ha, buffer, offset, length);
1177
1178 return(ret);
1179 }
1180 }
1181
1182 /*--------------------------------------------------------------------------*/
1183 /* Helper Functions */
1184 /*--------------------------------------------------------------------------*/
1185
1186 #ifndef NO_IPS_CMDLINE
1187
1188 /****************************************************************************/
1189 /* */
1190 /* Routine Name: ips_is_passthru */
1191 /* */
1192 /* Routine Description: */
1193 /* */
1194 /* Determine if the specified SCSI command is really a passthru command */
1195 /* */
1196 /****************************************************************************/
1197 static int
1198 ips_is_passthru(Scsi_Cmnd *SC) {
1199 DBG("ips_is_passthru");
1200
1201 if(!SC)
1202 return(0);
1203
1204 if((SC->channel ==0) &&
1205 (SC->target == IPS_ADAPTER_ID) &&
1206 (SC->lun ==0) &&
1207 (SC->cmnd[0] ==0x0d) &&
1208 (SC->request_bufflen) &&
1209 (!SC->use_sg) &&
1210 (((char*) SC->request_buffer)[0] =='C') &&
1211 (((char*) SC->request_buffer)[1] =='O') &&
1212 (((char*) SC->request_buffer)[2] =='P') &&
1213 (((char*) SC->request_buffer)[3] =='P')) {
1214 return(1);
1215 }else{
1216 return(0);
1217 }
1218 }
1219
1220 /****************************************************************************/
1221 /* */
1222 /* Routine Name: ips_is_passthru */
1223 /* */
1224 /* Routine Description: */
1225 /* */
1226 /* Make a passthru command out of the info in the Scsi block */
1227 /* */
1228 /****************************************************************************/
1229 static int
1230 ips_make_passthru(ips_ha_t *ha, Scsi_Cmnd *SC, ips_scb_t *scb) {
1231  ips_passthru_t *pt;
1232
1233 DBG("ips_make_passthru");
1234
1235 if(!SC->request_bufflen || !SC->request_buffer) {
1236 /* no data */
1237 #if IPS_DEBUG_PT >= 1
1238 printk(KERN_NOTICE "(%s%d) No passthru structure\n",
1239  ips_name, ha->host_num);
1240 #endif
1241
1242 return(IPS_FAILURE);
1243 }
1244
1245 if(SC->request_bufflen <sizeof(ips_passthru_t)) {
1246 /* wrong size */
1247 #if IPS_DEBUG_PT >= 1
1248 printk(KERN_NOTICE "(%s%d) Passthru structure wrong size\n",
1249  ips_name, ha->host_num);
1250 #endif
1251
1252 return(IPS_FAILURE);
1253 }
1254
1255 if((((char*) SC->request_buffer)[0] !='C') ||
1256 (((char*) SC->request_buffer)[1] !='O') ||
1257 (((char*) SC->request_buffer)[2] !='P') ||
1258 (((char*) SC->request_buffer)[3] !='P')) {
1259 /* signature doesn't match */
1260 #if IPS_DEBUG_PT >= 1
1261 printk(KERN_NOTICE "(%s%d) Wrong signature on passthru structure.\n",
1262  ips_name, ha->host_num);
1263 #endif
1264
1265 return(IPS_FAILURE);
1266 }
1267
1268  pt = (ips_passthru_t *) SC->request_buffer;
1269  scb->scsi_cmd = SC;
1270
1271 if(SC->request_bufflen < (sizeof(ips_passthru_t) + pt->CmdBSize)) {
1272 /* wrong size */
1273 #if IPS_DEBUG_PT >= 1
1274 printk(KERN_NOTICE "(%s%d) Passthru structure wrong size\n",
1275  ips_name, ha->host_num);
1276 #endif
1277
1278 return(IPS_FAILURE);
1279 }
1280
1281 switch(pt->CoppCmd) {
1282 case IPS_NUMCTRLS:
1283 memcpy(SC->request_buffer +sizeof(ips_passthru_t),
1284 &ips_num_controllers,sizeof(int));
1285  SC->result = DID_OK <<16;
1286
1287 return(IPS_SUCCESS_IMM);
1288 case IPS_CTRLINFO:
1289 memcpy(SC->request_buffer +sizeof(ips_passthru_t),
1290  ha,sizeof(ips_ha_t));
1291  SC->result = DID_OK <<16;
1292
1293 return(IPS_SUCCESS_IMM);
1294 case COPPUSRCMD:
1295 if(ips_usrcmd(ha, pt, scb))
1296 return(IPS_SUCCESS);
1297 else
1298 return(IPS_FAILURE);
1299 break;
1300 }
1301
1302 return(IPS_FAILURE);
1303 }
1304
1305 /****************************************************************************/
1306 /* */
1307 /* Routine Name: ips_usrcmd */
1308 /* */
1309 /* Routine Description: */
1310 /* */
1311 /* Process a user command and make it ready to send */
1312 /* */
1313 /****************************************************************************/
1314 static int
1315 ips_usrcmd(ips_ha_t *ha, ips_passthru_t *pt, ips_scb_t *scb) {
1316  SG_LIST *sg_list;
1317
1318 DBG("ips_usrcmd");
1319
1320 if((!scb) || (!pt) || (!ha))
1321 return(0);
1322
1323 /* Save the S/G list pointer so it doesn't get clobbered */
1324  sg_list = scb->sg_list;
1325
1326 /* copy in the CP */
1327 memcpy(&scb->cmd, &pt->CoppCP.cmd,sizeof(IOCTL_INFO));
1328 memcpy(&scb->dcdb, &pt->CoppCP.dcdb,sizeof(DCDB_TABLE));
1329
1330 /* FIX stuff that might be wrong */
1331  scb->sg_list = sg_list;
1332  scb->scb_busaddr =VIRT_TO_BUS(scb);
1333  scb->bus =0;
1334  scb->target_id =0;
1335  scb->lun =0;
1336  scb->sg_len =0;
1337  scb->data_len =0;
1338  scb->flags =0;
1339  scb->op_code =0;
1340  scb->callback = ipsintr_done;
1341  scb->timeout = ips_cmd_timeout;
1342  scb->cmd.basic_io.command_id =IPS_COMMAND_ID(ha, scb);
1343
1344 /* we don't support DCDB/READ/WRITE Scatter Gather */
1345 if((scb->cmd.basic_io.op_code == READ_SCATTER_GATHER) ||
1346 (scb->cmd.basic_io.op_code == WRITE_SCATTER_GATHER) ||
1347 (scb->cmd.basic_io.op_code == DIRECT_CDB_SCATTER_GATHER))
1348 return(0);
1349
1350 if(pt->CmdBSize && pt->CmdBuffer) {
1351  scb->data_busaddr =VIRT_TO_BUS(scb->scsi_cmd->request_buffer +sizeof(ips_passthru_t));
1352 }else{
1353  scb->data_busaddr =0L;
1354 }
1355
1356 if(pt->CmdBSize) {
1357 if(scb->cmd.dcdb.op_code == DIRECT_CDB) {
1358  scb->cmd.dcdb.dcdb_address =VIRT_TO_BUS(&scb->dcdb);
1359  scb->dcdb.buffer_pointer = scb->data_busaddr;
1360 }else{
1361  scb->cmd.basic_io.sg_addr = scb->data_busaddr;
1362 }
1363 }
1364
1365 /* set timeouts */
1366 if(pt->TimeOut) {
1367  scb->timeout = pt->TimeOut;
1368
1369 if(pt->TimeOut <=10)
1370  scb->dcdb.cmd_attribute |= TIMEOUT_10;
1371 else if(pt->TimeOut <=60)
1372  scb->dcdb.cmd_attribute |= TIMEOUT_60;
1373 else
1374  scb->dcdb.cmd_attribute |= TIMEOUT_20M;
1375 }
1376
1377 /* assume error */
1378  scb->scsi_cmd->result = DID_ERROR <<16;
1379
1380 /* success */
1381 return(1);
1382 }
1383
1384 /****************************************************************************/
1385 /* */
1386 /* Routine Name: ips_cleanup_passthru */
1387 /* */
1388 /* Routine Description: */
1389 /* */
1390 /* Cleanup after a passthru command */
1391 /* */
1392 /****************************************************************************/
1393 static void
1394 ips_cleanup_passthru(ips_scb_t *scb) {
1395  ips_passthru_t *pt;
1396
1397 DBG("ips_cleanup_passthru");
1398
1399 if((!scb) || (!scb->scsi_cmd) || (!scb->scsi_cmd->request_buffer)) {
1400 #if IPS_DEBUG_PT >= 1
1401 printk(KERN_NOTICE "IPS couldn't cleanup\n");
1402 #endif
1403
1404 return;
1405 }
1406
1407  pt = (ips_passthru_t *) scb->scsi_cmd->request_buffer;
1408
1409 /* Copy data back to the user */
1410  pt->BasicStatus = scb->basic_status;
1411  pt->ExtendedStatus = scb->extended_status;
1412
1413  scb->scsi_cmd->result = DID_OK <<16;
1414 }
1415
1416 #endif
1417
1418 /****************************************************************************/
1419 /* */
1420 /* Routine Name: ips_host_info */
1421 /* */
1422 /* Routine Description: */
1423 /* */
1424 /* The passthru interface for the driver */
1425 /* */
1426 /****************************************************************************/
1427 static int
1428 ips_host_info(ips_ha_t *ha,char*ptr, off_t offset,int len) {
1429  INFOSTR info;
1430
1431 DBG("ips_host_info");
1432
1433  info.buffer = ptr;
1434  info.length = len;
1435  info.offset = offset;
1436  info.pos =0;
1437
1438 copy_info(&info,"\nIBM ServeRAID General Information:\n\n");
1439
1440 if((ha->nvram->signature == NVRAM_PAGE5_SIGNATURE) &&
1441 (ha->nvram->adapter_type !=0))
1442 copy_info(&info,"\tController Type : %s\n", ips_adapter_name[ha->ad_type-1]);
1443 else
1444 copy_info(&info,"\tController Type : Unknown\n");
1445
1446 copy_info(&info,"\tIO port address : 0x%lx\n", ha->io_addr);
1447 copy_info(&info,"\tIRQ number : %d\n", ha->irq);
1448
1449 if(ha->nvram->signature == NVRAM_PAGE5_SIGNATURE)
1450 copy_info(&info,"\tBIOS Version : %c%c%c%c%c%c%c%c\n",
1451  ha->nvram->bios_high[0], ha->nvram->bios_high[1],
1452  ha->nvram->bios_high[2], ha->nvram->bios_high[3],
1453  ha->nvram->bios_low[0], ha->nvram->bios_low[1],
1454  ha->nvram->bios_low[2], ha->nvram->bios_low[3]);
1455
1456 copy_info(&info,"\tFirmware Version : %c%c%c%c%c%c%c%c\n",
1457  ha->enq->CodeBlkVersion[0], ha->enq->CodeBlkVersion[1],
1458  ha->enq->CodeBlkVersion[2], ha->enq->CodeBlkVersion[3],
1459  ha->enq->CodeBlkVersion[4], ha->enq->CodeBlkVersion[5],
1460  ha->enq->CodeBlkVersion[6], ha->enq->CodeBlkVersion[7]);
1461
1462 copy_info(&info,"\tBoot Block Version : %c%c%c%c%c%c%c%c\n",
1463  ha->enq->BootBlkVersion[0], ha->enq->BootBlkVersion[1],
1464  ha->enq->BootBlkVersion[2], ha->enq->BootBlkVersion[3],
1465  ha->enq->BootBlkVersion[4], ha->enq->BootBlkVersion[5],
1466  ha->enq->BootBlkVersion[6], ha->enq->BootBlkVersion[7]);
1467
1468 copy_info(&info,"\tDriver Version : %s%s\n",
1469  IPS_VERSION_HIGH, IPS_VERSION_LOW);
1470
1471 copy_info(&info,"\tMax Physical Devices : %d\n",
1472  ha->enq->ucMaxPhysicalDevices);
1473 copy_info(&info,"\tMax Active Commands : %d\n",
1474  ha->max_cmds);
1475 copy_info(&info,"\tCurrent Queued Commands : %d\n",
1476  ha->scb_waitlist.count);
1477 copy_info(&info,"\tCurrent Active Commands : %d\n",
1478  ha->scb_activelist.count - ha->num_ioctl);
1479 copy_info(&info,"\tCurrent Queued PT Commands : %d\n",
1480  ha->copp_waitlist.count);
1481 copy_info(&info,"\tCurrent Active PT Commands : %d\n",
1482  ha->num_ioctl);
1483
1484 copy_info(&info,"\n");
1485
1486 return(info.pos > info.offset ? info.pos - info.offset :0);
1487 }
1488
1489 /****************************************************************************/
1490 /* */
1491 /* Routine Name: copy_mem_info */
1492 /* */
1493 /* Routine Description: */
1494 /* */
1495 /* Copy data into an INFOSTR structure */
1496 /* */
1497 /****************************************************************************/
1498 static void
1499 copy_mem_info(INFOSTR *info,char*data,int len) {
1500 DBG("copy_mem_info");
1501
1502 if(info->pos + len > info->length)
1503  len = info->length - info->pos;
1504
1505 if(info->pos + len < info->offset) {
1506  info->pos += len;
1507 return;
1508 }
1509
1510 if(info->pos < info->offset) {
1511  data += (info->offset - info->pos);
1512  len -= (info->offset - info->pos);
1513 }
1514
1515 if(len >0) {
1516 memcpy(info->buffer + info->pos, data, len);
1517  info->pos += len;
1518 }
1519 }
1520
1521 /****************************************************************************/
1522 /* */
1523 /* Routine Name: copy_info */
1524 /* */
1525 /* Routine Description: */
1526 /* */
1527 /* printf style wrapper for an info structure */
1528 /* */
1529 /****************************************************************************/
1530 static int
1531 copy_info(INFOSTR *info,char*fmt, ...) {
1532 va_list args;
1533 char buf[81];
1534 int len;
1535
1536 DBG("copy_info");
1537
1538 va_start(args, fmt);
1539  len =vsprintf(buf, fmt, args);
1540 va_end(args);
1541
1542 copy_mem_info(info, buf, len);
1543
1544 return(len);
1545 }
1546
1547 /****************************************************************************/
1548 /* */
1549 /* Routine Name: ips_hainit */
1550 /* */
1551 /* Routine Description: */
1552 /* */
1553 /* Initialize the controller */
1554 /* */
1555 /* NOTE: Assumes to be called from with a lock */
1556 /* */
1557 /****************************************************************************/
1558 static int
1559 ips_hainit(ips_ha_t *ha) {
1560 int i;
1561
1562 DBG("ips_hainit");
1563
1564 if(!ha)
1565 return(0);
1566
1567 /* initialize status queue */
1568 ips_statinit(ha);
1569
1570 /* Setup HBA ID's */
1571 if(!ips_read_config(ha)) {
1572
1573 #ifndef NO_IPS_RESET
1574
1575 /* Try to reset the controller and try again */
1576 if(!ips_reset_adapter(ha)) {
1577 printk(KERN_WARNING "(%s%d) unable to reset controller.\n",
1578  ips_name, ha->host_num);
1579
1580 return(0);
1581 }
1582
1583 if(!ips_clear_adapter(ha)) {
1584 printk(KERN_WARNING "(%s%d) unable to initialize controller.\n",
1585  ips_name, ha->host_num);
1586
1587 return(0);
1588 }
1589
1590 #endif
1591
1592 if(!ips_read_config(ha)) {
1593 printk(KERN_WARNING "(%s%d) unable to read config from controller.\n",
1594  ips_name, ha->host_num);
1595
1596 return(0);
1597 }
1598 }/* end if */
1599
1600 /* write driver version */
1601 if(!ips_write_driver_status(ha)) {
1602 printk(KERN_WARNING "(%s%d) unable to write driver info to controller.\n",
1603  ips_name, ha->host_num);
1604
1605 return(0);
1606 }
1607
1608 if(!ips_read_adapter_status(ha)) {
1609 printk(KERN_WARNING "(%s%d) unable to read controller status.\n",
1610  ips_name, ha->host_num);
1611
1612 return(0);
1613 }
1614
1615 if(!ips_read_subsystem_parameters(ha)) {
1616 printk(KERN_WARNING "(%s%d) unable to read subsystem parameters.\n",
1617  ips_name, ha->host_num);
1618
1619 return(0);
1620 }
1621
1622 /* set limits on SID, LUN, BUS */
1623  ha->ntargets = MAX_TARGETS +1;
1624  ha->nlun =1;
1625  ha->nbus = (ha->enq->ucMaxPhysicalDevices / MAX_TARGETS);
1626
1627 switch(ha->conf->logical_drive[0].ucStripeSize) {
1628 case4:
1629  ha->max_xfer =0x10000;
1630 break;
1631
1632 case5:
1633  ha->max_xfer =0x20000;
1634 break;
1635
1636 case6:
1637  ha->max_xfer =0x40000;
1638 break;
1639
1640 case7:
1641 default:
1642  ha->max_xfer =0x80000;
1643 break;
1644 }
1645
1646 /* setup max concurrent commands */
1647 if(ha->subsys->param[4] &0x1) {
1648 /* Use the new method */
1649  ha->max_cmds = ha->enq->ucConcurrentCmdCount;
1650 }else{
1651 /* use the old method */
1652 switch(ha->conf->logical_drive[0].ucStripeSize) {
1653 case4:
1654  ha->max_cmds =32;
1655 break;
1656
1657 case5:
1658  ha->max_cmds =16;
1659 break;
1660
1661 case6:
1662  ha->max_cmds =8;
1663 break;
1664
1665 case7:
1666 default:
1667  ha->max_cmds =4;
1668 break;
1669 }
1670 }
1671
1672 /* set controller IDs */
1673  ha->ha_id[0] = IPS_ADAPTER_ID;
1674 for(i =1; i < ha->nbus; i++)
1675  ha->ha_id[i] = ha->conf->init_id[i-1] &0x1f;
1676
1677 return(1);
1678 }
1679
1680 /****************************************************************************/
1681 /* */
1682 /* Routine Name: ips_next */
1683 /* */
1684 /* Routine Description: */
1685 /* */
1686 /* Take the next command off the queue and send it to the controller */
1687 /* */
1688 /* ASSUMED to be called from within a lock */
1689 /* */
1690 /****************************************************************************/
1691 static void
1692 ips_next(ips_ha_t *ha) {
1693  ips_scb_t *scb;
1694  Scsi_Cmnd *SC;
1695 int ret;
1696
1697 DBG("ips_next");
1698
1699 if(!ha)
1700 return;
1701
1702 #ifndef NO_IPS_CMDLINE
1703 /*
1704  * Send passthru commands
1705  * These have priority over normal I/O
1706  * but shouldn't affect performance too much
1707  * since we limit the number that can be active
1708  * on the card at any one time
1709  */
1710 while((ha->num_ioctl < IPS_MAX_IOCTL) &&
1711 (ha->copp_waitlist.head) &&
1712 (scb =ips_getscb(ha))) {
1713  SC =ips_removeq_wait_head(&ha->copp_waitlist);
1714
1715  ret =ips_make_passthru(ha, SC, scb);
1716
1717 switch(ret) {
1718 case IPS_FAILURE:
1719 if(scb->scsi_cmd) {
1720  scb->scsi_cmd->result = DID_ERROR <<16;
1721  scb->scsi_cmd->scsi_done(scb->scsi_cmd);
1722 }
1723 ips_freescb(ha, scb);
1724 break;
1725 case IPS_SUCCESS_IMM:
1726 if(scb->scsi_cmd)
1727  scb->scsi_cmd->scsi_done(scb->scsi_cmd);
1728 ips_freescb(ha, scb);
1729 break;
1730 default:
1731 break;
1732 }/* end case */
1733
1734 if(ret != IPS_SUCCESS)
1735 continue;
1736
1737  ret =ips_send_cmd(ha, scb);
1738
1739 if(ret == IPS_SUCCESS) {
1740 ips_putq_scb_head(&ha->scb_activelist, scb);
1741  ha->num_ioctl++;
1742 }
1743
1744 switch(ret) {
1745 case IPS_FAILURE:
1746 if(scb->scsi_cmd) {
1747  scb->scsi_cmd->result = DID_ERROR <<16;
1748  scb->scsi_cmd->scsi_done(scb->scsi_cmd);
1749 }
1750
1751 ips_freescb(ha, scb);
1752 break;
1753 case IPS_SUCCESS_IMM:
1754 if(scb->scsi_cmd)
1755  scb->scsi_cmd->scsi_done(scb->scsi_cmd);
1756 ips_freescb(ha, scb);
1757 break;
1758 default:
1759 break;
1760 }/* end case */
1761 }
1762 #endif
1763
1764 /*
1765  * Send "Normal" I/O commands
1766  */
1767 while((ha->scb_waitlist.head) &&
1768 (scb =ips_getscb(ha))) {
1769  SC =ips_removeq_wait_head(&ha->scb_waitlist);
1770
1771  SC->result = DID_OK;
1772  SC->host_scribble = NULL;
1773
1774 memset(SC->sense_buffer,0,sizeof(SC->sense_buffer));
1775
1776  scb->target_id = SC->target;
1777  scb->lun = SC->lun;
1778  scb->bus = SC->channel;
1779  scb->scsi_cmd = SC;
1780  scb->breakup =0;
1781  scb->data_len =0;
1782  scb->callback = ipsintr_done;
1783  scb->timeout = ips_cmd_timeout;
1784 memset(&scb->cmd,0,4);
1785
1786 /* copy in the CDB */
1787 memcpy(scb->cdb, SC->cmnd, SC->cmd_len);
1788
1789 /* Now handle the data buffer */
1790 if(SC->use_sg) {
1791 struct scatterlist *sg;
1792 int i;
1793
1794  sg = SC->request_buffer;
1795
1796 for(i =0; i < SC->use_sg; i++) {
1797  scb->sg_list[i].address =VIRT_TO_BUS(sg[i].address);
1798  scb->sg_list[i].length = sg[i].length;
1799
1800 if(scb->data_len + sg[i].length > ha->max_xfer) {
1801 /*
1802  * Data Breakup required
1803  */
1804  scb->breakup = i;
1805 break;
1806 }
1807
1808  scb->data_len += sg[i].length;
1809 }
1810
1811 if(!scb->breakup)
1812  scb->sg_len = SC->use_sg;
1813 else
1814  scb->sg_len = scb->breakup;
1815
1816  scb->dcdb.transfer_length = scb->data_len;
1817  scb->data_busaddr =VIRT_TO_BUS(scb->sg_list);
1818 }else{
1819 if(SC->request_bufflen) {
1820 if(SC->request_bufflen > ha->max_xfer) {
1821 /*
1822  * Data breakup required
1823  */
1824  scb->breakup =1;
1825  scb->data_len = ha->max_xfer;
1826 }else{
1827  scb->data_len = SC->request_bufflen;
1828 }
1829
1830  scb->dcdb.transfer_length = scb->data_len;
1831  scb->data_busaddr =VIRT_TO_BUS(SC->request_buffer);
1832  scb->sg_len =0;
1833 }else{
1834  scb->data_busaddr =0L;
1835  scb->sg_len =0;
1836  scb->data_len =0;
1837  scb->dcdb.transfer_length =0;
1838 }
1839
1840 }
1841
1842 if((scb->scsi_cmd->request.cmd == READ) && (SC->request_bufflen))
1843  scb->dcdb.cmd_attribute |= DATA_IN;
1844
1845 if((scb->scsi_cmd->request.cmd == WRITE) && (SC->request_bufflen))
1846  scb->dcdb.cmd_attribute |= DATA_OUT;
1847
1848 if(scb->data_len >= IPS_MAX_XFER) {
1849  scb->dcdb.cmd_attribute |= TRANSFER_64K;
1850  scb->dcdb.transfer_length =0;
1851 }
1852
1853  ret =ips_send_cmd(ha, scb);
1854
1855 if(ret == IPS_SUCCESS)
1856 ips_putq_scb_head(&ha->scb_activelist, scb);
1857
1858 switch(ret) {
1859 case IPS_FAILURE:
1860 if(scb->scsi_cmd) {
1861  scb->scsi_cmd->result = DID_ERROR <<16;
1862  scb->scsi_cmd->scsi_done(scb->scsi_cmd);
1863 }
1864
1865 ips_freescb(ha, scb);
1866 break;
1867 case IPS_SUCCESS_IMM:
1868 if(scb->scsi_cmd)
1869  scb->scsi_cmd->scsi_done(scb->scsi_cmd);
1870 ips_freescb(ha, scb);
1871 break;
1872 default:
1873 break;
1874 }/* end case */
1875 }/* end while */
1876 }
1877
1878 /****************************************************************************/
1879 /* */
1880 /* Routine Name: ips_putq_scb_head */
1881 /* */
1882 /* Routine Description: */
1883 /* */
1884 /* Add an item to the head of the queue */
1885 /* */
1886 /* ASSUMED to be called from within a lock */
1887 /* */
1888 /****************************************************************************/
1889 staticinlinevoid
1890 ips_putq_scb_head(ips_scb_queue_t *queue, ips_scb_t *item) {
1891 DBG("ips_putq_scb_head");
1892
1893 if(!item)
1894 return;
1895
1896  item->q_next = queue->head;
1897  queue->head = item;
1898
1899 if(!queue->tail)
1900  queue->tail = item;
1901
1902  queue->count++;
1903 }
1904
1905 /****************************************************************************/
1906 /* */
1907 /* Routine Name: ips_putq_scb_tail */
1908 /* */
1909 /* Routine Description: */
1910 /* */
1911 /* Add an item to the tail of the queue */
1912 /* */
1913 /* ASSUMED to be called from within a lock */
1914 /* */
1915 /****************************************************************************/
1916 staticinlinevoid
1917 ips_putq_scb_tail(ips_scb_queue_t *queue, ips_scb_t *item) {
1918 DBG("ips_putq_scb_tail");
1919
1920 if(!item)
1921 return;
1922
1923  item->q_next = NULL;
1924
1925 if(queue->tail)
1926  queue->tail->q_next = item;
1927
1928  queue->tail = item;
1929
1930 if(!queue->head)
1931  queue->head = item;
1932
1933  queue->count++;
1934 }
1935
1936 /****************************************************************************/
1937 /* */
1938 /* Routine Name: ips_removeq_scb_head */
1939 /* */
1940 /* Routine Description: */
1941 /* */
1942 /* Remove the head of the queue */
1943 /* */
1944 /* ASSUMED to be called from within a lock */
1945 /* */
1946 /****************************************************************************/
1947 staticinline ips_scb_t *
1948 ips_removeq_scb_head(ips_scb_queue_t *queue) {
1949  ips_scb_t *item;
1950
1951 DBG("ips_removeq_scb_head");
1952
1953  item = queue->head;
1954
1955 if(!item)
1956 return(NULL);
1957
1958  queue->head = item->q_next;
1959  item->q_next = NULL;
1960
1961 if(queue->tail == item)
1962  queue->tail = NULL;
1963
1964  queue->count--;
1965
1966 return(item);
1967 }
1968
1969 /****************************************************************************/
1970 /* */
1971 /* Routine Name: ips_removeq_scb */
1972 /* */
1973 /* Routine Description: */
1974 /* */
1975 /* Remove an item from a queue */
1976 /* */
1977 /* ASSUMED to be called from within a lock */
1978 /* */
1979 /****************************************************************************/
1980 staticinline ips_scb_t *
1981 ips_removeq_scb(ips_scb_queue_t *queue, ips_scb_t *item) {
1982  ips_scb_t *p;
1983
1984 DBG("ips_removeq_scb");
1985
1986 if(!item)
1987 return(NULL);
1988
1989 if(item == queue->head)
1990 return(ips_removeq_scb_head(queue));
1991
1992  p = queue->head;
1993
1994 while((p) && (item != p->q_next))
1995  p = p->q_next;
1996
1997 if(p) {
1998 /* found a match */
1999  p->q_next = item->q_next;
2000
2001 if(!item->q_next)
2002  queue->tail = p;
2003
2004  item->q_next = NULL;
2005  queue->count--;
2006
2007 return(item);
2008 }
2009
2010 return(NULL);
2011 }
2012
2013 /****************************************************************************/
2014 /* */
2015 /* Routine Name: ips_putq_wait_head */
2016 /* */
2017 /* Routine Description: */
2018 /* */
2019 /* Add an item to the head of the queue */
2020 /* */
2021 /* ASSUMED to be called from within a lock */
2022 /* */
2023 /****************************************************************************/
2024 staticinlinevoid
2025 ips_putq_wait_head(ips_wait_queue_t *queue, Scsi_Cmnd *item) {
2026 DBG("ips_putq_wait_head");
2027
2028 if(!item)
2029 return;
2030
2031  item->host_scribble = (char*) queue->head;
2032  queue->head = item;
2033
2034 if(!queue->tail)
2035  queue->tail = item;
2036
2037  queue->count++;
2038 }
2039
2040 /****************************************************************************/
2041 /* */
2042 /* Routine Name: ips_putq_wait_tail */
2043 /* */
2044 /* Routine Description: */
2045 /* */
2046 /* Add an item to the tail of the queue */
2047 /* */
2048 /* ASSUMED to be called from within a lock */
2049 /* */
2050 /****************************************************************************/
2051 staticinlinevoid
2052 ips_putq_wait_tail(ips_wait_queue_t *queue, Scsi_Cmnd *item) {
2053 DBG("ips_putq_wait_tail");
2054
2055 if(!item)
2056 return;
2057
2058  item->host_scribble = NULL;
2059
2060 if(queue->tail)
2061  queue->tail->host_scribble = (char*)item;
2062
2063  queue->tail = item;
2064
2065 if(!queue->head)
2066  queue->head = item;
2067
2068  queue->count++;
2069 }
2070
2071 /****************************************************************************/
2072 /* */
2073 /* Routine Name: ips_removeq_wait_head */
2074 /* */
2075 /* Routine Description: */
2076 /* */
2077 /* Remove the head of the queue */
2078 /* */
2079 /* ASSUMED to be called from within a lock */
2080 /* */
2081 /****************************************************************************/
2082 staticinline Scsi_Cmnd *
2083 ips_removeq_wait_head(ips_wait_queue_t *queue) {
2084  Scsi_Cmnd *item;
2085
2086 DBG("ips_removeq_wait_head");
2087
2088  item = queue->head;
2089
2090 if(!item)
2091 return(NULL);
2092
2093  queue->head = (Scsi_Cmnd *) item->host_scribble;
2094  item->host_scribble = NULL;
2095
2096 if(queue->tail == item)
2097  queue->tail = NULL;
2098
2099  queue->count--;
2100
2101 return(item);
2102 }
2103
2104 /****************************************************************************/
2105 /* */
2106 /* Routine Name: ips_removeq_wait */
2107 /* */
2108 /* Routine Description: */
2109 /* */
2110 /* Remove an item from a queue */
2111 /* */
2112 /* ASSUMED to be called from within a lock */
2113 /* */
2114 /****************************************************************************/
2115 staticinline Scsi_Cmnd *
2116 ips_removeq_wait(ips_wait_queue_t *queue, Scsi_Cmnd *item) {
2117  Scsi_Cmnd *p;
2118
2119 DBG("ips_removeq_wait");
2120
2121 if(!item)
2122 return(NULL);
2123
2124 if(item == queue->head)
2125 return(ips_removeq_wait_head(queue));
2126
2127  p = queue->head;
2128
2129 while((p) && (item != (Scsi_Cmnd *) p->host_scribble))
2130  p = (Scsi_Cmnd *) p->host_scribble;
2131
2132 if(p) {
2133 /* found a match */
2134  p->host_scribble = item->host_scribble;
2135
2136 if(!item->host_scribble)
2137  queue->tail = p;
2138
2139  item->host_scribble = NULL;
2140  queue->count--;
2141
2142 return(item);
2143 }
2144
2145 return(NULL);
2146 }
2147
2148 /****************************************************************************/
2149 /* */
2150 /* Routine Name: ipsintr_blocking */
2151 /* */
2152 /* Routine Description: */
2153 /* */
2154 /* Finalize an interrupt for internal commands */
2155 /* */
2156 /****************************************************************************/
2157 static void
2158 ipsintr_blocking(ips_ha_t *ha, ips_scb_t *scb) {
2159 DBG("ipsintr_blocking");
2160
2161 if((ha->waitflag == TRUE) &&
2162 (ha->cmd_in_progress == scb->cdb[0])) {
2163  ha->waitflag = FALSE;
2164
2165 return;
2166 }
2167 }
2168
2169 /****************************************************************************/
2170 /* */
2171 /* Routine Name: ipsintr_done */
2172 /* */
2173 /* Routine Description: */
2174 /* */
2175 /* Finalize an interrupt for non-internal commands */
2176 /* */
2177 /****************************************************************************/
2178 static void
2179 ipsintr_done(ips_ha_t *ha, ips_scb_t *scb) {
2180 DBG("ipsintr_done");
2181
2182 if(scb->scsi_cmd == NULL) {
2183 /* unexpected interrupt */
2184 printk(KERN_WARNING "(%s%d) Spurious interrupt; scsi_cmd not set.\n",
2185  ips_name, ha->host_num);
2186
2187 return;
2188 }
2189
2190 ips_done(ha, scb);
2191 }
2192
2193 /****************************************************************************/
2194 /* */
2195 /* Routine Name: ips_done */
2196 /* */
2197 /* Routine Description: */
2198 /* */
2199 /* Do housekeeping on completed commands */
2200 /* */
2201 /****************************************************************************/
2202 static void
2203 ips_done(ips_ha_t *ha, ips_scb_t *scb) {
2204 int ret;
2205
2206 DBG("ips_done");
2207
2208 if(!scb)
2209 return;
2210
2211 #ifndef NO_IPS_CMDLINE
2212 if((scb->scsi_cmd) && (ips_is_passthru(scb->scsi_cmd))) {
2213 ips_cleanup_passthru(scb);
2214  ha->num_ioctl--;
2215 }else{
2216 #endif
2217 /*
2218  * Check to see if this command had too much
2219  * data and had to be broke up. If so, queue
2220  * the rest of the data and continue.
2221  */
2222 if(scb->breakup) {
2223 /* we had a data breakup */
2224  u16 bk_save;
2225
2226  bk_save = scb->breakup;
2227  scb->breakup =0;
2228
2229 if(scb->scsi_cmd->use_sg) {
2230 /* S/G request */
2231 struct scatterlist *sg;
2232 int i;
2233
2234  sg = scb->scsi_cmd->request_buffer;
2235
2236  scb->data_len =0;
2237
2238 for(i = bk_save; i < scb->scsi_cmd->use_sg; i++) {
2239  scb->sg_list[i - bk_save].address =VIRT_TO_BUS(sg[i].address);
2240  scb->sg_list[i - bk_save].length = sg[i].length;
2241
2242 if(scb->data_len + sg[i].length > ha->max_xfer) {
2243 /*
2244  * Data Breakup required
2245  */
2246  scb->breakup = i;
2247 break;
2248 }
2249
2250  scb->data_len += sg[i].length;
2251 }
2252
2253 if(!scb->breakup)
2254  scb->sg_len = scb->scsi_cmd->use_sg - bk_save;
2255 else
2256  scb->sg_len = scb->breakup - bk_save;
2257
2258  scb->dcdb.transfer_length = scb->data_len;
2259  scb->data_busaddr =VIRT_TO_BUS(scb->sg_list);
2260 }else{
2261 /* Non S/G Request */
2262 if(scb->scsi_cmd->request_bufflen - (bk_save * ha->max_xfer)) {
2263 /* Further breakup required */
2264  scb->data_len = ha->max_xfer;
2265  scb->data_busaddr =VIRT_TO_BUS(scb->scsi_cmd->request_buffer + (bk_save * ha->max_xfer));
2266  scb->breakup = bk_save +1;
2267 }else{
2268  scb->data_len = scb->scsi_cmd->request_bufflen - (bk_save * ha->max_xfer);
2269  scb->data_busaddr =VIRT_TO_BUS(scb->scsi_cmd->request_buffer + (bk_save * ha->max_xfer));
2270 }
2271
2272  scb->dcdb.transfer_length = scb->data_len;
2273  scb->sg_len =0;
2274 }
2275
2276 if((scb->scsi_cmd->request.cmd == READ) && (scb->data_len))
2277  scb->dcdb.cmd_attribute |= DATA_IN;
2278
2279 if((scb->scsi_cmd->request.cmd == WRITE) && (scb->data_len))
2280  scb->dcdb.cmd_attribute |= DATA_OUT;
2281
2282 if(scb->data_len >= IPS_MAX_XFER) {
2283  scb->dcdb.cmd_attribute |= TRANSFER_64K;
2284  scb->dcdb.transfer_length =0;
2285 }
2286
2287  ret =ips_send_cmd(ha, scb);
2288
2289 switch(ret) {
2290 case IPS_FAILURE:
2291 if(scb->scsi_cmd) {
2292  scb->scsi_cmd->result = DID_ERROR <<16;
2293  scb->scsi_cmd->scsi_done(scb->scsi_cmd);
2294 }
2295
2296 ips_freescb(ha, scb);
2297 break;
2298 case IPS_SUCCESS_IMM:
2299 if(scb->scsi_cmd) {
2300  scb->scsi_cmd->result = DID_ERROR <<16;
2301  scb->scsi_cmd->scsi_done(scb->scsi_cmd);
2302 }
2303
2304 ips_freescb(ha, scb);
2305 break;
2306 default:
2307 break;
2308 }/* end case */
2309
2310 return;
2311 }
2312 #ifndef NO_IPS_CMDLINE
2313 }/* end if passthru */
2314 #endif
2315
2316 /* call back to SCSI layer */
2317  scb->scsi_cmd->scsi_done(scb->scsi_cmd);
2318 ips_freescb(ha, scb);
2319
2320 /* do the next command */
2321 ips_next(ha);
2322 }
2323
2324 /****************************************************************************/
2325 /* */
2326 /* Routine Name: ips_map_status */
2327 /* */
2328 /* Routine Description: */
2329 /* */
2330 /* Map ServeRAID error codes to Linux Error Codes */
2331 /* */
2332 /****************************************************************************/
2333 static int
2334 ips_map_status(ips_scb_t *scb, ips_stat_t *sp) {
2335 int errcode;
2336
2337 DBG("ips_map_status");
2338
2339 if(scb->bus) {
2340 /* copy SCSI status and sense data for DCDB commands */
2341 memcpy(scb->scsi_cmd->sense_buffer, scb->dcdb.sense_info,
2342 sizeof(scb->scsi_cmd->sense_buffer));
2343  scb->scsi_cmd->result = scb->dcdb.scsi_status;
2344 }else
2345  scb->scsi_cmd->result =0;
2346
2347 /* default driver error */
2348  errcode = DID_ERROR;
2349
2350 switch(scb->basic_status & GSC_STATUS_MASK) {
2351 case CMD_TIMEOUT:
2352  errcode = DID_TIME_OUT;
2353 break;
2354
2355 case INVAL_OPCO:
2356 case INVAL_CMD_BLK:
2357 case INVAL_PARM_BLK:
2358 case LOG_DRV_ERROR:
2359 case CMD_CMPLT_WERROR:
2360 break;
2361
2362 case PHYS_DRV_ERROR:
2363 /*
2364  * For physical drive errors that
2365  * are not on a logical drive should
2366  * be DID_OK. The SCSI errcode will
2367  * show what the real error is.
2368  */
2369 if(scb->bus)
2370  errcode = DID_OK;
2371
2372 switch(scb->extended_status) {
2373 case SELECTION_TIMEOUT:
2374 if(scb->bus) {
2375  scb->scsi_cmd->result |= DID_TIME_OUT <<16;
2376
2377 return(0);
2378 }
2379 break;
2380 case DATA_OVER_UNDER_RUN:
2381 if((scb->bus) && (scb->dcdb.transfer_length < scb->data_len)) {
2382 if((scb->scsi_cmd->cmnd[0] == INQUIRY) &&
2383 ((((char*) scb->scsi_cmd->buffer)[0] &0x1f) == TYPE_DISK)) {
2384 /* underflow -- no error */
2385 /* restrict access to physical DASD */
2386  errcode = DID_TIME_OUT;
2387 break;
2388 }
2389
2390 /* normal underflow Occured */
2391 if(scb->dcdb.transfer_length >= scb->scsi_cmd->underflow) {
2392  scb->scsi_cmd->result |= DID_OK <<16;
2393
2394 return(0);
2395 }
2396 }
2397
2398 break;
2399 case EXT_RECOVERY:
2400 /* don't fail recovered errors */
2401 if(scb->bus) {
2402  scb->scsi_cmd->result |= DID_OK <<16;
2403
2404 return(0);
2405 }
2406 break;
2407
2408 case EXT_HOST_RESET:
2409 case EXT_DEVICE_RESET:
2410  errcode = DID_RESET;
2411 break;
2412
2413 case EXT_CHECK_CONDITION:
2414 break;
2415 }/* end switch */
2416 }/* end switch */
2417
2418  scb->scsi_cmd->result |= (errcode <<16);
2419
2420 return(1);
2421 }
2422
2423 /****************************************************************************/
2424 /* */
2425 /* Routine Name: ips_send */
2426 /* */
2427 /* Routine Description: */
2428 /* */
2429 /* Wrapper for ips_send_cmd */
2430 /* */
2431 /****************************************************************************/
2432 static int
2433 ips_send(ips_ha_t *ha, ips_scb_t *scb, scb_callback callback) {
2434 int ret;
2435
2436 DBG("ips_send");
2437
2438  scb->callback = callback;
2439
2440  ret =ips_send_cmd(ha, scb);
2441
2442 return(ret);
2443 }
2444
2445 /****************************************************************************/
2446 /* */
2447 /* Routine Name: ips_send_wait */
2448 /* */
2449 /* Routine Description: */
2450 /* */
2451 /* Send a command to the controller and wait for it to return */
2452 /* */
2453 /****************************************************************************/
2454 static int
2455 ips_send_wait(ips_ha_t *ha, ips_scb_t *scb,int timeout) {
2456 int ret;
2457
2458 DBG("ips_send_wait");
2459
2460  ha->waitflag = TRUE;
2461  ha->cmd_in_progress = scb->cdb[0];
2462
2463  ret =ips_send(ha, scb, ipsintr_blocking);
2464
2465 if((ret == IPS_FAILURE) || (ret == IPS_SUCCESS_IMM))
2466 return(ret);
2467
2468  ret =ips_wait(ha, timeout, IPS_INTR_OFF);
2469
2470 return(ret);
2471 }
2472
2473 /****************************************************************************/
2474 /* */
2475 /* Routine Name: ips_send_cmd */
2476 /* */
2477 /* Routine Description: */
2478 /* */
2479 /* Map SCSI commands to ServeRAID commands for logical drives */
2480 /* */
2481 /****************************************************************************/
2482 static int
2483 ips_send_cmd(ips_ha_t *ha, ips_scb_t *scb) {
2484 int ret;
2485
2486 DBG("ips_send_cmd");
2487
2488  ret = IPS_SUCCESS;
2489
2490 if(!scb->scsi_cmd) {
2491 /* internal command */
2492
2493 if(scb->bus >0) {
2494 /* ServeRAID commands can't be issued */
2495 /* to real devices -- fail them */
2496 if((ha->waitflag == TRUE) &&
2497 (ha->cmd_in_progress == scb->cdb[0])) {
2498  ha->waitflag = FALSE;
2499 }
2500
2501 return(1);
2502 }
2503 #ifndef NO_IPS_CMDLINE
2504 }else if((scb->bus ==0) && (!ips_is_passthru(scb->scsi_cmd))) {
2505 #else
2506 }else if(scb->bus ==0) {
2507 #endif
2508 /* command to logical bus -- interpret */
2509  ret = IPS_SUCCESS_IMM;
2510
2511 switch(scb->scsi_cmd->cmnd[0]) {
2512 case ALLOW_MEDIUM_REMOVAL:
2513 case REZERO_UNIT:
2514 case ERASE:
2515 case WRITE_FILEMARKS:
2516 case SPACE:
2517  scb->scsi_cmd->result = DID_ERROR <<16;
2518 break;
2519
2520 case START_STOP:
2521  scb->scsi_cmd->result = DID_OK <<16;
2522
2523 case TEST_UNIT_READY:
2524 case INQUIRY:
2525 if(scb->target_id == IPS_ADAPTER_ID) {
2526 /*
2527  * Either we have a TUR
2528  * or we have a SCSI inquiry
2529  */
2530 if(scb->scsi_cmd->cmnd[0] == TEST_UNIT_READY)
2531  scb->scsi_cmd->result = DID_OK <<16;
2532
2533 if(scb->scsi_cmd->cmnd[0] == INQUIRY) {
2534  INQUIRYDATA inq;
2535
2536 memset(&inq,0,sizeof(INQUIRYDATA));
2537
2538  inq.DeviceType = TYPE_PROCESSOR;
2539  inq.DeviceTypeQualifier =0;
2540  inq.RemoveableMedia =0;
2541  inq.Versions =0x1;/* SCSI I */
2542  inq.AdditionalLength =31;
2543 strncpy(inq.VendorId,"IBM ",8);
2544 strncpy(inq.ProductId,"SERVERAID ",16);
2545 strncpy(inq.ProductRevisionLevel,"1.00",4);
2546
2547 memcpy(scb->scsi_cmd->request_buffer, &inq, scb->scsi_cmd->request_bufflen);
2548
2549  scb->scsi_cmd->result = DID_OK <<16;
2550 }
2551 }else{
2552  scb->cmd.logical_info.op_code = GET_LOGICAL_DRIVE_INFO;
2553  scb->cmd.logical_info.command_id =IPS_COMMAND_ID(ha, scb);
2554  scb->cmd.logical_info.buffer_addr =VIRT_TO_BUS(&ha->adapt->logical_drive_info);
2555  scb->cmd.logical_info.reserved =0;
2556  scb->cmd.logical_info.reserved2 =0;
2557  ret = IPS_SUCCESS;
2558 }
2559
2560 break;
2561
2562 case REQUEST_SENSE:
2563 ips_reqsen(ha, scb);
2564  scb->scsi_cmd->result = DID_OK <<16;
2565 break;
2566
2567 case READ_6:
2568 case WRITE_6:
2569 if(!scb->sg_len) {
2570  scb->cmd.basic_io.op_code =
2571 (scb->scsi_cmd->cmnd[0] == READ_6) ? IPS_READ : IPS_WRITE;
2572 }else{
2573  scb->cmd.basic_io.op_code =
2574 (scb->scsi_cmd->cmnd[0] == READ_6) ? READ_SCATTER_GATHER : WRITE_SCATTER_GATHER;
2575 }
2576
2577  scb->cmd.basic_io.command_id =IPS_COMMAND_ID(ha, scb);
2578  scb->cmd.basic_io.log_drv = scb->target_id;
2579  scb->cmd.basic_io.sg_count = scb->sg_len;
2580  scb->cmd.basic_io.sg_addr = scb->data_busaddr;
2581
2582 if(scb->cmd.basic_io.lba)
2583  scb->cmd.basic_io.lba += scb->cmd.basic_io.sector_count;
2584 else
2585  scb->cmd.basic_io.lba = (((scb->scsi_cmd->cmnd[1] &0x1f) <<16) |
2586 (scb->scsi_cmd->cmnd[2] <<8) |
2587 (scb->scsi_cmd->cmnd[3]));
2588
2589  scb->cmd.basic_io.sector_count = scb->data_len / IPS_BLKSIZE;
2590
2591 if(scb->cmd.basic_io.sector_count ==0)
2592  scb->cmd.basic_io.sector_count =256;
2593
2594  scb->cmd.basic_io.reserved =0;
2595  ret = IPS_SUCCESS;
2596 break;
2597
2598 case READ_10:
2599 case WRITE_10:
2600 if(!scb->sg_len) {
2601  scb->cmd.basic_io.op_code =
2602 (scb->scsi_cmd->cmnd[0] == READ_10) ? IPS_READ : IPS_WRITE;
2603 }else{
2604  scb->cmd.basic_io.op_code =
2605 (scb->scsi_cmd->cmnd[0] == READ_10) ? READ_SCATTER_GATHER : WRITE_SCATTER_GATHER;
2606 }
2607
2608  scb->cmd.basic_io.command_id =IPS_COMMAND_ID(ha, scb);
2609  scb->cmd.basic_io.log_drv = scb->target_id;
2610  scb->cmd.basic_io.sg_count = scb->sg_len;
2611  scb->cmd.basic_io.sg_addr = scb->data_busaddr;
2612
2613 if(scb->cmd.basic_io.lba)
2614  scb->cmd.basic_io.lba += scb->cmd.basic_io.sector_count;
2615 else
2616  scb->cmd.basic_io.lba = ((scb->scsi_cmd->cmnd[2] <<24) |
2617 (scb->scsi_cmd->cmnd[3] <<16) |
2618 (scb->scsi_cmd->cmnd[4] <<8) |
2619  scb->scsi_cmd->cmnd[5]);
2620
2621  scb->cmd.basic_io.sector_count = scb->data_len / IPS_BLKSIZE;
2622
2623  scb->cmd.basic_io.reserved =0;
2624
2625 if(scb->cmd.basic_io.sector_count ==0) {
2626 /*
2627  * This is a null condition
2628  * we don't have to do anything
2629  * so just return
2630  */
2631  scb->scsi_cmd->result = DID_OK <<16;
2632 }else
2633  ret = IPS_SUCCESS;
2634
2635 break;
2636
2637 case RESERVE:
2638 case RELEASE:
2639  scb->scsi_cmd->result = DID_OK <<16;
2640 break;
2641
2642 case MODE_SENSE:
2643  scb->cmd.basic_io.op_code = ENQUIRY;
2644  scb->cmd.basic_io.command_id =IPS_COMMAND_ID(ha, scb);
2645  scb->cmd.basic_io.sg_addr =VIRT_TO_BUS(ha->enq);
2646  ret = IPS_SUCCESS;
2647 break;
2648
2649 case READ_CAPACITY:
2650  scb->cmd.logical_info.op_code = GET_LOGICAL_DRIVE_INFO;
2651  scb->cmd.logical_info.command_id =IPS_COMMAND_ID(ha, scb);
2652  scb->cmd.logical_info.buffer_addr =VIRT_TO_BUS(&ha->adapt->logical_drive_info);
2653  scb->cmd.logical_info.reserved =0;
2654  scb->cmd.logical_info.reserved2 =0;
2655  scb->cmd.logical_info.reserved3 =0;
2656  ret = IPS_SUCCESS;
2657 break;
2658
2659 case SEND_DIAGNOSTIC:
2660 case REASSIGN_BLOCKS:
2661 case FORMAT_UNIT:
2662 case SEEK_10:
2663 case VERIFY:
2664 case READ_DEFECT_DATA:
2665 case READ_BUFFER:
2666 case WRITE_BUFFER:
2667  scb->scsi_cmd->result = DID_OK <<16;
2668 break;
2669
2670 default:
2671  scb->scsi_cmd->result = DID_ERROR <<16;
2672 break;
2673 }/* end switch */
2674 }/* end if */
2675
2676 if(ret == IPS_SUCCESS_IMM)
2677 return(ret);
2678
2679 /* setup DCDB */
2680 if(scb->bus >0) {
2681 if(!scb->sg_len)
2682  scb->cmd.dcdb.op_code = DIRECT_CDB;
2683 else
2684  scb->cmd.dcdb.op_code = DIRECT_CDB_SCATTER_GATHER;
2685
2686  scb->cmd.dcdb.command_id =IPS_COMMAND_ID(ha, scb);
2687  scb->cmd.dcdb.dcdb_address =VIRT_TO_BUS(&scb->dcdb);
2688  scb->cmd.dcdb.reserved =0;
2689  scb->cmd.dcdb.reserved2 =0;
2690  scb->cmd.dcdb.reserved3 =0;
2691
2692  scb->dcdb.device_address = ((scb->bus -1) <<4) | scb->target_id;
2693  scb->dcdb.cmd_attribute |= DISCONNECT_ALLOWED;
2694
2695 if(scb->timeout) {
2696 if(scb->timeout <=10)
2697  scb->dcdb.cmd_attribute |= TIMEOUT_10;
2698 else if(scb->timeout <=60)
2699  scb->dcdb.cmd_attribute |= TIMEOUT_60;
2700 else
2701  scb->dcdb.cmd_attribute |= TIMEOUT_20M;
2702 }
2703
2704 if(!(scb->dcdb.cmd_attribute & TIMEOUT_20M))
2705  scb->dcdb.cmd_attribute |= TIMEOUT_20M;
2706
2707  scb->dcdb.sense_length =sizeof(scb->scsi_cmd->sense_buffer);
2708  scb->dcdb.buffer_pointer = scb->data_busaddr;
2709  scb->dcdb.sg_count = scb->sg_len;
2710  scb->dcdb.cdb_length = scb->scsi_cmd->cmd_len;
2711 memcpy(scb->dcdb.scsi_cdb, scb->scsi_cmd->cmnd, scb->scsi_cmd->cmd_len);
2712 }
2713
2714 return(ips_issue(ha, scb));
2715 }
2716
2717 /****************************************************************************/
2718 /* */
2719 /* Routine Name: ips_chk_status */
2720 /* */
2721 /* Routine Description: */
2722 /* */
2723 /* Check the status of commands to logical drives */
2724 /* */
2725 /****************************************************************************/
2726 static int
2727 ips_chkstatus(ips_ha_t *ha) {
2728  ips_scb_t *scb;
2729  ips_stat_t *sp = &ha->sp;
2730  u8 basic_status;
2731  u8 ext_status;
2732 int command_id;
2733 int errcode;
2734 int ret;
2735
2736 DBG("ips_chkstatus");
2737
2738  command_id =ips_statupd(ha);
2739
2740 if(command_id > (MAX_CMDS-1)) {
2741 printk(KERN_NOTICE "(%s%d) invalid command id received: %d\n",
2742  ips_name, ha->host_num, command_id);
2743
2744 return(-1);
2745 }
2746
2747  scb = &ha->scbs[command_id];
2748  sp->scb_addr = (u32) scb;
2749  sp->residue_len =0;
2750  scb->basic_status = basic_status = ha->adapt->p_status_tail->basic_status & BASIC_STATUS_MASK;
2751  scb->extended_status = ext_status = ha->adapt->p_status_tail->extended_status;
2752
2753 /* Remove the item from the active queue */
2754 ips_removeq_scb(&ha->scb_activelist, scb);
2755
2756 if(!scb->scsi_cmd)
2757 /* internal commands are handled in do_ipsintr */
2758 return(0);
2759
2760 #ifndef NO_IPS_CMDLINE
2761 if((scb->scsi_cmd) && (ips_is_passthru(scb->scsi_cmd)))
2762 /* passthru - just returns the raw result */
2763 return(0);
2764 #endif
2765
2766  errcode = DID_OK;
2767  ret =0;
2768
2769 if(((basic_status & GSC_STATUS_MASK) == SSUCCESS) ||
2770 ((basic_status & GSC_STATUS_MASK) == RECOVERED_ERROR)) {
2771
2772 if(scb->bus ==0) {
2773 #if IPS_DEBUG >= 1
2774 if((basic_status & GSC_STATUS_MASK) == RECOVERED_ERROR) {
2775 printk(KERN_NOTICE "(%s%d) Recovered Logical Drive Error OpCode: %x, BSB: %x, ESB: %x\n",
2776  ips_name, ha->host_num,
2777  scb->cmd.basic_io.op_code, basic_status, ext_status);
2778 }
2779 #endif
2780
2781 switch(scb->scsi_cmd->cmnd[0]) {
2782 case ALLOW_MEDIUM_REMOVAL:
2783 case REZERO_UNIT:
2784 case ERASE:
2785 case WRITE_FILEMARKS:
2786 case SPACE:
2787  errcode = DID_ERROR;
2788  ret =1;
2789 break;
2790
2791 case START_STOP:
2792 break;
2793
2794 case TEST_UNIT_READY:
2795 if(!ips_online(ha, scb)) {
2796  errcode = DID_TIME_OUT;
2797  ret =1;
2798 }
2799 break;
2800
2801 case INQUIRY:
2802 if(ips_online(ha, scb)) {
2803 ips_inquiry(ha, scb);
2804 }else{
2805  errcode = DID_TIME_OUT;
2806  ret =1;
2807 }
2808 break;
2809
2810 case REQUEST_SENSE:
2811 ips_reqsen(ha, scb);
2812 break;
2813
2814 case READ_6:
2815 case WRITE_6:
2816 case READ_10:
2817 case WRITE_10:
2818 case RESERVE:
2819 case RELEASE:
2820 break;
2821
2822 case MODE_SENSE:
2823 if(!ips_online(ha, scb) || !ips_msense(ha, scb)) {
2824  errcode = DID_ERROR;
2825  ret =1;
2826 }
2827 break;
2828
2829 case READ_CAPACITY:
2830 if(ips_online(ha, scb))
2831 ips_rdcap(ha, scb);
2832 else{
2833  errcode = DID_TIME_OUT;
2834  ret =1;
2835 }
2836 break;
2837
2838 case SEND_DIAGNOSTIC:
2839 case REASSIGN_BLOCKS:
2840 break;
2841
2842 case FORMAT_UNIT:
2843  errcode = DID_ERROR;
2844  ret =1;
2845 break;
2846
2847 case SEEK_10:
2848 case VERIFY:
2849 case READ_DEFECT_DATA:
2850 case READ_BUFFER:
2851 case WRITE_BUFFER:
2852 break;
2853
2854 default:
2855  errcode = DID_ERROR;
2856  ret =1;
2857 }/* end switch */
2858
2859  scb->scsi_cmd->result = errcode <<16;
2860 }else{/* bus == 0 */
2861 /* restrict access to physical drives */
2862 if((scb->scsi_cmd->cmnd[0] == INQUIRY) &&
2863 ((((char*) scb->scsi_cmd->buffer)[0] &0x1f) == TYPE_DISK)) {
2864
2865  scb->scsi_cmd->result = DID_TIME_OUT <<16;
2866
2867  ret =1;
2868 }
2869 }/* else */
2870 }else{/* recovered error / success */
2871 #if IPS_DEBUG >= 1
2872 if(scb->bus ==0) {
2873 printk(KERN_NOTICE "(%s%d) Unrecovered Logical Drive Error OpCode: %x, BSB: %x, ESB: %x\n",
2874  ips_name, ha->host_num,
2875  scb->cmd.basic_io.op_code, basic_status, ext_status);
2876 }
2877 #endif
2878
2879  ret =ips_map_status(scb, sp);
2880 }/* else */
2881
2882 return(ret);
2883 }
2884
2885 /****************************************************************************/
2886 /* */
2887 /* Routine Name: ips_online */
2888 /* */
2889 /* Routine Description: */
2890 /* */
2891 /* Determine if a logical drive is online */
2892 /* */
2893 /****************************************************************************/
2894 static int
2895 ips_online(ips_ha_t *ha, ips_scb_t *scb) {
2896 DBG("ips_online");
2897
2898 if(scb->target_id >= MAX_LOGICAL_DRIVES)
2899 return(0);
2900
2901 if((scb->basic_status & GSC_STATUS_MASK) >1) {
2902 memset(&ha->adapt->logical_drive_info,0,sizeof(ha->adapt->logical_drive_info));
2903
2904 return(0);
2905 }
2906
2907 if(scb->target_id < ha->adapt->logical_drive_info.no_of_log_drive &&
2908  ha->adapt->logical_drive_info.drive_info[scb->target_id].state != OFF_LINE &&
2909  ha->adapt->logical_drive_info.drive_info[scb->target_id].state != FREE &&
2910  ha->adapt->logical_drive_info.drive_info[scb->target_id].state != CRS &&
2911  ha->adapt->logical_drive_info.drive_info[scb->target_id].state != SYS)
2912 return(1);
2913 else
2914 return(0);
2915 }
2916
2917 /****************************************************************************/
2918 /* */
2919 /* Routine Name: ips_inquiry */
2920 /* */
2921 /* Routine Description: */
2922 /* */
2923 /* Simulate an inquiry command to a logical drive */
2924 /* */
2925 /****************************************************************************/
2926 static int
2927 ips_inquiry(ips_ha_t *ha, ips_scb_t *scb) {
2928  INQUIRYDATA inq;
2929
2930 DBG("ips_inquiry");
2931
2932 memset(&inq,0,sizeof(INQUIRYDATA));
2933
2934  inq.DeviceType = TYPE_DISK;
2935  inq.DeviceTypeQualifier =0;
2936  inq.RemoveableMedia =0;
2937  inq.Versions =0x1;/* SCSI I */
2938  inq.AdditionalLength =31;
2939 strncpy(inq.VendorId,"IBM ",8);
2940 strncpy(inq.ProductId,"SERVERAID ",16);
2941 strncpy(inq.ProductRevisionLevel,"1.00",4);
2942
2943 memcpy(scb->scsi_cmd->request_buffer, &inq, scb->scsi_cmd->request_bufflen);
2944
2945 return(1);
2946 }
2947
2948 /****************************************************************************/
2949 /* */
2950 /* Routine Name: ips_rdcap */
2951 /* */
2952 /* Routine Description: */
2953 /* */
2954 /* Simulate a read capacity command to a logical drive */
2955 /* */
2956 /****************************************************************************/
2957 static int
2958 ips_rdcap(ips_ha_t *ha, ips_scb_t *scb) {
2959  CAPACITY_T *cap;
2960
2961 DBG("ips_rdcap");
2962
2963 if(scb->scsi_cmd->bufflen <8)
2964 return(0);
2965
2966  cap = (CAPACITY_T *) scb->scsi_cmd->request_buffer;
2967
2968  cap->lba =htonl(ha->adapt->logical_drive_info.drive_info[scb->target_id].sector_count -1);
2969  cap->len =htonl((u32) IPS_BLKSIZE);
2970
2971 return(1);
2972 }
2973
2974 /****************************************************************************/
2975 /* */
2976 /* Routine Name: ips_msense */
2977 /* */
2978 /* Routine Description: */
2979 /* */
2980 /* Simulate a mode sense command to a logical drive */
2981 /* */
2982 /****************************************************************************/
2983 static int
2984 ips_msense(ips_ha_t *ha, ips_scb_t *scb) {
2985  u16 heads;
2986  u16 sectors;
2987  u32 cylinders;
2988  ips_mdata_t mdata;
2989
2990 DBG("ips_msense");
2991
2992 if(ha->enq->ulDriveSize[scb->target_id] >0x400000&&
2993 (ha->enq->ucMiscFlag &0x8) ==0) {
2994  heads = NORM_MODE_HEADS;
2995  sectors = NORM_MODE_SECTORS;
2996 }else{
2997  heads = COMP_MODE_HEADS;
2998  sectors = COMP_MODE_SECTORS;
2999 }
3000
3001  cylinders = ha->enq->ulDriveSize[scb->target_id] / (heads * sectors);
3002
3003  mdata.plh.plh_type =0;
3004  mdata.plh.plh_wp =0;
3005  mdata.plh.plh_bdl =8;
3006
3007 switch(scb->scsi_cmd->cmnd[2] &0x3f) {
3008 case0x03:/* page 3 */
3009  mdata.pdata.pg3.pg_pc =0x3;
3010  mdata.pdata.pg3.pg_res1 =0;
3011  mdata.pdata.pg3.pg_len =sizeof(DADF_T);
3012  mdata.plh.plh_len =3+ mdata.plh.plh_bdl + mdata.pdata.pg3.pg_len;
3013  mdata.pdata.pg3.pg_trk_z =0;
3014  mdata.pdata.pg3.pg_asec_z =0;
3015  mdata.pdata.pg3.pg_atrk_z =0;
3016  mdata.pdata.pg3.pg_atrk_v =0;
3017  mdata.pdata.pg3.pg_sec_t =htons(sectors);
3018  mdata.pdata.pg3.pg_bytes_s =htons(IPS_BLKSIZE);
3019  mdata.pdata.pg3.pg_intl =htons(1);
3020  mdata.pdata.pg3.pg_trkskew =0;
3021  mdata.pdata.pg3.pg_cylskew =0;
3022  mdata.pdata.pg3.pg_res2 =0;
3023  mdata.pdata.pg3.pg_ins =0;
3024  mdata.pdata.pg3.pg_surf =0;
3025  mdata.pdata.pg3.pg_rmb =0;
3026  mdata.pdata.pg3.pg_hsec =0;
3027  mdata.pdata.pg3.pg_ssec =1;
3028 break;
3029
3030 case0x4:
3031  mdata.pdata.pg4.pg_pc =0x4;
3032  mdata.pdata.pg4.pg_res1 =0;
3033  mdata.pdata.pg4.pg_len =sizeof(RDDG_T);
3034  mdata.plh.plh_len =3+ mdata.plh.plh_bdl + mdata.pdata.pg4.pg_len;
3035  mdata.pdata.pg4.pg_cylu = (cylinders >>8) &0xffff;
3036  mdata.pdata.pg4.pg_cyll = cylinders &0xff;
3037  mdata.pdata.pg4.pg_head = heads;
3038  mdata.pdata.pg4.pg_wrpcompu =0;
3039  mdata.pdata.pg4.pg_wrpcompl =0;
3040  mdata.pdata.pg4.pg_redwrcur =0;
3041  mdata.pdata.pg4.pg_drstep =htons(1);
3042  mdata.pdata.pg4.pg_landu =0;
3043  mdata.pdata.pg4.pg_landl =0;
3044  mdata.pdata.pg4.pg_res2 =0;
3045 break;
3046 default:
3047 return(0);
3048 }/* end switch */
3049
3050 memcpy(scb->scsi_cmd->request_buffer, &mdata, scb->scsi_cmd->request_bufflen);
3051
3052 return(1);
3053 }
3054
3055 /****************************************************************************/
3056 /* */
3057 /* Routine Name: ips_reqsen */
3058 /* */
3059 /* Routine Description: */
3060 /* */
3061 /* Simulate a request sense command to a logical drive */
3062 /* */
3063 /****************************************************************************/
3064 static int
3065 ips_reqsen(ips_ha_t *ha, ips_scb_t *scb) {
3066 char*sp;
3067
3068 DBG("ips_reqsen");
3069
3070  sp = (char*) scb->scsi_cmd->sense_buffer;
3071 memset(sp,0,sizeof(scb->scsi_cmd->sense_buffer));
3072
3073  sp[0] =0x70;
3074  sp[3] = NO_SENSE;
3075  sp[7] =0xe;
3076  sp[12] = NO_SENSE;
3077
3078 return(0);
3079 }
3080
3081 /****************************************************************************/
3082 /* */
3083 /* Routine Name: ips_free */
3084 /* */
3085 /* Routine Description: */
3086 /* */
3087 /* Free any allocated space for this controller */
3088 /* */
3089 /****************************************************************************/
3090 static void
3091 ips_free(ips_ha_t *ha) {
3092 int i;
3093
3094 DBG("ips_free");
3095
3096 if(ha) {
3097 if(ha->enq) {
3098 kfree(ha->enq);
3099  ha->enq = NULL;
3100 }
3101
3102 if(ha->conf) {
3103 kfree(ha->conf);
3104  ha->conf = NULL;
3105 }
3106
3107 if(ha->adapt) {
3108 kfree(ha->adapt);
3109  ha->adapt = NULL;
3110 }
3111
3112 if(ha->nvram) {
3113 kfree(ha->nvram);
3114  ha->nvram = NULL;
3115 }
3116
3117 if(ha->subsys) {
3118 kfree(ha->subsys);
3119  ha->subsys = NULL;
3120 }
3121
3122 if(ha->dummy) {
3123 kfree(ha->dummy);
3124  ha->dummy = NULL;
3125 }
3126
3127 if(ha->scbs) {
3128 for(i =0; i < ha->max_cmds; i++) {
3129 if(ha->scbs[i].sg_list)
3130 kfree(ha->scbs[i].sg_list);
3131 }
3132
3133 kfree(ha->scbs);
3134  ha->scbs = NULL;
3135 }/* end if */
3136 }
3137 }
3138
3139 /****************************************************************************/
3140 /* */
3141 /* Routine Name: ips_allocatescbs */
3142 /* */
3143 /* Routine Description: */
3144 /* */
3145 /* Allocate the command blocks */
3146 /* */
3147 /****************************************************************************/
3148 static int
3149 ips_allocatescbs(ips_ha_t *ha) {
3150  ips_scb_t *scb_p;
3151 int i;
3152
3153 DBG("ips_allocatescbs");
3154
3155 /* Allocate memory for the CCBs */
3156  ha->scbs = (ips_scb_t *)kmalloc(ha->max_cmds *sizeof(ips_scb_t), GFP_KERNEL|GFP_DMA);
3157
3158 memset(ha->scbs,0, ha->max_cmds *sizeof(ips_scb_t));
3159
3160 for(i =0; i < ha->max_cmds; i++) {
3161  scb_p = &ha->scbs[i];
3162
3163 /* allocate S/G list */
3164  scb_p->sg_list = (SG_LIST *)kmalloc(sizeof(SG_LIST) * MAX_SG_ELEMENTS, GFP_KERNEL|GFP_DMA);
3165
3166 if(! scb_p->sg_list)
3167 return(0);
3168
3169 /* add to the free list */
3170 if(i < ha->max_cmds -1) {
3171  scb_p->q_next = ha->scb_freelist;
3172  ha->scb_freelist = scb_p;
3173 }
3174 }
3175
3176 /* success */
3177 return(1);
3178 }
3179
3180 /****************************************************************************/
3181 /* */
3182 /* Routine Name: ips_init_scb */
3183 /* */
3184 /* Routine Description: */
3185 /* */
3186 /* Initialize a CCB to default values */
3187 /* */
3188 /****************************************************************************/
3189 static void
3190 ips_init_scb(ips_ha_t *ha, ips_scb_t *scb) {
3191  SG_LIST *sg_list;
3192
3193 DBG("ips_init_scb");
3194
3195 if(scb == NULL)
3196 return;
3197
3198  sg_list = scb->sg_list;
3199
3200 /* zero fill */
3201 memset(scb,0,sizeof(ips_scb_t));
3202 memset(ha->dummy,0,sizeof(BASIC_IO_CMD));
3203
3204 /* Initialize dummy command bucket */
3205  ha->dummy->op_code =0xFF;
3206  ha->dummy->ccsar =VIRT_TO_BUS(ha->dummy);
3207  ha->dummy->command_id = MAX_CMDS;
3208
3209 /* set bus address of scb */
3210  scb->scb_busaddr =VIRT_TO_BUS(scb);
3211  scb->sg_list = sg_list;
3212
3213 /* Neptune Fix */
3214  scb->cmd.basic_io.cccr = ILE;
3215  scb->cmd.basic_io.ccsar =VIRT_TO_BUS(ha->dummy);
3216 }
3217
3218 /****************************************************************************/
3219 /* */
3220 /* Routine Name: ips_get_scb */
3221 /* */
3222 /* Routine Description: */
3223 /* */
3224 /* Initialize a CCB to default values */
3225 /* */
3226 /* ASSUMED to be callled from within a lock */
3227 /* */
3228 /****************************************************************************/
3229 static ips_scb_t *
3230 ips_getscb(ips_ha_t *ha) {
3231  ips_scb_t *scb;
3232 unsigned int cpu_flags;
3233
3234 DBG("ips_getscb");
3235
3236 spin_lock_irqsave(&ha->scb_lock, cpu_flags);
3237 if((scb = ha->scb_freelist) == NULL) {
3238 spin_unlock_irqrestore(&ha->scb_lock, cpu_flags);
3239
3240 return(NULL);
3241 }
3242
3243  ha->scb_freelist = scb->q_next;
3244  scb->q_next = NULL;
3245
3246 spin_unlock_irqrestore(&ha->scb_lock, cpu_flags);
3247
3248 ips_init_scb(ha, scb);
3249
3250 return(scb);
3251 }
3252
3253 /****************************************************************************/
3254 /* */
3255 /* Routine Name: ips_free_scb */
3256 /* */
3257 /* Routine Description: */
3258 /* */
3259 /* Return an unused CCB back to the free list */
3260 /* */
3261 /* ASSUMED to be called from within a lock */
3262 /* */
3263 /****************************************************************************/
3264 static void
3265 ips_freescb(ips_ha_t *ha, ips_scb_t *scb) {
3266 unsigned int cpu_flags;
3267
3268 DBG("ips_freescb");
3269
3270 /* check to make sure this is not our "special" scb */
3271 if(IPS_COMMAND_ID(ha, scb) < (ha->max_cmds -1)) {
3272 spin_lock_irqsave(&ha->scb_lock, cpu_flags);
3273  scb->q_next = ha->scb_freelist;
3274  ha->scb_freelist = scb;
3275 spin_unlock_irqrestore(&ha->scb_lock, cpu_flags);
3276 }
3277 }
3278
3279 /****************************************************************************/
3280 /* */
3281 /* Routine Name: ips_reset_adapter */
3282 /* */
3283 /* Routine Description: */
3284 /* */
3285 /* Reset the controller */
3286 /* */
3287 /****************************************************************************/
3288 static int
3289 ips_reset_adapter(ips_ha_t *ha) {
3290  u8 Isr;
3291  u8 Cbsp;
3292  u8 PostByte[MAX_POST_BYTES];
3293  u8 ConfigByte[MAX_CONFIG_BYTES];
3294 int i, j;
3295 int reset_counter;
3296
3297 DBG("ips_reset_adapter");
3298
3299 #if IPS_DEBUG >= 1
3300 printk(KERN_WARNING "ips_reset_adapter: io addr: %x, irq: %d\n",
3301  ha->io_addr, ha->irq);
3302 #endif
3303
3304  reset_counter =0;
3305
3306 while(reset_counter <2) {
3307  reset_counter++;
3308
3309 outb(RST, ha->io_addr + SCPR);
3310 MDELAY(ONE_SEC);
3311 outb(0, ha->io_addr + SCPR);
3312 MDELAY(ONE_SEC);
3313
3314 for(i =0; i < MAX_POST_BYTES; i++) {
3315 for(j =0; j <45; j++) {
3316  Isr =inb(ha->io_addr + HISR);
3317 if(Isr & GHI)
3318 break;
3319
3320 MDELAY(ONE_SEC);
3321 }
3322
3323 if(j >=45) {
3324 /* error occured */
3325 if(reset_counter <2)
3326 continue;
3327 else
3328 /* reset failed */
3329 return(0);
3330 }
3331
3332  PostByte[i] =inb(ha->io_addr + ISPR);
3333 outb(Isr, ha->io_addr + HISR);
3334 }
3335
3336 if(PostByte[0] < GOOD_POST_BASIC_STATUS) {
3337 printk("(%s%d) reset controller fails (post status %x %x).\n",
3338  ips_name, ha->host_num, PostByte[0], PostByte[1]);
3339
3340 return(0);
3341 }
3342
3343 for(i =0; i < MAX_CONFIG_BYTES; i++) {
3344 for(j =0; j <240; j++) {
3345  Isr =inb(ha->io_addr + HISR);
3346 if(Isr & GHI)
3347 break;
3348
3349 MDELAY(ONE_SEC);/* 100 msec */
3350 }
3351
3352 if(j >=240) {
3353 /* error occured */
3354 if(reset_counter <2)
3355 continue;
3356 else
3357 /* reset failed */
3358 return(0);
3359 }
3360
3361  ConfigByte[i] =inb(ha->io_addr + ISPR);
3362 outb(Isr, ha->io_addr + HISR);
3363 }
3364
3365 if(ConfigByte[0] ==0&& ConfigByte[1] ==2) {
3366 printk("(%s%d) reset controller fails (status %x %x).\n",
3367  ips_name, ha->host_num, ConfigByte[0], ConfigByte[1]);
3368
3369 return(0);
3370 }
3371
3372 for(i =0; i <240; i++) {
3373  Cbsp =inb(ha->io_addr + CBSP);
3374
3375 if((Cbsp & OP) ==0)
3376 break;
3377
3378 MDELAY(ONE_SEC);
3379 }
3380
3381 if(i >=240) {
3382 /* error occured */
3383 if(reset_counter <2)
3384 continue;
3385 else
3386 /* reset failed */
3387 return(0);
3388 }
3389
3390 /* setup CCCR */
3391 outw(0x1010, ha->io_addr + CCCR);
3392
3393 /* Enable busmastering */
3394 outb(EBM, ha->io_addr + SCPR);
3395
3396 /* setup status queues */
3397 ips_statinit(ha);
3398
3399 /* Enable interrupts */
3400 outb(EI, ha->io_addr + HISR);
3401
3402 /* if we get here then everything went OK */
3403 break;
3404 }
3405
3406 return(1);
3407 }
3408
3409 /****************************************************************************/
3410 /* */
3411 /* Routine Name: ips_statinit */
3412 /* */
3413 /* Routine Description: */
3414 /* */
3415 /* Initialize the status queues on the controller */
3416 /* */
3417 /****************************************************************************/
3418 static void
3419 ips_statinit(ips_ha_t *ha) {
3420  u32 phys_status_start;
3421
3422 DBG("ips_statinit");
3423
3424  ha->adapt->p_status_start = ha->adapt->status;
3425  ha->adapt->p_status_end = ha->adapt->status + MAX_CMDS;
3426  ha->adapt->p_status_tail = ha->adapt->status;
3427
3428  phys_status_start =VIRT_TO_BUS(ha->adapt->status);
3429 outl(phys_status_start, ha->io_addr + SQSR);
3430 outl(phys_status_start + STATUS_Q_SIZE, ha->io_addr + SQER);
3431 outl(phys_status_start + STATUS_SIZE, ha->io_addr + SQHR);
3432 outl(phys_status_start, ha->io_addr + SQTR);
3433
3434  ha->adapt->hw_status_start = phys_status_start;
3435  ha->adapt->hw_status_tail = phys_status_start;
3436 }
3437
3438 /****************************************************************************/
3439 /* */
3440 /* Routine Name: ips_statupd */
3441 /* */
3442 /* Routine Description: */
3443 /* */
3444 /* Remove an element from the status queue */
3445 /* */
3446 /****************************************************************************/
3447 static int
3448 ips_statupd(ips_ha_t *ha) {
3449 int command_id;
3450
3451 DBG("ips_statupd");
3452
3453 if(ha->adapt->p_status_tail != ha->adapt->p_status_end) {
3454  ha->adapt->p_status_tail++;
3455  ha->adapt->hw_status_tail +=sizeof(STATUS);
3456 }else{
3457  ha->adapt->p_status_tail = ha->adapt->p_status_start;
3458  ha->adapt->hw_status_tail = ha->adapt->hw_status_start;
3459 }
3460
3461 outl(ha->adapt->hw_status_tail, ha->io_addr + SQTR);
3462
3463  command_id = ha->adapt->p_status_tail->command_id;
3464
3465 return(command_id);
3466 }
3467
3468 /****************************************************************************/
3469 /* */
3470 /* Routine Name: ips_issue */
3471 /* */
3472 /* Routine Description: */
3473 /* */
3474 /* Send a command down to the controller */
3475 /* */
3476 /* ASSUMED to be called from within a lock */
3477 /* */
3478 /****************************************************************************/
3479 static int
3480 ips_issue(ips_ha_t *ha, ips_scb_t *scb) {
3481  u32 TimeOut;
3482  u16 val;
3483
3484 DBG("ips_issue");
3485
3486 #if IPS_DEBUG >= 10
3487 if(scb->scsi_cmd)
3488 printk(KERN_NOTICE "%s: ips_issue: cmd 0x%X id %d (%d %d %d)\n",
3489  ips_name,
3490  scb->cdb[0],
3491  scb->cmd.basic_io.command_id,
3492  scb->bus,
3493  scb->target_id,
3494  scb->lun);
3495 else
3496 printk(KERN_NOTICE "%s: ips_issue: logical cmd id %d\n",
3497  ips_name,
3498  scb->cmd.basic_io.command_id);
3499 #if IPS_DEBUG >= 11
3500 MDELAY(ONE_SEC);
3501 #endif
3502 #endif
3503
3504  TimeOut =0;
3505
3506 while((val =inw(ha->io_addr + CCCR)) & SEMAPHORE) {
3507 UDELAY(1000);
3508
3509 if(++TimeOut >= SEMAPHORE_TIMEOUT) {
3510 if(!(val & START_STOP_BIT))
3511 break;
3512
3513 printk(KERN_WARNING "(%s%d) ips_issue val [0x%x].\n",
3514  ips_name, ha->host_num, val);
3515 printk(KERN_WARNING "(%s%d) ips_issue semaphore chk timeout.\n",
3516  ips_name, ha->host_num);
3517
3518 return(IPS_FAILURE);
3519 }/* end if */
3520 }/* end while */
3521
3522 outl(scb->scb_busaddr, ha->io_addr + CCSAR);
3523 outw(START_COMMAND, ha->io_addr + CCCR);
3524
3525 return(IPS_SUCCESS);
3526 }
3527
3528 /****************************************************************************/
3529 /* */
3530 /* Routine Name: ips_isintr */
3531 /* */
3532 /* Routine Description: */
3533 /* */
3534 /* Test to see if an interrupt is for us */
3535 /* */
3536 /****************************************************************************/
3537 static int
3538 ips_isintr(ips_ha_t *ha) {
3539  u8 Isr;
3540
3541 DBG("ips_isintr");
3542
3543  Isr =inb(ha->io_addr + HISR);
3544
3545 if(Isr ==0xFF)
3546 /* ?!?! Nothing really there */
3547 return(0);
3548
3549 if(Isr & SCE)
3550 return(1);
3551 else if(Isr & (SQO | GHI)) {
3552 /* status queue overflow or GHI */
3553 /* just clear the interrupt */
3554 outb(Isr, ha->io_addr + HISR);
3555 }
3556
3557 return(0);
3558 }
3559
3560 /****************************************************************************/
3561 /* */
3562 /* Routine Name: ips_wait */
3563 /* */
3564 /* Routine Description: */
3565 /* */
3566 /* Wait for a command to complete */
3567 /* */
3568 /****************************************************************************/
3569 static int
3570 ips_wait(ips_ha_t *ha,int time,int intr) {
3571 int ret;
3572
3573 DBG("ips_wait");
3574
3575  ret = IPS_FAILURE;
3576
3577  time *= ONE_SEC;/* convert seconds to milliseconds */
3578
3579 while(time >0) {
3580 if(intr == IPS_INTR_OFF) {
3581 if(ha->waitflag == FALSE) {
3582 /*
3583  * controller generated an interupt to
3584  * acknowledge completion of the command
3585  * and ips_intr() has serviced the interrupt.
3586  */
3587  ret = IPS_SUCCESS;
3588 break;
3589 }
3590
3591 /*
3592  * NOTE: Interrupts are disabled here
3593  * On an SMP system interrupts will only
3594  * be disabled on one processor.
3595  * So, ultimately we still need to set the
3596  * "I'm in the interrupt handler flag"
3597  */
3598 while(test_and_set_bit(IPS_IN_INTR, &ha->flags))
3599 UDELAY(1000);
3600
3601 ips_intr(ha);
3602
3603 clear_bit(IPS_IN_INTR, &ha->flags);
3604
3605 }else{
3606 if(ha->waitflag == FALSE) {
3607  ret = IPS_SUCCESS;
3608 break;
3609 }
3610 }
3611
3612 UDELAY(1000);/* 1 milisecond */
3613  time--;
3614 }
3615
3616 return(ret);
3617 }
3618
3619 /****************************************************************************/
3620 /* */
3621 /* Routine Name: ips_write_driver_status */
3622 /* */
3623 /* Routine Description: */
3624 /* */
3625 /* Write OS/Driver version to Page 5 of the nvram on the controller */
3626 /* */
3627 /****************************************************************************/
3628 static int
3629 ips_write_driver_status(ips_ha_t *ha) {
3630 DBG("ips_write_driver_status");
3631
3632 if(!ips_readwrite_page5(ha, FALSE)) {
3633 printk(KERN_WARNING "(%s%d) unable to read NVRAM page 5.\n",
3634  ips_name, ha->host_num);
3635
3636 return(0);
3637 }
3638
3639 /* check to make sure the page has a valid */
3640 /* signature */
3641 if(ha->nvram->signature != NVRAM_PAGE5_SIGNATURE) {
3642 #if IPS_DEBUG >= 1
3643 printk("(%s%d) NVRAM page 5 has an invalid signature: %X.\n",
3644  ips_name, ha->host_num, ha->nvram->signature);
3645 #endif
3646 return(1);
3647 }
3648
3649 #if IPS_DEBUG >= 2
3650 printk("(%s%d) Ad Type: %d, Ad Slot: %d, BIOS: %c%c%c%c %c%c%c%c.\n",
3651  ips_name, ha->host_num, ha->nvram->adapter_type, ha->nvram->adapter_slot,
3652  ha->nvram->bios_high[0], ha->nvram->bios_high[1],
3653  ha->nvram->bios_high[2], ha->nvram->bios_high[3],
3654  ha->nvram->bios_low[0], ha->nvram->bios_low[1],
3655  ha->nvram->bios_low[2], ha->nvram->bios_low[3]);
3656 #endif
3657
3658 /* save controller type */
3659  ha->ad_type = ha->nvram->adapter_type;
3660
3661 /* change values (as needed) */
3662  ha->nvram->operating_system = OS_LINUX;
3663 strncpy((char*) ha->nvram->driver_high, IPS_VERSION_HIGH,4);
3664 strncpy((char*) ha->nvram->driver_low, IPS_VERSION_LOW,4);
3665
3666 /* now update the page */
3667 if(!ips_readwrite_page5(ha, TRUE)) {
3668 printk(KERN_WARNING "(%s%d) unable to write NVRAM page 5.\n",
3669  ips_name, ha->host_num);
3670
3671 return(0);
3672 }
3673
3674 return(1);
3675 }
3676
3677 /****************************************************************************/
3678 /* */
3679 /* Routine Name: ips_read_adapter_status */
3680 /* */
3681 /* Routine Description: */
3682 /* */
3683 /* Do an Inquiry command to the adapter */
3684 /* */
3685 /****************************************************************************/
3686 static int
3687 ips_read_adapter_status(ips_ha_t *ha) {
3688  ips_scb_t *scb;
3689 int ret;
3690
3691 DBG("ips_read_adapter_status");
3692
3693  scb = &ha->scbs[ha->max_cmds-1];
3694
3695 ips_init_scb(ha, scb);
3696
3697  scb->timeout = ips_cmd_timeout;
3698  scb->cdb[0] = ENQUIRY;
3699
3700  scb->cmd.basic_io.op_code = ENQUIRY;
3701  scb->cmd.basic_io.command_id =IPS_COMMAND_ID(ha, scb);
3702  scb->cmd.basic_io.sg_count =0;
3703  scb->cmd.basic_io.sg_addr =VIRT_TO_BUS(ha->enq);
3704  scb->cmd.basic_io.lba =0;
3705  scb->cmd.basic_io.sector_count =0;
3706  scb->cmd.basic_io.log_drv =0;
3707  scb->cmd.basic_io.reserved =0;
3708
3709 /* send command */
3710  ret =ips_send_wait(ha, scb, ips_cmd_timeout);
3711 if((ret == IPS_FAILURE) || (ret == IPS_SUCCESS_IMM))
3712 return(0);
3713
3714 return(1);
3715 }
3716
3717 /****************************************************************************/
3718 /* */
3719 /* Routine Name: ips_read_subsystem_parameters */
3720 /* */
3721 /* Routine Description: */
3722 /* */
3723 /* Read subsystem parameters from the adapter */
3724 /* */
3725 /****************************************************************************/
3726 static int
3727 ips_read_subsystem_parameters(ips_ha_t *ha) {
3728  ips_scb_t *scb;
3729 int ret;
3730
3731 DBG("ips_read_subsystem_parameters");
3732
3733  scb = &ha->scbs[ha->max_cmds-1];
3734
3735 ips_init_scb(ha, scb);
3736
3737  scb->timeout = ips_cmd_timeout;
3738  scb->cdb[0] = GET_SUBSYS_PARAM;
3739
3740  scb->cmd.basic_io.op_code = GET_SUBSYS_PARAM;
3741  scb->cmd.basic_io.command_id =IPS_COMMAND_ID(ha, scb);
3742  scb->cmd.basic_io.sg_count =0;
3743  scb->cmd.basic_io.sg_addr =VIRT_TO_BUS(ha->subsys);
3744  scb->cmd.basic_io.lba =0;
3745  scb->cmd.basic_io.sector_count =0;
3746  scb->cmd.basic_io.log_drv =0;
3747  scb->cmd.basic_io.reserved =0;
3748
3749 /* send command */
3750  ret =ips_send_wait(ha, scb, ips_cmd_timeout);
3751 if((ret == IPS_FAILURE) || (ret == IPS_SUCCESS_IMM))
3752 return(0);
3753
3754 return(1);
3755 }
3756
3757 /****************************************************************************/
3758 /* */
3759 /* Routine Name: ips_read_config */
3760 /* */
3761 /* Routine Description: */
3762 /* */
3763 /* Read the configuration on the adapter */
3764 /* */
3765 /****************************************************************************/
3766 static int
3767 ips_read_config(ips_ha_t *ha) {
3768  ips_scb_t *scb;
3769 int i;
3770 int ret;
3771
3772 DBG("ips_read_config");
3773
3774 /* set defaults for initiator IDs */
3775  ha->conf->init_id[0] = IPS_ADAPTER_ID;
3776 for(i =1; i <4; i++)
3777  ha->conf->init_id[i] =7;
3778
3779  scb = &ha->scbs[ha->max_cmds-1];
3780
3781 ips_init_scb(ha, scb);
3782
3783  scb->timeout = ips_cmd_timeout;
3784  scb->cdb[0] = READ_NVRAM_CONFIGURATION;
3785
3786  scb->cmd.basic_io.op_code = READ_NVRAM_CONFIGURATION;
3787  scb->cmd.basic_io.command_id =IPS_COMMAND_ID(ha, scb);
3788  scb->cmd.basic_io.sg_addr =VIRT_TO_BUS(ha->conf);
3789
3790 /* send command */
3791 if(((ret =ips_send_wait(ha, scb, ips_cmd_timeout)) == IPS_FAILURE) ||
3792 (ret == IPS_SUCCESS_IMM) ||
3793 ((scb->basic_status & GSC_STATUS_MASK) >1)) {
3794
3795 memset(ha->conf,0,sizeof(CONFCMD));
3796
3797 /* reset initiator IDs */
3798  ha->conf->init_id[0] = IPS_ADAPTER_ID;
3799 for(i =1; i <4; i++)
3800  ha->conf->init_id[i] =7;
3801
3802 return(0);
3803 }
3804
3805 return(1);
3806 }
3807
3808 /****************************************************************************/
3809 /* */
3810 /* Routine Name: ips_readwrite_page5 */
3811 /* */
3812 /* Routine Description: */
3813 /* */
3814 /* Read the configuration on the adapter */
3815 /* */
3816 /****************************************************************************/
3817 static int
3818 ips_readwrite_page5(ips_ha_t *ha,int write) {
3819  ips_scb_t *scb;
3820 int ret;
3821
3822 DBG("ips_readwrite_page5");
3823
3824  scb = &ha->scbs[ha->max_cmds-1];
3825
3826 ips_init_scb(ha, scb);
3827
3828  scb->timeout = ips_cmd_timeout;
3829  scb->cdb[0] = RW_NVRAM_PAGE;
3830
3831  scb->cmd.nvram.op_code = RW_NVRAM_PAGE;
3832  scb->cmd.nvram.command_id =IPS_COMMAND_ID(ha, scb);
3833  scb->cmd.nvram.page =5;
3834  scb->cmd.nvram.write = write;
3835  scb->cmd.nvram.buffer_addr =VIRT_TO_BUS(ha->nvram);
3836  scb->cmd.nvram.reserved =0;
3837  scb->cmd.nvram.reserved2 =0;
3838
3839 /* issue the command */
3840 if(((ret =ips_send_wait(ha, scb, ips_cmd_timeout)) == IPS_FAILURE) ||
3841 (ret == IPS_SUCCESS_IMM) ||
3842 ((scb->basic_status & GSC_STATUS_MASK) >1)) {
3843
3844 memset(ha->nvram,0,sizeof(NVRAM_PAGE5));
3845
3846 return(0);
3847 }
3848
3849 return(1);
3850 }
3851
3852 /****************************************************************************/
3853 /* */
3854 /* Routine Name: ips_clear_adapter */
3855 /* */
3856 /* Routine Description: */
3857 /* */
3858 /* Clear the stripe lock tables */
3859 /* */
3860 /****************************************************************************/
3861 static int
3862 ips_clear_adapter(ips_ha_t *ha) {
3863  ips_scb_t *scb;
3864 int ret;
3865
3866 DBG("ips_clear_adapter");
3867
3868  scb = &ha->scbs[ha->max_cmds-1];
3869
3870 ips_init_scb(ha, scb);
3871
3872  scb->timeout = ips_reset_timeout;
3873  scb->cdb[0] = CONFIG_SYNC;
3874
3875  scb->cmd.config_sync.op_code = CONFIG_SYNC;
3876  scb->cmd.config_sync.command_id =IPS_COMMAND_ID(ha, scb);
3877  scb->cmd.config_sync.channel =0;
3878  scb->cmd.config_sync.source_target = POCL;
3879  scb->cmd.config_sync.reserved =0;
3880  scb->cmd.config_sync.reserved2 =0;
3881  scb->cmd.config_sync.reserved3 =0;
3882
3883 /* issue command */
3884  ret =ips_send_wait(ha, scb, ips_reset_timeout);
3885 if((ret == IPS_FAILURE) || (ret == IPS_SUCCESS_IMM))
3886 return(0);
3887
3888 /* send unlock stripe command */
3889 ips_init_scb(ha, scb);
3890
3891  scb->cdb[0] = GET_ERASE_ERROR_TABLE;
3892  scb->timeout = ips_reset_timeout;
3893
3894  scb->cmd.unlock_stripe.op_code = GET_ERASE_ERROR_TABLE;
3895  scb->cmd.unlock_stripe.command_id =IPS_COMMAND_ID(ha, scb);
3896  scb->cmd.unlock_stripe.log_drv =0;
3897  scb->cmd.unlock_stripe.control = CSL;
3898  scb->cmd.unlock_stripe.reserved =0;
3899  scb->cmd.unlock_stripe.reserved2 =0;
3900  scb->cmd.unlock_stripe.reserved3 =0;
3901
3902 /* issue command */
3903  ret =ips_send_wait(ha, scb, ips_reset_timeout);
3904 if((ret == IPS_FAILURE) || (ret == IPS_SUCCESS_IMM))
3905 return(0);
3906
3907 return(1);
3908 }
3909
3910 #if defined (MODULE)
3911
3912 Scsi_Host_Template driver_template = IPS;
3913
3914 #include"scsi_module.c"
3915
3916 #endif
3917
3918
3919 /*
3920  * Overrides for Emacs so that we almost follow Linus's tabbing style.
3921  * Emacs will notice this stuff at the end of the file and automatically
3922  * adjust the settings for this buffer only. This must remain at the end
3923  * of the file.
3924  * ---------------------------------------------------------------------------
3925  * Local variables:
3926  * c-indent-level: 2
3927  * c-brace-imaginary-offset: 0
3928  * c-brace-offset: -2
3929  * c-argdecl-indent: 2
3930  * c-label-offset: -2
3931  * c-continued-statement-offset: 2
3932  * c-continued-brace-offset: 0
3933  * indent-tabs-mode: nil
3934  * tab-width: 8
3935  * End:
3936  */