SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/scsi/dpt_i2o.c

   1 /***************************************************************************
   2                           dpti.c  -  description
   3                              -------------------
   4     begin                : Thu Sep 7 2000
   5     copyright            : (C) 2000 by Adaptec
   6
   7                            July 30, 2001 First version being submitted
   8                            for inclusion in the kernel.  V2.4
   9
  10     See Documentation/scsi/dpti.txt for history, notes, license info
  11     and credits
  12  ***************************************************************************/
  13
  14 /***************************************************************************
  15  *                                                                         *
  16  *   This program is free software; you can redistribute it and/or modify  *
  17  *   it under the terms of the GNU General Public License as published by  *
  18  *   the Free Software Foundation; either version 2 of the License, or     *
  19  *   (at your option) any later version.                                   *
  20  *                                                                         *
  21  ***************************************************************************/
  22 /***************************************************************************
  23  * Sat Dec 20 2003 Go Taniguchi <go@turbolinux.co.jp>
  24  - Support 2.6 kernel and DMA-mapping
  25  - ioctl fix for raid tools
  26  - use schedule_timeout in long long loop
  27  **************************************************************************/
  28
  29 /*#define DEBUG 1 */
  30 /*#define UARTDELAY 1 */
  31
  32 /* On the real kernel ADDR32 should always be zero for 2.4. GFP_HIGH allocates
  33    high pages. Keep the macro around because of the broken unmerged ia64 tree */
  34
  35 #define ADDR32 (0)
  36
  37 #include <linux/module.h>
  38
  39 MODULE_AUTHOR("Deanna Bonds, with _lots_ of help from Mark Salyzyn");
  40 MODULE_DESCRIPTION("Adaptec I2O RAID Driver");
  41
  42 ////////////////////////////////////////////////////////////////
  43
  44 #include <linux/ioctl.h>        /* For SCSI-Passthrough */
  45 #include <asm/uaccess.h>
  46
  47 #include <linux/stat.h>
  48 #include <linux/slab.h>         /* for kmalloc() */
  49 #include <linux/pci.h>          /* for PCI support */
  50 #include <linux/proc_fs.h>
  51 #include <linux/blkdev.h>
  52 #include <linux/delay.h>        /* for udelay */
  53 #include <linux/interrupt.h>
  54 #include <linux/kernel.h>       /* for printk */
  55 #include <linux/sched.h>
  56 #include <linux/reboot.h>
  57 #include <linux/spinlock.h>
  58 #include <linux/dma-mapping.h>
  59
  60 #include <linux/timer.h>
  61 #include <linux/string.h>
  62 #include <linux/ioport.h>
  63 #include <linux/mutex.h>
  64
  65 #include <asm/processor.h>      /* for boot_cpu_data */
  66 #include <asm/pgtable.h>
  67 #include <asm/io.h>             /* for virt_to_bus, etc. */
  68
  69 #include <scsi/scsi.h>
  70 #include <scsi/scsi_cmnd.h>
  71 #include <scsi/scsi_device.h>
  72 #include <scsi/scsi_host.h>
  73 #include <scsi/scsi_tcq.h>
  74
  75 #include "dpt/dptsig.h"
  76 #include "dpti.h"
  77
  78 /*============================================================================
  79  * Create a binary signature - this is read by dptsig
  80  * Needed for our management apps
  81  *============================================================================
  82  */
  83 static dpt_sig_S DPTI_sig = {
  84         {'d', 'P', 't', 'S', 'i', 'G'}, SIG_VERSION,
  85 #ifdef __i386__
  86         PROC_INTEL, PROC_386 | PROC_486 | PROC_PENTIUM | PROC_SEXIUM,
  87 #elif defined(__ia64__)
  88         PROC_INTEL, PROC_IA64,
  89 #elif defined(__sparc__)
  90         PROC_ULTRASPARC, PROC_ULTRASPARC,
  91 #elif defined(__alpha__)
  92         PROC_ALPHA, PROC_ALPHA,
  93 #else
  94         (-1),(-1),
  95 #endif
  96          FT_HBADRVR, 0, OEM_DPT, OS_LINUX, CAP_OVERLAP, DEV_ALL,
  97         ADF_ALL_SC5, 0, 0, DPT_VERSION, DPT_REVISION, DPT_SUBREVISION,
  98         DPT_MONTH, DPT_DAY, DPT_YEAR, "Adaptec Linux I2O RAID Driver"
  99 };
 100
 101
 102
 103
 104 /*============================================================================
 105  * Globals
 106  *============================================================================
 107  */
 108
 109 static DEFINE_MUTEX(adpt_configuration_lock);
 110
 111 static struct i2o_sys_tbl *sys_tbl = NULL;
 112 static int sys_tbl_ind = 0;
 113 static int sys_tbl_len = 0;
 114
 115 static adpt_hba* hba_chain = NULL;
 116 static int hba_count = 0;
 117
 118 static const struct file_operations adpt_fops = {
 119         .ioctl          = adpt_ioctl,
 120         .open           = adpt_open,
 121         .release        = adpt_close
 122 };
 123
 124 #ifdef REBOOT_NOTIFIER
 125 static struct notifier_block adpt_reboot_notifier =
 126 {
 127          adpt_reboot_event,
 128          NULL,
 129          0
 130 };
 131 #endif
 132
 133 /* Structures and definitions for synchronous message posting.
 134  * See adpt_i2o_post_wait() for description
 135  * */
 136 struct adpt_i2o_post_wait_data
 137 {
 138         int status;
 139         u32 id;
 140         adpt_wait_queue_head_t *wq;
 141         struct adpt_i2o_post_wait_data *next;
 142 };
 143
 144 static struct adpt_i2o_post_wait_data *adpt_post_wait_queue = NULL;
 145 static u32 adpt_post_wait_id = 0;
 146 static DEFINE_SPINLOCK(adpt_post_wait_lock);
 147
 148
 149 /*============================================================================
 150  *                              Functions
 151  *============================================================================
 152  */
 153
 154 static u8 adpt_read_blink_led(adpt_hba* host)
 155 {
 156         if(host->FwDebugBLEDflag_P != 0) {
 157                 if( readb(host->FwDebugBLEDflag_P) == 0xbc ){
 158                         return readb(host->FwDebugBLEDvalue_P);
 159                 }
 160         }
 161         return 0;
 162 }
 163
 164 /*============================================================================
 165  * Scsi host template interface functions
 166  *============================================================================
 167  */
 168
 169 static struct pci_device_id dptids[] = {
 170         { PCI_DPT_VENDOR_ID, PCI_DPT_DEVICE_ID, PCI_ANY_ID, PCI_ANY_ID,},
 171         { PCI_DPT_VENDOR_ID, PCI_DPT_RAPTOR_DEVICE_ID, PCI_ANY_ID, PCI_ANY_ID,},
 172         { 0, }
 173 };
 174 MODULE_DEVICE_TABLE(pci,dptids);
 175
 176 static void adpt_exit(void);
 177
 178 static int adpt_detect(void)
 179 {
 180         struct pci_dev *pDev = NULL;
 181         adpt_hba* pHba;
 182
 183         PINFO("Detecting Adaptec I2O RAID controllers...\n");
 184
 185         /* search for all Adatpec I2O RAID cards */
 186         while ((pDev = pci_get_device( PCI_DPT_VENDOR_ID, PCI_ANY_ID, pDev))) {
 187                 if(pDev->device == PCI_DPT_DEVICE_ID ||
 188                    pDev->device == PCI_DPT_RAPTOR_DEVICE_ID){
 189                         if(adpt_install_hba(pDev) ){
 190                                 PERROR("Could not Init an I2O RAID device\n");
 191                                 PERROR("Will not try to detect others.\n");
 192                                 return hba_count-1;
 193                         }
 194                         pci_dev_get(pDev);
 195                 }
 196         }
 197
 198         /* In INIT state, Activate IOPs */
 199         for (pHba = hba_chain; pHba; pHba = pHba->next) {
 200                 // Activate does get status , init outbound, and get hrt
 201                 if (adpt_i2o_activate_hba(pHba) < 0) {
 202                         adpt_i2o_delete_hba(pHba);
 203                 }
 204         }
 205
 206
 207         /* Active IOPs in HOLD state */
 208
 209 rebuild_sys_tab:
 210         if (hba_chain == NULL)
 211                 return 0;
 212
 213         /*
 214          * If build_sys_table fails, we kill everything and bail
 215          * as we can't init the IOPs w/o a system table
 216          */
 217         if (adpt_i2o_build_sys_table() < 0) {
 218                 adpt_i2o_sys_shutdown();
 219                 return 0;
 220         }
 221
 222         PDEBUG("HBA's in HOLD state\n");
 223
 224         /* If IOP don't get online, we need to rebuild the System table */
 225         for (pHba = hba_chain; pHba; pHba = pHba->next) {
 226                 if (adpt_i2o_online_hba(pHba) < 0) {
 227                         adpt_i2o_delete_hba(pHba);
 228                         goto rebuild_sys_tab;
 229                 }
 230         }
 231
 232         /* Active IOPs now in OPERATIONAL state */
 233         PDEBUG("HBA's in OPERATIONAL state\n");
 234
 235         printk("dpti: If you have a lot of devices this could take a few minutes.\n");
 236         for (pHba = hba_chain; pHba; pHba = pHba->next) {
 237                 printk(KERN_INFO"%s: Reading the hardware resource table.\n", pHba->name);
 238                 if (adpt_i2o_lct_get(pHba) < 0){
 239                         adpt_i2o_delete_hba(pHba);
 240                         continue;
 241                 }
 242
 243                 if (adpt_i2o_parse_lct(pHba) < 0){
 244                         adpt_i2o_delete_hba(pHba);
 245                         continue;
 246                 }
 247                 adpt_inquiry(pHba);
 248         }
 249
 250         for (pHba = hba_chain; pHba; pHba = pHba->next) {
 251                 if (adpt_scsi_register(pHba) < 0) {
 252                         adpt_i2o_delete_hba(pHba);
 253                         continue;
 254                 }
 255                 pHba->initialized = TRUE;
 256                 pHba->state &= ~DPTI_STATE_RESET;
 257                 scsi_scan_host(pHba->host);
 258         }
 259
 260         // Register our control device node
 261         // nodes will need to be created in /dev to access this
 262         // the nodes can not be created from within the driver
 263         if (hba_count && register_chrdev(DPTI_I2O_MAJOR, DPT_DRIVER, &adpt_fops)) {
 264                 adpt_exit();
 265                 return 0;
 266         }
 267         return hba_count;
 268 }
 269
 270
 271 static int adpt_release(adpt_hba *pHba)
 272 {
 273         struct Scsi_Host *shost = pHba->host;
 274         scsi_remove_host(shost);
 275 //      adpt_i2o_quiesce_hba(pHba);
 276         adpt_i2o_delete_hba(pHba);
 277         scsi_host_put(shost);
 278         return 0;
 279 }
 280
 281
 282 static void adpt_inquiry(adpt_hba* pHba)
 283 {
 284         u32 msg[14];
 285         u32 *mptr;
 286         u32 *lenptr;
 287         int direction;
 288         int scsidir;
 289         u32 len;
 290         u32 reqlen;
 291         u8* buf;
 292         u8  scb[16];
 293         s32 rcode;
 294
 295         memset(msg, 0, sizeof(msg));
 296         buf = kmalloc(80,GFP_KERNEL|ADDR32);
 297         if(!buf){
 298                 printk(KERN_ERR"%s: Could not allocate buffer\n",pHba->name);
 299                 return;
 300         }
 301         memset((void*)buf, 0, 36);
 302
 303         len = 36;
 304         direction = 0x00000000;
 305         scsidir  =0x40000000;   // DATA IN  (iop<--dev)
 306
 307         reqlen = 14;            // SINGLE SGE
 308         /* Stick the headers on */
 309         msg[0] = reqlen<<16 | SGL_OFFSET_12;
 310         msg[1] = (0xff<<24|HOST_TID<<12|ADAPTER_TID);
 311         msg[2] = 0;
 312         msg[3]  = 0;
 313         // Adaptec/DPT Private stuff
 314         msg[4] = I2O_CMD_SCSI_EXEC|DPT_ORGANIZATION_ID<<16;
 315         msg[5] = ADAPTER_TID | 1<<16 /* Interpret*/;
 316         /* Direction, disconnect ok | sense data | simple queue , CDBLen */
 317         // I2O_SCB_FLAG_ENABLE_DISCONNECT |
 318         // I2O_SCB_FLAG_SIMPLE_QUEUE_TAG |
 319         // I2O_SCB_FLAG_SENSE_DATA_IN_MESSAGE;
 320         msg[6] = scsidir|0x20a00000| 6 /* cmd len*/;
 321
 322         mptr=msg+7;
 323
 324         memset(scb, 0, sizeof(scb));
 325         // Write SCSI command into the message - always 16 byte block
 326         scb[0] = INQUIRY;
 327         scb[1] = 0;
 328         scb[2] = 0;
 329         scb[3] = 0;
 330         scb[4] = 36;
 331         scb[5] = 0;
 332         // Don't care about the rest of scb
 333
 334         memcpy(mptr, scb, sizeof(scb));
 335         mptr+=4;
 336         lenptr=mptr++;          /* Remember me - fill in when we know */
 337
 338         /* Now fill in the SGList and command */
 339         *lenptr = len;
 340         *mptr++ = 0xD0000000|direction|len;
 341         *mptr++ = virt_to_bus(buf);
 342
 343         // Send it on it's way
 344         rcode = adpt_i2o_post_wait(pHba, msg, reqlen<<2, 120);
 345         if (rcode != 0) {
 346                 sprintf(pHba->detail, "Adaptec I2O RAID");
 347                 printk(KERN_INFO "%s: Inquiry Error (%d)\n",pHba->name,rcode);
 348                 if (rcode != -ETIME && rcode != -EINTR)
 349                         kfree(buf);
 350         } else {
 351                 memset(pHba->detail, 0, sizeof(pHba->detail));
 352                 memcpy(&(pHba->detail), "Vendor: Adaptec ", 16);
 353                 memcpy(&(pHba->detail[16]), " Model: ", 8);
 354                 memcpy(&(pHba->detail[24]), (u8*) &buf[16], 16);
 355                 memcpy(&(pHba->detail[40]), " FW: ", 4);
 356                 memcpy(&(pHba->detail[44]), (u8*) &buf[32], 4);
 357                 pHba->detail[48] = '\0';        /* precautionary */
 358                 kfree(buf);
 359         }
 360         adpt_i2o_status_get(pHba);
 361         return ;
 362 }
 363
 364
 365 static int adpt_slave_configure(struct scsi_device * device)
 366 {
 367         struct Scsi_Host *host = device->host;
 368         adpt_hba* pHba;
 369
 370         pHba = (adpt_hba *) host->hostdata[0];
 371
 372         if (host->can_queue && device->tagged_supported) {
 373                 scsi_adjust_queue_depth(device, MSG_SIMPLE_TAG,
 374                                 host->can_queue - 1);
 375         } else {
 376                 scsi_adjust_queue_depth(device, 0, 1);
 377         }
 378         return 0;
 379 }
 380
 381 static int adpt_queue(struct scsi_cmnd * cmd, void (*done) (struct scsi_cmnd *))
 382 {
 383         adpt_hba* pHba = NULL;
 384         struct adpt_device* pDev = NULL;        /* dpt per device information */
 385
 386         cmd->scsi_done = done;
 387         /*
 388          * SCSI REQUEST_SENSE commands will be executed automatically by the
 389          * Host Adapter for any errors, so they should not be executed
 390          * explicitly unless the Sense Data is zero indicating that no error
 391          * occurred.
 392          */
 393
 394         if ((cmd->cmnd[0] == REQUEST_SENSE) && (cmd->sense_buffer[0] != 0)) {
 395                 cmd->result = (DID_OK << 16);
 396                 cmd->scsi_done(cmd);
 397                 return 0;
 398         }
 399
 400         pHba = (adpt_hba*)cmd->device->host->hostdata[0];
 401         if (!pHba) {
 402                 return FAILED;
 403         }
 404
 405         rmb();
 406         /*
 407          * TODO: I need to block here if I am processing ioctl cmds
 408          * but if the outstanding cmds all finish before the ioctl,
 409          * the scsi-core will not know to start sending cmds to me again.
 410          * I need to a way to restart the scsi-cores queues or should I block
 411          * calling scsi_done on the outstanding cmds instead
 412          * for now we don't set the IOCTL state
 413          */
 414         if(((pHba->state) & DPTI_STATE_IOCTL) || ((pHba->state) & DPTI_STATE_RESET)) {
 415                 pHba->host->last_reset = jiffies;
 416                 pHba->host->resetting = 1;
 417                 return 1;
 418         }
 419
 420         // TODO if the cmd->device if offline then I may need to issue a bus rescan
 421         // followed by a get_lct to see if the device is there anymore
 422         if((pDev = (struct adpt_device*) (cmd->device->hostdata)) == NULL) {
 423                 /*
 424                  * First command request for this device.  Set up a pointer
 425                  * to the device structure.  This should be a TEST_UNIT_READY
 426                  * command from scan_scsis_single.
 427                  */
 428                 if ((pDev = adpt_find_device(pHba, (u32)cmd->device->channel, (u32)cmd->device->id, (u32)cmd->device->lun)) == NULL) {
 429                         // TODO: if any luns are at this bus, scsi id then fake a TEST_UNIT_READY and INQUIRY response
 430                         // with type 7F (for all luns less than the max for this bus,id) so the lun scan will continue.
 431                         cmd->result = (DID_NO_CONNECT << 16);
 432                         cmd->scsi_done(cmd);
 433                         return 0;
 434                 }
 435                 cmd->device->hostdata = pDev;
 436         }
 437         pDev->pScsi_dev = cmd->device;
 438
 439         /*
 440          * If we are being called from when the device is being reset,
 441          * delay processing of the command until later.
 442          */
 443         if (pDev->state & DPTI_DEV_RESET ) {
 444                 return FAILED;
 445         }
 446         return adpt_scsi_to_i2o(pHba, cmd, pDev);
 447 }
 448
 449 static int adpt_bios_param(struct scsi_device *sdev, struct block_device *dev,
 450                 sector_t capacity, int geom[])
 451 {
 452         int heads=-1;
 453         int sectors=-1;
 454         int cylinders=-1;
 455
 456         // *** First lets set the default geometry ****
 457
 458         // If the capacity is less than ox2000
 459         if (capacity < 0x2000 ) {       // floppy
 460                 heads = 18;
 461                 sectors = 2;
 462         }
 463         // else if between 0x2000 and 0x20000
 464         else if (capacity < 0x20000) {
 465                 heads = 64;
 466                 sectors = 32;
 467         }
 468         // else if between 0x20000 and 0x40000
 469         else if (capacity < 0x40000) {
 470                 heads = 65;
 471                 sectors = 63;
 472         }
 473         // else if between 0x4000 and 0x80000
 474         else if (capacity < 0x80000) {
 475                 heads = 128;
 476                 sectors = 63;
 477         }
 478         // else if greater than 0x80000
 479         else {
 480                 heads = 255;
 481                 sectors = 63;
 482         }
 483         cylinders = sector_div(capacity, heads * sectors);
 484
 485         // Special case if CDROM
 486         if(sdev->type == 5) {  // CDROM
 487                 heads = 252;
 488                 sectors = 63;
 489                 cylinders = 1111;
 490         }
 491
 492         geom[0] = heads;
 493         geom[1] = sectors;
 494         geom[2] = cylinders;
 495
 496         PDEBUG("adpt_bios_param: exit\n");
 497         return 0;
 498 }
 499
 500
 501 static const char *adpt_info(struct Scsi_Host *host)
 502 {
 503         adpt_hba* pHba;
 504
 505         pHba = (adpt_hba *) host->hostdata[0];
 506         return (char *) (pHba->detail);
 507 }
 508
 509 static int adpt_proc_info(struct Scsi_Host *host, char *buffer, char **start, off_t offset,
 510                   int length, int inout)
 511 {
 512         struct adpt_device* d;
 513         int id;
 514         int chan;
 515         int len = 0;
 516         int begin = 0;
 517         int pos = 0;
 518         adpt_hba* pHba;
 519         int unit;
 520
 521         *start = buffer;
 522         if (inout == TRUE) {
 523                 /*
 524                  * The user has done a write and wants us to take the
 525                  * data in the buffer and do something with it.
 526                  * proc_scsiwrite calls us with inout = 1
 527                  *
 528                  * Read data from buffer (writing to us) - NOT SUPPORTED
 529                  */
 530                 return -EINVAL;
 531         }
 532
 533         /*
 534          * inout = 0 means the user has done a read and wants information
 535          * returned, so we write information about the cards into the buffer
 536          * proc_scsiread() calls us with inout = 0
 537          */
 538
 539         // Find HBA (host bus adapter) we are looking for
 540         mutex_lock(&adpt_configuration_lock);
 541         for (pHba = hba_chain; pHba; pHba = pHba->next) {
 542                 if (pHba->host == host) {
 543                         break;  /* found adapter */
 544                 }
 545         }
 546         mutex_unlock(&adpt_configuration_lock);
 547         if (pHba == NULL) {
 548                 return 0;
 549         }
 550         host = pHba->host;
 551
 552         len  = sprintf(buffer    , "Adaptec I2O RAID Driver Version: %s\n\n", DPT_I2O_VERSION);
 553         len += sprintf(buffer+len, "%s\n", pHba->detail);
 554         len += sprintf(buffer+len, "SCSI Host=scsi%d  Control Node=/dev/%s  irq=%d\n",
 555                         pHba->host->host_no, pHba->name, host->irq);
 556         len += sprintf(buffer+len, "\tpost fifo size  = %d\n\treply fifo size = %d\n\tsg table size   = %d\n\n",
 557                         host->can_queue, (int) pHba->reply_fifo_size , host->sg_tablesize);
 558
 559         pos = begin + len;
 560
 561         /* CHECKPOINT */
 562         if(pos > offset + length) {
 563                 goto stop_output;
 564         }
 565         if(pos <= offset) {
 566                 /*
 567                  * If we haven't even written to where we last left
 568                  * off (the last time we were called), reset the
 569                  * beginning pointer.
 570                  */
 571                 len = 0;
 572                 begin = pos;
 573         }
 574         len +=  sprintf(buffer+len, "Devices:\n");
 575         for(chan = 0; chan < MAX_CHANNEL; chan++) {
 576                 for(id = 0; id < MAX_ID; id++) {
 577                         d = pHba->channel[chan].device[id];
 578                         while(d){
 579                                 len += sprintf(buffer+len,"\t%-24.24s", d->pScsi_dev->vendor);
 580                                 len += sprintf(buffer+len," Rev: %-8.8s\n", d->pScsi_dev->rev);
 581                                 pos = begin + len;
 582
 583
 584                                 /* CHECKPOINT */
 585                                 if(pos > offset + length) {
 586                                         goto stop_output;
 587                                 }
 588                                 if(pos <= offset) {
 589                                         len = 0;
 590                                         begin = pos;
 591                                 }
 592
 593                                 unit = d->pI2o_dev->lct_data.tid;
 594                                 len += sprintf(buffer+len, "\tTID=%d, (Channel=%d, Target=%d, Lun=%d)  (%s)\n\n",
 595                                                unit, (int)d->scsi_channel, (int)d->scsi_id, (int)d->scsi_lun,
 596                                                scsi_device_online(d->pScsi_dev)? "online":"offline");
 597                                 pos = begin + len;
 598
 599                                 /* CHECKPOINT */
 600                                 if(pos > offset + length) {
 601                                         goto stop_output;
 602                                 }
 603                                 if(pos <= offset) {
 604                                         len = 0;
 605                                         begin = pos;
 606                                 }
 607
 608                                 d = d->next_lun;
 609                         }
 610                 }
 611         }
 612
 613         /*
 614          * begin is where we last checked our position with regards to offset
 615          * begin is always less than offset.  len is relative to begin.  It
 616          * is the number of bytes written past begin
 617          *
 618          */
 619 stop_output:
 620         /* stop the output and calculate the correct length */
 621         *(buffer + len) = '\0';
 622
 623         *start = buffer + (offset - begin);     /* Start of wanted data */
 624         len -= (offset - begin);
 625         if(len > length) {
 626                 len = length;
 627         } else if(len < 0){
 628                 len = 0;
 629                 **start = '\0';
 630         }
 631         return len;
 632 }
 633
 634
 635 /*===========================================================================
 636  * Error Handling routines
 637  *===========================================================================
 638  */
 639
 640 static int adpt_abort(struct scsi_cmnd * cmd)
 641 {
 642         adpt_hba* pHba = NULL;  /* host bus adapter structure */
 643         struct adpt_device* dptdevice;  /* dpt per device information */
 644         u32 msg[5];
 645         int rcode;
 646
 647         if(cmd->serial_number == 0){
 648                 return FAILED;
 649         }
 650         pHba = (adpt_hba*) cmd->device->host->hostdata[0];
 651         printk(KERN_INFO"%s: Trying to Abort cmd=%ld\n",pHba->name, cmd->serial_number);
 652         if ((dptdevice = (void*) (cmd->device->hostdata)) == NULL) {
 653                 printk(KERN_ERR "%s: Unable to abort: No device in cmnd\n",pHba->name);
 654                 return FAILED;
 655         }
 656
 657         memset(msg, 0, sizeof(msg));
 658         msg[0] = FIVE_WORD_MSG_SIZE|SGL_OFFSET_0;
 659         msg[1] = I2O_CMD_SCSI_ABORT<<24|HOST_TID<<12|dptdevice->tid;
 660         msg[2] = 0;
 661         msg[3]= 0;
 662         msg[4] = (u32)cmd;
 663         if (pHba->host)
 664                 spin_lock_irq(pHba->host->host_lock);
 665         rcode = adpt_i2o_post_wait(pHba, msg, sizeof(msg), FOREVER);
 666         if (pHba->host)
 667                 spin_unlock_irq(pHba->host->host_lock);
 668         if (rcode != 0) {
 669                 if(rcode == -EOPNOTSUPP ){
 670                         printk(KERN_INFO"%s: Abort cmd not supported\n",pHba->name);
 671                         return FAILED;
 672                 }
 673                 printk(KERN_INFO"%s: Abort cmd=%ld failed.\n",pHba->name, cmd->serial_number);
 674                 return FAILED;
 675         }
 676         printk(KERN_INFO"%s: Abort cmd=%ld complete.\n",pHba->name, cmd->serial_number);
 677         return SUCCESS;
 678 }
 679
 680
 681 #define I2O_DEVICE_RESET 0x27
 682 // This is the same for BLK and SCSI devices
 683 // NOTE this is wrong in the i2o.h definitions
 684 // This is not currently supported by our adapter but we issue it anyway
 685 static int adpt_device_reset(struct scsi_cmnd* cmd)
 686 {
 687         adpt_hba* pHba;
 688         u32 msg[4];
 689         u32 rcode;
 690         int old_state;
 691         struct adpt_device* d = cmd->device->hostdata;
 692
 693         pHba = (void*) cmd->device->host->hostdata[0];
 694         printk(KERN_INFO"%s: Trying to reset device\n",pHba->name);
 695         if (!d) {
 696                 printk(KERN_INFO"%s: Reset Device: Device Not found\n",pHba->name);
 697                 return FAILED;
 698         }
 699         memset(msg, 0, sizeof(msg));
 700         msg[0] = FOUR_WORD_MSG_SIZE|SGL_OFFSET_0;
 701         msg[1] = (I2O_DEVICE_RESET<<24|HOST_TID<<12|d->tid);
 702         msg[2] = 0;
 703         msg[3] = 0;
 704
 705         if (pHba->host)
 706                 spin_lock_irq(pHba->host->host_lock);
 707         old_state = d->state;
 708         d->state |= DPTI_DEV_RESET;
 709         rcode = adpt_i2o_post_wait(pHba, msg,sizeof(msg), FOREVER);
 710         d->state = old_state;
 711         if (pHba->host)
 712                 spin_unlock_irq(pHba->host->host_lock);
 713         if (rcode != 0) {
 714                 if(rcode == -EOPNOTSUPP ){
 715                         printk(KERN_INFO"%s: Device reset not supported\n",pHba->name);
 716                         return FAILED;
 717                 }
 718                 printk(KERN_INFO"%s: Device reset failed\n",pHba->name);
 719                 return FAILED;
 720         } else {
 721                 printk(KERN_INFO"%s: Device reset successful\n",pHba->name);
 722                 return SUCCESS;
 723         }
 724 }
 725
 726
 727 #define I2O_HBA_BUS_RESET 0x87
 728 // This version of bus reset is called by the eh_error handler
 729 static int adpt_bus_reset(struct scsi_cmnd* cmd)
 730 {
 731         adpt_hba* pHba;
 732         u32 msg[4];
 733         u32 rcode;
 734
 735         pHba = (adpt_hba*)cmd->device->host->hostdata[0];
 736         memset(msg, 0, sizeof(msg));
 737         printk(KERN_WARNING"%s: Bus reset: SCSI Bus %d: tid: %d\n",pHba->name, cmd->device->channel,pHba->channel[cmd->device->channel].tid );
 738         msg[0] = FOUR_WORD_MSG_SIZE|SGL_OFFSET_0;
 739         msg[1] = (I2O_HBA_BUS_RESET<<24|HOST_TID<<12|pHba->channel[cmd->device->channel].tid);
 740         msg[2] = 0;
 741         msg[3] = 0;
 742         if (pHba->host)
 743                 spin_lock_irq(pHba->host->host_lock);
 744         rcode = adpt_i2o_post_wait(pHba, msg,sizeof(msg), FOREVER);
 745         if (pHba->host)
 746                 spin_unlock_irq(pHba->host->host_lock);
 747         if (rcode != 0) {
 748                 printk(KERN_WARNING"%s: Bus reset failed.\n",pHba->name);
 749                 return FAILED;
 750         } else {
 751                 printk(KERN_WARNING"%s: Bus reset success.\n",pHba->name);
 752                 return SUCCESS;
 753         }
 754 }
 755
 756 // This version of reset is called by the eh_error_handler
 757 static int __adpt_reset(struct scsi_cmnd* cmd)
 758 {
 759         adpt_hba* pHba;
 760         int rcode;
 761         pHba = (adpt_hba*)cmd->device->host->hostdata[0];
 762         printk(KERN_WARNING"%s: Hba Reset: scsi id %d: tid: %d\n",pHba->name,cmd->device->channel,pHba->channel[cmd->device->channel].tid );
 763         rcode =  adpt_hba_reset(pHba);
 764         if(rcode == 0){
 765                 printk(KERN_WARNING"%s: HBA reset complete\n",pHba->name);
 766                 return SUCCESS;
 767         } else {
 768                 printk(KERN_WARNING"%s: HBA reset failed (%x)\n",pHba->name, rcode);
 769                 return FAILED;
 770         }
 771 }
 772
 773 static int adpt_reset(struct scsi_cmnd* cmd)
 774 {
 775         int rc;
 776
 777         spin_lock_irq(cmd->device->host->host_lock);
 778         rc = __adpt_reset(cmd);
 779         spin_unlock_irq(cmd->device->host->host_lock);
 780
 781         return rc;
 782 }
 783
 784 // This version of reset is called by the ioctls and indirectly from eh_error_handler via adpt_reset
 785 static int adpt_hba_reset(adpt_hba* pHba)
 786 {
 787         int rcode;
 788
 789         pHba->state |= DPTI_STATE_RESET;
 790
 791         // Activate does get status , init outbound, and get hrt
 792         if ((rcode=adpt_i2o_activate_hba(pHba)) < 0) {
 793                 printk(KERN_ERR "%s: Could not activate\n", pHba->name);
 794                 adpt_i2o_delete_hba(pHba);
 795                 return rcode;
 796         }
 797
 798         if ((rcode=adpt_i2o_build_sys_table()) < 0) {
 799                 adpt_i2o_delete_hba(pHba);
 800                 return rcode;
 801         }
 802         PDEBUG("%s: in HOLD state\n",pHba->name);
 803
 804         if ((rcode=adpt_i2o_online_hba(pHba)) < 0) {
 805                 adpt_i2o_delete_hba(pHba);
 806                 return rcode;
 807         }
 808         PDEBUG("%s: in OPERATIONAL state\n",pHba->name);
 809
 810         if ((rcode=adpt_i2o_lct_get(pHba)) < 0){
 811                 adpt_i2o_delete_hba(pHba);
 812                 return rcode;
 813         }
 814
 815         if ((rcode=adpt_i2o_reparse_lct(pHba)) < 0){
 816                 adpt_i2o_delete_hba(pHba);
 817                 return rcode;
 818         }
 819         pHba->state &= ~DPTI_STATE_RESET;
 820
 821         adpt_fail_posted_scbs(pHba);
 822         return 0;       /* return success */
 823 }
 824
 825 /*===========================================================================
 826  *
 827  *===========================================================================
 828  */
 829
 830
 831 static void adpt_i2o_sys_shutdown(void)
 832 {
 833         adpt_hba *pHba, *pNext;
 834         struct adpt_i2o_post_wait_data *p1, *old;
 835
 836          printk(KERN_INFO"Shutting down Adaptec I2O controllers.\n");
 837          printk(KERN_INFO"   This could take a few minutes if there are many devices attached\n");
 838         /* Delete all IOPs from the controller chain */
 839         /* They should have already been released by the
 840          * scsi-core
 841          */
 842         for (pHba = hba_chain; pHba; pHba = pNext) {
 843                 pNext = pHba->next;
 844                 adpt_i2o_delete_hba(pHba);
 845         }
 846
 847         /* Remove any timedout entries from the wait queue.  */
 848 //      spin_lock_irqsave(&adpt_post_wait_lock, flags);
 849         /* Nothing should be outstanding at this point so just
 850          * free them
 851          */
 852         for(p1 = adpt_post_wait_queue; p1;) {
 853                 old = p1;
 854                 p1 = p1->next;
 855                 kfree(old);
 856         }
 857 //      spin_unlock_irqrestore(&adpt_post_wait_lock, flags);
 858         adpt_post_wait_queue = NULL;
 859
 860          printk(KERN_INFO "Adaptec I2O controllers down.\n");
 861 }
 862
 863 /*
 864  * reboot/shutdown notification.
 865  *
 866  * - Quiesce each IOP in the system
 867  *
 868  */
 869
 870 #ifdef REBOOT_NOTIFIER
 871 static int adpt_reboot_event(struct notifier_block *n, ulong code, void *p)
 872 {
 873
 874          if(code != SYS_RESTART && code != SYS_HALT && code != SYS_POWER_OFF)
 875                   return NOTIFY_DONE;
 876
 877          adpt_i2o_sys_shutdown();
 878
 879          return NOTIFY_DONE;
 880 }
 881 #endif
 882
 883
 884 static int adpt_install_hba(struct pci_dev* pDev)
 885 {
 886
 887         adpt_hba* pHba = NULL;
 888         adpt_hba* p = NULL;
 889         ulong base_addr0_phys = 0;
 890         ulong base_addr1_phys = 0;
 891         u32 hba_map0_area_size = 0;
 892         u32 hba_map1_area_size = 0;
 893         void __iomem *base_addr_virt = NULL;
 894         void __iomem *msg_addr_virt = NULL;
 895
 896         int raptorFlag = FALSE;
 897
 898         if(pci_enable_device(pDev)) {
 899                 return -EINVAL;
 900         }
 901
 902         if (pci_request_regions(pDev, "dpt_i2o")) {
 903                 PERROR("dpti: adpt_config_hba: pci request region failed\n");
 904                 return -EINVAL;
 905         }
 906
 907         pci_set_master(pDev);
 908         if (pci_set_dma_mask(pDev, DMA_64BIT_MASK) &&
 909             pci_set_dma_mask(pDev, DMA_32BIT_MASK))
 910                 return -EINVAL;
 911
 912         base_addr0_phys = pci_resource_start(pDev,0);
 913         hba_map0_area_size = pci_resource_len(pDev,0);
 914
 915         // Check if standard PCI card or single BAR Raptor
 916         if(pDev->device == PCI_DPT_DEVICE_ID){
 917                 if(pDev->subsystem_device >=0xc032 && pDev->subsystem_device <= 0xc03b){
 918                         // Raptor card with this device id needs 4M
 919                         hba_map0_area_size = 0x400000;
 920                 } else { // Not Raptor - it is a PCI card
 921                         if(hba_map0_area_size > 0x100000 ){
 922                                 hba_map0_area_size = 0x100000;
 923                         }
 924                 }
 925         } else {// Raptor split BAR config
 926                 // Use BAR1 in this configuration
 927                 base_addr1_phys = pci_resource_start(pDev,1);
 928                 hba_map1_area_size = pci_resource_len(pDev,1);
 929                 raptorFlag = TRUE;
 930         }
 931
 932         base_addr_virt = ioremap(base_addr0_phys,hba_map0_area_size);
 933         if (!base_addr_virt) {
 934                 pci_release_regions(pDev);
 935                 PERROR("dpti: adpt_config_hba: io remap failed\n");
 936                 return -EINVAL;
 937         }
 938
 939         if(raptorFlag == TRUE) {
 940                 msg_addr_virt = ioremap(base_addr1_phys, hba_map1_area_size );
 941                 if (!msg_addr_virt) {
 942                         PERROR("dpti: adpt_config_hba: io remap failed on BAR1\n");
 943                         iounmap(base_addr_virt);
 944                         pci_release_regions(pDev);
 945                         return -EINVAL;
 946                 }
 947         } else {
 948                 msg_addr_virt = base_addr_virt;
 949         }
 950
 951         // Allocate and zero the data structure
 952         pHba = kmalloc(sizeof(adpt_hba), GFP_KERNEL);
 953         if( pHba == NULL) {
 954                 if(msg_addr_virt != base_addr_virt){
 955                         iounmap(msg_addr_virt);
 956                 }
 957                 iounmap(base_addr_virt);
 958                 pci_release_regions(pDev);
 959                 return -ENOMEM;
 960         }
 961         memset(pHba, 0, sizeof(adpt_hba));
 962
 963         mutex_lock(&adpt_configuration_lock);
 964
 965         if(hba_chain != NULL){
 966                 for(p = hba_chain; p->next; p = p->next);
 967                 p->next = pHba;
 968         } else {
 969                 hba_chain = pHba;
 970         }
 971         pHba->next = NULL;
 972         pHba->unit = hba_count;
 973         sprintf(pHba->name, "dpti%d", hba_count);
 974         hba_count++;
 975
 976         mutex_unlock(&adpt_configuration_lock);
 977
 978         pHba->pDev = pDev;
 979         pHba->base_addr_phys = base_addr0_phys;
 980
 981         // Set up the Virtual Base Address of the I2O Device
 982         pHba->base_addr_virt = base_addr_virt;
 983         pHba->msg_addr_virt = msg_addr_virt;
 984         pHba->irq_mask = base_addr_virt+0x30;
 985         pHba->post_port = base_addr_virt+0x40;
 986         pHba->reply_port = base_addr_virt+0x44;
 987
 988         pHba->hrt = NULL;
 989         pHba->lct = NULL;
 990         pHba->lct_size = 0;
 991         pHba->status_block = NULL;
 992         pHba->post_count = 0;
 993         pHba->state = DPTI_STATE_RESET;
 994         pHba->pDev = pDev;
 995         pHba->devices = NULL;
 996
 997         // Initializing the spinlocks
 998         spin_lock_init(&pHba->state_lock);
 999         spin_lock_init(&adpt_post_wait_lock);
1000
1001         if(raptorFlag == 0){
1002                 printk(KERN_INFO"Adaptec I2O RAID controller %d at %p size=%x irq=%d\n",
1003                         hba_count-1, base_addr_virt, hba_map0_area_size, pDev->irq);
1004         } else {
1005                 printk(KERN_INFO"Adaptec I2O RAID controller %d irq=%d\n",hba_count-1, pDev->irq);
1006                 printk(KERN_INFO"     BAR0 %p - size= %x\n",base_addr_virt,hba_map0_area_size);
1007                 printk(KERN_INFO"     BAR1 %p - size= %x\n",msg_addr_virt,hba_map1_area_size);
1008         }
1009
1010         if (request_irq (pDev->irq, adpt_isr, IRQF_SHARED, pHba->name, pHba)) {
1011                 printk(KERN_ERR"%s: Couldn't register IRQ %d\n", pHba->name, pDev->irq);
1012                 adpt_i2o_delete_hba(pHba);
1013                 return -EINVAL;
1014         }
1015
1016         return 0;
1017 }
1018
1019
1020 static void adpt_i2o_delete_hba(adpt_hba* pHba)
1021 {
1022         adpt_hba* p1;
1023         adpt_hba* p2;
1024         struct i2o_device* d;
1025         struct i2o_device* next;
1026         int i;
1027         int j;
1028         struct adpt_device* pDev;
1029         struct adpt_device* pNext;
1030
1031
1032         mutex_lock(&adpt_configuration_lock);
1033         if(pHba->host){
1034                 free_irq(pHba->host->irq, pHba);
1035         }
1036         p2 = NULL;
1037         for( p1 = hba_chain; p1; p2 = p1,p1=p1->next){
1038                 if(p1 == pHba) {
1039                         if(p2) {
1040                                 p2->next = p1->next;
1041                         } else {
1042                                 hba_chain = p1->next;
1043                         }
1044                         break;
1045                 }
1046         }
1047
1048         hba_count--;
1049         mutex_unlock(&adpt_configuration_lock);
1050
1051         iounmap(pHba->base_addr_virt);
1052         pci_release_regions(pHba->pDev);
1053         if(pHba->msg_addr_virt != pHba->base_addr_virt){
1054                 iounmap(pHba->msg_addr_virt);
1055         }
1056         kfree(pHba->hrt);
1057         kfree(pHba->lct);
1058         kfree(pHba->status_block);
1059         kfree(pHba->reply_pool);
1060
1061         for(d = pHba->devices; d ; d = next){
1062                 next = d->next;
1063                 kfree(d);
1064         }
1065         for(i = 0 ; i < pHba->top_scsi_channel ; i++){
1066                 for(j = 0; j < MAX_ID; j++){
1067                         if(pHba->channel[i].device[j] != NULL){
1068                                 for(pDev = pHba->channel[i].device[j]; pDev; pDev = pNext){
1069                                         pNext = pDev->next_lun;
1070                                         kfree(pDev);
1071                                 }
1072                         }
1073                 }
1074         }
1075         pci_dev_put(pHba->pDev);
1076         kfree(pHba);
1077
1078         if(hba_count <= 0){
1079                 unregister_chrdev(DPTI_I2O_MAJOR, DPT_DRIVER);
1080         }
1081 }
1082
1083
1084 static struct adpt_device* adpt_find_device(adpt_hba* pHba, u32 chan, u32 id, u32 lun)
1085 {
1086         struct adpt_device* d;
1087
1088         if(chan < 0 || chan >= MAX_CHANNEL)
1089                 return NULL;
1090
1091         if( pHba->channel[chan].device == NULL){
1092                 printk(KERN_DEBUG"Adaptec I2O RAID: Trying to find device before they are allocated\n");
1093                 return NULL;
1094         }
1095
1096         d = pHba->channel[chan].device[id];
1097         if(!d || d->tid == 0) {
1098                 return NULL;
1099         }
1100
1101         /* If it is the only lun at that address then this should match*/
1102         if(d->scsi_lun == lun){
1103                 return d;
1104         }
1105
1106         /* else we need to look through all the luns */
1107         for(d=d->next_lun ; d ; d = d->next_lun){
1108                 if(d->scsi_lun == lun){
1109                         return d;
1110                 }
1111         }
1112         return NULL;
1113 }
1114
1115
1116 static int adpt_i2o_post_wait(adpt_hba* pHba, u32* msg, int len, int timeout)
1117 {
1118         // I used my own version of the WAIT_QUEUE_HEAD
1119         // to handle some version differences
1120         // When embedded in the kernel this could go back to the vanilla one
1121         ADPT_DECLARE_WAIT_QUEUE_HEAD(adpt_wq_i2o_post);
1122         int status = 0;
1123         ulong flags = 0;
1124         struct adpt_i2o_post_wait_data *p1, *p2;
1125         struct adpt_i2o_post_wait_data *wait_data =
1126                 kmalloc(sizeof(struct adpt_i2o_post_wait_data),GFP_KERNEL);
1127         DECLARE_WAITQUEUE(wait, current);
1128
1129         if (!wait_data)
1130                 return -ENOMEM;
1131
1132         /*
1133          * The spin locking is needed to keep anyone from playing
1134          * with the queue pointers and id while we do the same
1135          */
1136         spin_lock_irqsave(&adpt_post_wait_lock, flags);
1137        // TODO we need a MORE unique way of getting ids
1138        // to support async LCT get
1139         wait_data->next = adpt_post_wait_queue;
1140         adpt_post_wait_queue = wait_data;
1141         adpt_post_wait_id++;
1142         adpt_post_wait_id &= 0x7fff;
1143         wait_data->id =  adpt_post_wait_id;
1144         spin_unlock_irqrestore(&adpt_post_wait_lock, flags);
1145
1146         wait_data->wq = &adpt_wq_i2o_post;
1147         wait_data->status = -ETIMEDOUT;
1148
1149         add_wait_queue(&adpt_wq_i2o_post, &wait);
1150
1151         msg[2] |= 0x80000000 | ((u32)wait_data->id);
1152         timeout *= HZ;
1153         if((status = adpt_i2o_post_this(pHba, msg, len)) == 0){
1154                 set_current_state(TASK_INTERRUPTIBLE);
1155                 if(pHba->host)
1156                         spin_unlock_irq(pHba->host->host_lock);
1157                 if (!timeout)
1158                         schedule();
1159                 else{
1160                         timeout = schedule_timeout(timeout);
1161                         if (timeout == 0) {
1162                                 // I/O issued, but cannot get result in
1163                                 // specified time. Freeing resorces is
1164                                 // dangerous.
1165                                 status = -ETIME;
1166                         }
1167                 }
1168                 if(pHba->host)
1169                         spin_lock_irq(pHba->host->host_lock);
1170         }
1171         remove_wait_queue(&adpt_wq_i2o_post, &wait);
1172
1173         if(status == -ETIMEDOUT){
1174                 printk(KERN_INFO"dpti%d: POST WAIT TIMEOUT\n",pHba->unit);
1175                 // We will have to free the wait_data memory during shutdown
1176                 return status;
1177         }
1178
1179         /* Remove the entry from the queue.  */
1180         p2 = NULL;
1181         spin_lock_irqsave(&adpt_post_wait_lock, flags);
1182         for(p1 = adpt_post_wait_queue; p1; p2 = p1, p1 = p1->next) {
1183                 if(p1 == wait_data) {
1184                         if(p1->status == I2O_DETAIL_STATUS_UNSUPPORTED_FUNCTION ) {
1185                                 status = -EOPNOTSUPP;
1186                         }
1187                         if(p2) {
1188                                 p2->next = p1->next;
1189                         } else {
1190                                 adpt_post_wait_queue = p1->next;
1191                         }
1192                         break;
1193                 }
1194         }
1195         spin_unlock_irqrestore(&adpt_post_wait_lock, flags);
1196
1197         kfree(wait_data);
1198
1199         return status;
1200 }
1201
1202
1203 static s32 adpt_i2o_post_this(adpt_hba* pHba, u32* data, int len)
1204 {
1205
1206         u32 m = EMPTY_QUEUE;
1207         u32 __iomem *msg;
1208         ulong timeout = jiffies + 30*HZ;
1209         do {
1210                 rmb();
1211                 m = readl(pHba->post_port);
1212                 if (m != EMPTY_QUEUE) {
1213                         break;
1214                 }
1215                 if(time_after(jiffies,timeout)){
1216                         printk(KERN_WARNING"dpti%d: Timeout waiting for message frame!\n", pHba->unit);
1217                         return -ETIMEDOUT;
1218                 }
1219                 schedule_timeout_uninterruptible(1);
1220         } while(m == EMPTY_QUEUE);
1221
1222         msg = pHba->msg_addr_virt + m;
1223         memcpy_toio(msg, data, len);
1224         wmb();
1225
1226         //post message
1227         writel(m, pHba->post_port);
1228         wmb();
1229
1230         return 0;
1231 }
1232
1233
1234 static void adpt_i2o_post_wait_complete(u32 context, int status)
1235 {
1236         struct adpt_i2o_post_wait_data *p1 = NULL;
1237         /*
1238          * We need to search through the adpt_post_wait
1239          * queue to see if the given message is still
1240          * outstanding.  If not, it means that the IOP
1241          * took longer to respond to the message than we
1242          * had allowed and timer has already expired.
1243          * Not much we can do about that except log
1244          * it for debug purposes, increase timeout, and recompile
1245          *
1246          * Lock needed to keep anyone from moving queue pointers
1247          * around while we're looking through them.
1248          */
1249
1250         context &= 0x7fff;
1251
1252         spin_lock(&adpt_post_wait_lock);
1253         for(p1 = adpt_post_wait_queue; p1; p1 = p1->next) {
1254                 if(p1->id == context) {
1255                         p1->status = status;
1256                         spin_unlock(&adpt_post_wait_lock);
1257                         wake_up_interruptible(p1->wq);
1258                         return;
1259                 }
1260         }
1261         spin_unlock(&adpt_post_wait_lock);
1262         // If this happens we lose commands that probably really completed
1263         printk(KERN_DEBUG"dpti: Could Not find task %d in wait queue\n",context);
1264         printk(KERN_DEBUG"      Tasks in wait queue:\n");
1265         for(p1 = adpt_post_wait_queue; p1; p1 = p1->next) {
1266                 printk(KERN_DEBUG"           %d\n",p1->id);
1267         }
1268         return;
1269 }
1270
1271 static s32 adpt_i2o_reset_hba(adpt_hba* pHba)
1272 {
1273         u32 msg[8];
1274         u8* status;
1275         u32 m = EMPTY_QUEUE ;
1276         ulong timeout = jiffies + (TMOUT_IOPRESET*HZ);
1277
1278         if(pHba->initialized  == FALSE) {       // First time reset should be quick
1279                 timeout = jiffies + (25*HZ);
1280         } else {
1281                 adpt_i2o_quiesce_hba(pHba);
1282         }
1283
1284         do {
1285                 rmb();
1286                 m = readl(pHba->post_port);
1287                 if (m != EMPTY_QUEUE) {
1288                         break;
1289                 }
1290                 if(time_after(jiffies,timeout)){
1291                         printk(KERN_WARNING"Timeout waiting for message!\n");
1292                         return -ETIMEDOUT;
1293                 }
1294                 schedule_timeout_uninterruptible(1);
1295         } while (m == EMPTY_QUEUE);
1296
1297         status = kzalloc(4, GFP_KERNEL|ADDR32);
1298         if(status == NULL) {
1299                 adpt_send_nop(pHba, m);
1300                 printk(KERN_ERR"IOP reset failed - no free memory.\n");
1301                 return -ENOMEM;
1302         }
1303
1304         msg[0]=EIGHT_WORD_MSG_SIZE|SGL_OFFSET_0;
1305         msg[1]=I2O_CMD_ADAPTER_RESET<<24|HOST_TID<<12|ADAPTER_TID;
1306         msg[2]=0;
1307         msg[3]=0;
1308         msg[4]=0;
1309         msg[5]=0;
1310         msg[6]=virt_to_bus(status);
1311         msg[7]=0;
1312
1313         memcpy_toio(pHba->msg_addr_virt+m, msg, sizeof(msg));
1314         wmb();
1315         writel(m, pHba->post_port);
1316         wmb();
1317
1318         while(*status == 0){
1319                 if(time_after(jiffies,timeout)){
1320                         printk(KERN_WARNING"%s: IOP Reset Timeout\n",pHba->name);
1321                         kfree(status);
1322                         return -ETIMEDOUT;
1323                 }
1324                 rmb();
1325                 schedule_timeout_uninterruptible(1);
1326         }
1327
1328         if(*status == 0x01 /*I2O_EXEC_IOP_RESET_IN_PROGRESS*/) {
1329                 PDEBUG("%s: Reset in progress...\n", pHba->name);
1330                 // Here we wait for message frame to become available
1331                 // indicated that reset has finished
1332                 do {
1333                         rmb();
1334                         m = readl(pHba->post_port);
1335                         if (m != EMPTY_QUEUE) {
1336                                 break;
1337                         }
1338                         if(time_after(jiffies,timeout)){
1339                                 printk(KERN_ERR "%s:Timeout waiting for IOP Reset.\n",pHba->name);
1340                                 return -ETIMEDOUT;
1341                         }
1342                         schedule_timeout_uninterruptible(1);
1343                 } while (m == EMPTY_QUEUE);
1344                 // Flush the offset
1345                 adpt_send_nop(pHba, m);
1346         }
1347         adpt_i2o_status_get(pHba);
1348         if(*status == 0x02 ||
1349                         pHba->status_block->iop_state != ADAPTER_STATE_RESET) {
1350                 printk(KERN_WARNING"%s: Reset reject, trying to clear\n",
1351                                 pHba->name);
1352         } else {
1353                 PDEBUG("%s: Reset completed.\n", pHba->name);
1354         }
1355
1356         kfree(status);
1357 #ifdef UARTDELAY
1358         // This delay is to allow someone attached to the card through the debug UART to
1359         // set up the dump levels that they want before the rest of the initialization sequence
1360         adpt_delay(20000);
1361 #endif
1362         return 0;
1363 }
1364
1365
1366 static int adpt_i2o_parse_lct(adpt_hba* pHba)
1367 {
1368         int i;
1369         int max;
1370         int tid;
1371         struct i2o_device *d;
1372         i2o_lct *lct = pHba->lct;
1373         u8 bus_no = 0;
1374         s16 scsi_id;
1375         s16 scsi_lun;
1376         u32 buf[10]; // larger than 7, or 8 ...
1377         struct adpt_device* pDev;
1378
1379         if (lct == NULL) {
1380                 printk(KERN_ERR "%s: LCT is empty???\n",pHba->name);
1381                 return -1;
1382         }
1383
1384         max = lct->table_size;
1385         max -= 3;
1386         max /= 9;
1387
1388         for(i=0;i<max;i++) {
1389                 if( lct->lct_entry[i].user_tid != 0xfff){
1390                         /*
1391                          * If we have hidden devices, we need to inform the upper layers about
1392                          * the possible maximum id reference to handle device access when
1393                          * an array is disassembled. This code has no other purpose but to
1394                          * allow us future access to devices that are currently hidden
1395                          * behind arrays, hotspares or have not been configured (JBOD mode).
1396                          */
1397                         if( lct->lct_entry[i].class_id != I2O_CLASS_RANDOM_BLOCK_STORAGE &&
1398                             lct->lct_entry[i].class_id != I2O_CLASS_SCSI_PERIPHERAL &&
1399                             lct->lct_entry[i].class_id != I2O_CLASS_FIBRE_CHANNEL_PERIPHERAL ){
1400                                 continue;
1401                         }
1402                         tid = lct->lct_entry[i].tid;
1403                         // I2O_DPT_DEVICE_INFO_GROUP_NO;
1404                         if(adpt_i2o_query_scalar(pHba, tid, 0x8000, -1, buf, 32)<0) {
1405                                 continue;
1406                         }
1407                         bus_no = buf[0]>>16;
1408                         scsi_id = buf[1];
1409                         scsi_lun = (buf[2]>>8 )&0xff;
1410                         if(bus_no >= MAX_CHANNEL) {     // Something wrong skip it
1411                                 printk(KERN_WARNING"%s: Channel number %d out of range \n", pHba->name, bus_no);
1412                                 continue;
1413                         }
1414                         if (scsi_id >= MAX_ID){
1415                                 printk(KERN_WARNING"%s: SCSI ID %d out of range \n", pHba->name, bus_no);
1416                                 continue;
1417                         }
1418                         if(bus_no > pHba->top_scsi_channel){
1419                                 pHba->top_scsi_channel = bus_no;
1420                         }
1421                         if(scsi_id > pHba->top_scsi_id){
1422                                 pHba->top_scsi_id = scsi_id;
1423                         }
1424                         if(scsi_lun > pHba->top_scsi_lun){
1425                                 pHba->top_scsi_lun = scsi_lun;
1426                         }
1427                         continue;
1428                 }
1429                 d = kmalloc(sizeof(struct i2o_device), GFP_KERNEL);
1430                 if(d==NULL)
1431                 {
1432                         printk(KERN_CRIT"%s: Out of memory for I2O device data.\n",pHba->name);
1433                         return -ENOMEM;
1434                 }
1435
1436                 d->controller = pHba;
1437                 d->next = NULL;
1438
1439                 memcpy(&d->lct_data, &lct->lct_entry[i], sizeof(i2o_lct_entry));
1440
1441                 d->flags = 0;
1442                 tid = d->lct_data.tid;
1443                 adpt_i2o_report_hba_unit(pHba, d);
1444                 adpt_i2o_install_device(pHba, d);
1445         }
1446         bus_no = 0;
1447         for(d = pHba->devices; d ; d = d->next) {
1448                 if(d->lct_data.class_id  == I2O_CLASS_BUS_ADAPTER_PORT ||
1449                    d->lct_data.class_id  == I2O_CLASS_FIBRE_CHANNEL_PORT){
1450                         tid = d->lct_data.tid;
1451                         // TODO get the bus_no from hrt-but for now they are in order
1452                         //bus_no =
1453                         if(bus_no > pHba->top_scsi_channel){
1454                                 pHba->top_scsi_channel = bus_no;
1455                         }
1456                         pHba->channel[bus_no].type = d->lct_data.class_id;
1457                         pHba->channel[bus_no].tid = tid;
1458                         if(adpt_i2o_query_scalar(pHba, tid, 0x0200, -1, buf, 28)>=0)
1459                         {
1460                                 pHba->channel[bus_no].scsi_id = buf[1];
1461                                 PDEBUG("Bus %d - SCSI ID %d.\n", bus_no, buf[1]);
1462                         }
1463                         // TODO remove - this is just until we get from hrt
1464                         bus_no++;
1465                         if(bus_no >= MAX_CHANNEL) {     // Something wrong skip it
1466                                 printk(KERN_WARNING"%s: Channel number %d out of range - LCT\n", pHba->name, bus_no);
1467                                 break;
1468                         }
1469                 }
1470         }
1471
1472         // Setup adpt_device table
1473         for(d = pHba->devices; d ; d = d->next) {
1474                 if(d->lct_data.class_id  == I2O_CLASS_RANDOM_BLOCK_STORAGE ||
1475                    d->lct_data.class_id  == I2O_CLASS_SCSI_PERIPHERAL ||
1476                    d->lct_data.class_id  == I2O_CLASS_FIBRE_CHANNEL_PERIPHERAL ){
1477
1478                         tid = d->lct_data.tid;
1479                         scsi_id = -1;
1480                         // I2O_DPT_DEVICE_INFO_GROUP_NO;
1481                         if(adpt_i2o_query_scalar(pHba, tid, 0x8000, -1, buf, 32)>=0) {
1482                                 bus_no = buf[0]>>16;
1483                                 scsi_id = buf[1];
1484                                 scsi_lun = (buf[2]>>8 )&0xff;
1485                                 if(bus_no >= MAX_CHANNEL) {     // Something wrong skip it
1486                                         continue;
1487                                 }
1488                                 if (scsi_id >= MAX_ID) {
1489                                         continue;
1490                                 }
1491                                 if( pHba->channel[bus_no].device[scsi_id] == NULL){
1492                                         pDev =  kzalloc(sizeof(struct adpt_device),GFP_KERNEL);
1493                                         if(pDev == NULL) {
1494                                                 return -ENOMEM;
1495                                         }
1496                                         pHba->channel[bus_no].device[scsi_id] = pDev;
1497                                 } else {
1498                                         for( pDev = pHba->channel[bus_no].device[scsi_id];
1499                                                         pDev->next_lun; pDev = pDev->next_lun){
1500                                         }
1501                                         pDev->next_lun = kzalloc(sizeof(struct adpt_device),GFP_KERNEL);
1502                                         if(pDev->next_lun == NULL) {
1503                                                 return -ENOMEM;
1504                                         }
1505                                         pDev = pDev->next_lun;
1506                                 }
1507                                 pDev->tid = tid;
1508                                 pDev->scsi_channel = bus_no;
1509                                 pDev->scsi_id = scsi_id;
1510                                 pDev->scsi_lun = scsi_lun;
1511                                 pDev->pI2o_dev = d;
1512                                 d->owner = pDev;
1513                                 pDev->type = (buf[0])&0xff;
1514                                 pDev->flags = (buf[0]>>8)&0xff;
1515                                 if(scsi_id > pHba->top_scsi_id){
1516                                         pHba->top_scsi_id = scsi_id;
1517                                 }
1518                                 if(scsi_lun > pHba->top_scsi_lun){
1519                                         pHba->top_scsi_lun = scsi_lun;
1520                                 }
1521                         }
1522                         if(scsi_id == -1){
1523                                 printk(KERN_WARNING"Could not find SCSI ID for %s\n",
1524                                                 d->lct_data.identity_tag);
1525                         }
1526                 }
1527         }
1528         return 0;
1529 }
1530
1531
1532 /*
1533  *      Each I2O controller has a chain of devices on it - these match
1534  *      the useful parts of the LCT of the board.
1535  */
1536
1537 static int adpt_i2o_install_device(adpt_hba* pHba, struct i2o_device *d)
1538 {
1539         mutex_lock(&adpt_configuration_lock);
1540         d->controller=pHba;
1541         d->owner=NULL;
1542         d->next=pHba->devices;
1543         d->prev=NULL;
1544         if (pHba->devices != NULL){
1545                 pHba->devices->prev=d;
1546         }
1547         pHba->devices=d;
1548         *d->dev_name = 0;
1549
1550         mutex_unlock(&adpt_configuration_lock);
1551         return 0;
1552 }
1553
1554 static int adpt_open(struct inode *inode, struct file *file)
1555 {
1556         int minor;
1557         adpt_hba* pHba;
1558
1559         //TODO check for root access
1560         //
1561         minor = iminor(inode);
1562         if (minor >= hba_count) {
1563                 return -ENXIO;
1564         }
1565         mutex_lock(&adpt_configuration_lock);
1566         for (pHba = hba_chain; pHba; pHba = pHba->next) {
1567                 if (pHba->unit == minor) {
1568                         break;  /* found adapter */
1569                 }
1570         }
1571         if (pHba == NULL) {
1572                 mutex_unlock(&adpt_configuration_lock);
1573                 return -ENXIO;
1574         }
1575
1576 //      if(pHba->in_use){
1577         //      mutex_unlock(&adpt_configuration_lock);
1578 //              return -EBUSY;
1579 //      }
1580
1581         pHba->in_use = 1;
1582         mutex_unlock(&adpt_configuration_lock);
1583
1584         return 0;
1585 }
1586
1587 static int adpt_close(struct inode *inode, struct file *file)
1588 {
1589         int minor;
1590         adpt_hba* pHba;
1591
1592         minor = iminor(inode);
1593         if (minor >= hba_count) {
1594                 return -ENXIO;
1595         }
1596         mutex_lock(&adpt_configuration_lock);
1597         for (pHba = hba_chain; pHba; pHba = pHba->next) {
1598                 if (pHba->unit == minor) {
1599                         break;  /* found adapter */
1600                 }
1601         }
1602         mutex_unlock(&adpt_configuration_lock);
1603         if (pHba == NULL) {
1604                 return -ENXIO;
1605         }
1606
1607         pHba->in_use = 0;
1608
1609         return 0;
1610 }
1611
1612
1613 static int adpt_i2o_passthru(adpt_hba* pHba, u32 __user *arg)
1614 {
1615         u32 msg[MAX_MESSAGE_SIZE];
1616         u32* reply = NULL;
1617         u32 size = 0;
1618         u32 reply_size = 0;
1619         u32 __user *user_msg = arg;
1620         u32 __user * user_reply = NULL;
1621         void *sg_list[pHba->sg_tablesize];
1622         u32 sg_offset = 0;
1623         u32 sg_count = 0;
1624         int sg_index = 0;
1625         u32 i = 0;
1626         u32 rcode = 0;
1627         void *p = NULL;
1628         ulong flags = 0;
1629
1630         memset(&msg, 0, MAX_MESSAGE_SIZE*4);
1631         // get user msg size in u32s
1632         if(get_user(size, &user_msg[0])){
1633                 return -EFAULT;
1634         }
1635         size = size>>16;
1636
1637         user_reply = &user_msg[size];
1638         if(size > MAX_MESSAGE_SIZE){
1639                 return -EFAULT;
1640         }
1641         size *= 4; // Convert to bytes
1642
1643         /* Copy in the user's I2O command */
1644         if(copy_from_user(msg, user_msg, size)) {
1645                 return -EFAULT;
1646         }
1647         get_user(reply_size, &user_reply[0]);
1648         reply_size = reply_size>>16;
1649         if(reply_size > REPLY_FRAME_SIZE){
1650                 reply_size = REPLY_FRAME_SIZE;
1651         }
1652         reply_size *= 4;
1653         reply = kzalloc(REPLY_FRAME_SIZE*4, GFP_KERNEL);
1654         if(reply == NULL) {
1655                 printk(KERN_WARNING"%s: Could not allocate reply buffer\n",pHba->name);
1656                 return -ENOMEM;
1657         }
1658         sg_offset = (msg[0]>>4)&0xf;
1659         msg[2] = 0x40000000; // IOCTL context
1660         msg[3] = (u32)reply;
1661         memset(sg_list,0, sizeof(sg_list[0])*pHba->sg_tablesize);
1662         if(sg_offset) {
1663                 // TODO 64bit fix
1664                 struct sg_simple_element *sg =  (struct sg_simple_element*) (msg+sg_offset);
1665                 sg_count = (size - sg_offset*4) / sizeof(struct sg_simple_element);
1666                 if (sg_count > pHba->sg_tablesize){
1667                         printk(KERN_DEBUG"%s:IOCTL SG List too large (%u)\n", pHba->name,sg_count);
1668                         kfree (reply);
1669                         return -EINVAL;
1670                 }
1671
1672                 for(i = 0; i < sg_count; i++) {
1673                         int sg_size;
1674
1675                         if (!(sg[i].flag_count & 0x10000000 /*I2O_SGL_FLAGS_SIMPLE_ADDRESS_ELEMENT*/)) {
1676                                 printk(KERN_DEBUG"%s:Bad SG element %d - not simple (%x)\n",pHba->name,i,  sg[i].flag_count);
1677                                 rcode = -EINVAL;
1678                                 goto cleanup;
1679                         }
1680                         sg_size = sg[i].flag_count & 0xffffff;
1681                         /* Allocate memory for the transfer */
1682                         p = kmalloc(sg_size, GFP_KERNEL|ADDR32);
1683                         if(!p) {
1684                                 printk(KERN_DEBUG"%s: Could not allocate SG buffer - size = %d buffer number %d of %d\n",
1685                                                 pHba->name,sg_size,i,sg_count);
1686                                 rcode = -ENOMEM;
1687                                 goto cleanup;
1688                         }
1689                         sg_list[sg_index++] = p; // sglist indexed with input frame, not our internal frame.
1690                         /* Copy in the user's SG buffer if necessary */
1691                         if(sg[i].flag_count & 0x04000000 /*I2O_SGL_FLAGS_DIR*/) {
1692                                 // TODO 64bit fix
1693                                 if (copy_from_user(p,(void __user *)sg[i].addr_bus, sg_size)) {
1694                                         printk(KERN_DEBUG"%s: Could not copy SG buf %d FROM user\n",pHba->name,i);
1695                                         rcode = -EFAULT;
1696                                         goto cleanup;
1697                                 }
1698                         }
1699                         //TODO 64bit fix
1700                         sg[i].addr_bus = (u32)virt_to_bus(p);
1701                 }
1702         }
1703
1704         do {
1705                 if(pHba->host)
1706                         spin_lock_irqsave(pHba->host->host_lock, flags);
1707                 // This state stops any new commands from enterring the
1708                 // controller while processing the ioctl
1709 //              pHba->state |= DPTI_STATE_IOCTL;
1710 //              We can't set this now - The scsi subsystem sets host_blocked and
1711 //              the queue empties and stops.  We need a way to restart the queue
1712                 rcode = adpt_i2o_post_wait(pHba, msg, size, FOREVER);
1713                 if (rcode != 0)
1714                         printk("adpt_i2o_passthru: post wait failed %d %p\n",
1715                                         rcode, reply);
1716 //              pHba->state &= ~DPTI_STATE_IOCTL;
1717                 if(pHba->host)
1718                         spin_unlock_irqrestore(pHba->host->host_lock, flags);
1719         } while(rcode == -ETIMEDOUT);
1720
1721         if(rcode){
1722                 goto cleanup;
1723         }
1724
1725         if(sg_offset) {
1726         /* Copy back the Scatter Gather buffers back to user space */
1727                 u32 j;
1728                 // TODO 64bit fix
1729                 struct sg_simple_element* sg;
1730                 int sg_size;
1731
1732                 // re-acquire the original message to handle correctly the sg copy operation
1733                 memset(&msg, 0, MAX_MESSAGE_SIZE*4);
1734                 // get user msg size in u32s
1735                 if(get_user(size, &user_msg[0])){
1736                         rcode = -EFAULT;
1737                         goto cleanup;
1738                 }
1739                 size = size>>16;
1740                 size *= 4;
1741                 /* Copy in the user's I2O command */
1742                 if (copy_from_user (msg, user_msg, size)) {
1743                         rcode = -EFAULT;
1744                         goto cleanup;
1745                 }
1746                 sg_count = (size - sg_offset*4) / sizeof(struct sg_simple_element);
1747
1748                 // TODO 64bit fix
1749                 sg       = (struct sg_simple_element*)(msg + sg_offset);
1750                 for (j = 0; j < sg_count; j++) {
1751                         /* Copy out the SG list to user's buffer if necessary */
1752                         if(! (sg[j].flag_count & 0x4000000 /*I2O_SGL_FLAGS_DIR*/)) {
1753                                 sg_size = sg[j].flag_count & 0xffffff;
1754                                 // TODO 64bit fix
1755                                 if (copy_to_user((void __user *)sg[j].addr_bus,sg_list[j], sg_size)) {
1756                                         printk(KERN_WARNING"%s: Could not copy %p TO user %x\n",pHba->name, sg_list[j], sg[j].addr_bus);
1757                                         rcode = -EFAULT;
1758                                         goto cleanup;
1759                                 }
1760                         }
1761                 }
1762         }
1763
1764         /* Copy back the reply to user space */
1765         if (reply_size) {
1766                 // we wrote our own values for context - now restore the user supplied ones
1767                 if(copy_from_user(reply+2, user_msg+2, sizeof(u32)*2)) {
1768                         printk(KERN_WARNING"%s: Could not copy message context FROM user\n",pHba->name);
1769                         rcode = -EFAULT;
1770                 }
1771                 if(copy_to_user(user_reply, reply, reply_size)) {
1772                         printk(KERN_WARNING"%s: Could not copy reply TO user\n",pHba->name);
1773                         rcode = -EFAULT;
1774                 }
1775         }
1776
1777
1778 cleanup:
1779         if (rcode != -ETIME && rcode != -EINTR)
1780                 kfree (reply);
1781         while(sg_index) {
1782                 if(sg_list[--sg_index]) {
1783                         if (rcode != -ETIME && rcode != -EINTR)
1784                                 kfree(sg_list[sg_index]);
1785                 }
1786         }
1787         return rcode;
1788 }
1789
1790
1791 /*
1792  * This routine returns information about the system.  This does not effect
1793  * any logic and if the info is wrong - it doesn't matter.
1794  */
1795
1796 /* Get all the info we can not get from kernel services */
1797 static int adpt_system_info(void __user *buffer)
1798 {
1799         sysInfo_S si;
1800
1801         memset(&si, 0, sizeof(si));
1802
1803         si.osType = OS_LINUX;
1804         si.osMajorVersion = 0;
1805         si.osMinorVersion = 0;
1806         si.osRevision = 0;
1807         si.busType = SI_PCI_BUS;
1808         si.processorFamily = DPTI_sig.dsProcessorFamily;
1809
1810 #if defined __i386__
1811         adpt_i386_info(&si);
1812 #elif defined (__ia64__)
1813         adpt_ia64_info(&si);
1814 #elif defined(__sparc__)
1815         adpt_sparc_info(&si);
1816 #elif defined (__alpha__)
1817         adpt_alpha_info(&si);
1818 #else
1819         si.processorType = 0xff ;
1820 #endif
1821         if(copy_to_user(buffer, &si, sizeof(si))){
1822                 printk(KERN_WARNING"dpti: Could not copy buffer TO user\n");
1823                 return -EFAULT;
1824         }
1825
1826         return 0;
1827 }
1828
1829 #if defined __ia64__
1830 static void adpt_ia64_info(sysInfo_S* si)
1831 {
1832         // This is all the info we need for now
1833         // We will add more info as our new
1834         // managmenent utility requires it
1835         si->processorType = PROC_IA64;
1836 }
1837 #endif
1838
1839
1840 #if defined __sparc__
1841 static void adpt_sparc_info(sysInfo_S* si)
1842 {
1843         // This is all the info we need for now
1844         // We will add more info as our new
1845         // managmenent utility requires it
1846         si->processorType = PROC_ULTRASPARC;
1847 }
1848 #endif
1849
1850 #if defined __alpha__
1851 static void adpt_alpha_info(sysInfo_S* si)
1852 {
1853         // This is all the info we need for now
1854         // We will add more info as our new
1855         // managmenent utility requires it
1856         si->processorType = PROC_ALPHA;
1857 }
1858 #endif
1859
1860 #if defined __i386__
1861
1862 static void adpt_i386_info(sysInfo_S* si)
1863 {
1864         // This is all the info we need for now
1865         // We will add more info as our new
1866         // managmenent utility requires it
1867         switch (boot_cpu_data.x86) {
1868         case CPU_386:
1869                 si->processorType = PROC_386;
1870                 break;
1871         case CPU_486:
1872                 si->processorType = PROC_486;
1873                 break;
1874         case CPU_586:
1875                 si->processorType = PROC_PENTIUM;
1876                 break;
1877         default:  // Just in case
1878                 si->processorType = PROC_PENTIUM;
1879                 break;
1880         }
1881 }
1882
1883 #endif
1884
1885
1886 static int adpt_ioctl(struct inode *inode, struct file *file, uint cmd,
1887               ulong arg)
1888 {
1889         int minor;
1890         int error = 0;
1891         adpt_hba* pHba;
1892         ulong flags = 0;
1893         void __user *argp = (void __user *)arg;
1894
1895         minor = iminor(inode);
1896         if (minor >= DPTI_MAX_HBA){
1897                 return -ENXIO;
1898         }
1899         mutex_lock(&adpt_configuration_lock);
1900         for (pHba = hba_chain; pHba; pHba = pHba->next) {
1901                 if (pHba->unit == minor) {
1902                         break;  /* found adapter */
1903                 }
1904         }
1905         mutex_unlock(&adpt_configuration_lock);
1906         if(pHba == NULL){
1907                 return -ENXIO;
1908         }
1909
1910         while((volatile u32) pHba->state & DPTI_STATE_RESET )
1911                 schedule_timeout_uninterruptible(2);
1912
1913         switch (cmd) {
1914         // TODO: handle 3 cases
1915         case DPT_SIGNATURE:
1916                 if (copy_to_user(argp, &DPTI_sig, sizeof(DPTI_sig))) {
1917                         return -EFAULT;
1918                 }
1919                 break;
1920         case I2OUSRCMD:
1921                 return adpt_i2o_passthru(pHba, argp);
1922
1923         case DPT_CTRLINFO:{
1924                 drvrHBAinfo_S HbaInfo;
1925
1926 #define FLG_OSD_PCI_VALID 0x0001
1927 #define FLG_OSD_DMA       0x0002
1928 #define FLG_OSD_I2O       0x0004
1929                 memset(&HbaInfo, 0, sizeof(HbaInfo));
1930                 HbaInfo.drvrHBAnum = pHba->unit;
1931                 HbaInfo.baseAddr = (ulong) pHba->base_addr_phys;
1932                 HbaInfo.blinkState = adpt_read_blink_led(pHba);
1933                 HbaInfo.pciBusNum =  pHba->pDev->bus->number;
1934                 HbaInfo.pciDeviceNum=PCI_SLOT(pHba->pDev->devfn);
1935                 HbaInfo.Interrupt = pHba->pDev->irq;
1936                 HbaInfo.hbaFlags = FLG_OSD_PCI_VALID | FLG_OSD_DMA | FLG_OSD_I2O;
1937                 if(copy_to_user(argp, &HbaInfo, sizeof(HbaInfo))){
1938                         printk(KERN_WARNING"%s: Could not copy HbaInfo TO user\n",pHba->name);
1939                         return -EFAULT;
1940                 }
1941                 break;
1942                 }
1943         case DPT_SYSINFO:
1944                 return adpt_system_info(argp);
1945         case DPT_BLINKLED:{
1946                 u32 value;
1947                 value = (u32)adpt_read_blink_led(pHba);
1948                 if (copy_to_user(argp, &value, sizeof(value))) {
1949                         return -EFAULT;
1950                 }
1951                 break;
1952                 }
1953         case I2ORESETCMD:
1954                 if(pHba->host)
1955                         spin_lock_irqsave(pHba->host->host_lock, flags);
1956                 adpt_hba_reset(pHba);
1957                 if(pHba->host)
1958                         spin_unlock_irqrestore(pHba->host->host_lock, flags);
1959                 break;
1960         case I2ORESCANCMD:
1961                 adpt_rescan(pHba);
1962                 break;
1963         default:
1964                 return -EINVAL;
1965         }
1966
1967         return error;
1968 }
1969
1970
1971 static irqreturn_t adpt_isr(int irq, void *dev_id)
1972 {
1973         struct scsi_cmnd* cmd;
1974         adpt_hba* pHba = dev_id;
1975         u32 m;
1976         void __iomem *reply;
1977         u32 status=0;
1978         u32 context;
1979         ulong flags = 0;
1980         int handled = 0;
1981
1982         if (pHba == NULL){
1983                 printk(KERN_WARNING"adpt_isr: NULL dev_id\n");
1984                 return IRQ_NONE;
1985         }
1986         if(pHba->host)
1987                 spin_lock_irqsave(pHba->host->host_lock, flags);
1988
1989         while( readl(pHba->irq_mask) & I2O_INTERRUPT_PENDING_B) {
1990                 m = readl(pHba->reply_port);
1991                 if(m == EMPTY_QUEUE){
1992                         // Try twice then give up
1993                         rmb();
1994                         m = readl(pHba->reply_port);
1995                         if(m == EMPTY_QUEUE){
1996                                 // This really should not happen
1997                                 printk(KERN_ERR"dpti: Could not get reply frame\n");
1998                                 goto out;
1999                         }
2000                 }
2001                 reply = bus_to_virt(m);
2002
2003                 if (readl(reply) & MSG_FAIL) {
2004                         u32 old_m = readl(reply+28);
2005                         void __iomem *msg;
2006                         u32 old_context;
2007                         PDEBUG("%s: Failed message\n",pHba->name);
2008                         if(old_m >= 0x100000){
2009                                 printk(KERN_ERR"%s: Bad preserved MFA (%x)- dropping frame\n",pHba->name,old_m);
2010                                 writel(m,pHba->reply_port);
2011                                 continue;
2012                         }
2013                         // Transaction context is 0 in failed reply frame
2014                         msg = pHba->msg_addr_virt + old_m;
2015                         old_context = readl(msg+12);
2016                         writel(old_context, reply+12);
2017                         adpt_send_nop(pHba, old_m);
2018                 }
2019                 context = readl(reply+8);
2020                 if(context & 0x40000000){ // IOCTL
2021                         void *p = (void *)readl(reply+12);
2022                         if( p != NULL) {
2023                                 memcpy_fromio(p, reply, REPLY_FRAME_SIZE * 4);
2024                         }
2025                         // All IOCTLs will also be post wait
2026                 }
2027                 if(context & 0x80000000){ // Post wait message
2028                         status = readl(reply+16);
2029                         if(status  >> 24){
2030                                 status &=  0xffff; /* Get detail status */
2031                         } else {
2032                                 status = I2O_POST_WAIT_OK;
2033                         }
2034                         if(!(context & 0x40000000)) {
2035                                 cmd = (struct scsi_cmnd*) readl(reply+12);
2036                                 if(cmd != NULL) {
2037                                         printk(KERN_WARNING"%s: Apparent SCSI cmd in Post Wait Context - cmd=%p context=%x\n", pHba->name, cmd, context);
2038                                 }
2039                         }
2040                         adpt_i2o_post_wait_complete(context, status);
2041                 } else { // SCSI message
2042                         cmd = (struct scsi_cmnd*) readl(reply+12);
2043                         if(cmd != NULL){
2044                                 if(cmd->serial_number != 0) { // If not timedout
2045                                         adpt_i2o_to_scsi(reply, cmd);
2046                                 }
2047                         }
2048                 }
2049                 writel(m, pHba->reply_port);
2050                 wmb();
2051                 rmb();
2052         }
2053         handled = 1;
2054 out:    if(pHba->host)
2055                 spin_unlock_irqrestore(pHba->host->host_lock, flags);
2056         return IRQ_RETVAL(handled);
2057 }
2058
2059 static s32 adpt_scsi_to_i2o(adpt_hba* pHba, struct scsi_cmnd* cmd, struct adpt_device* d)
2060 {
2061         int i;
2062         u32 msg[MAX_MESSAGE_SIZE];
2063         u32* mptr;
2064         u32 *lenptr;
2065         int direction;
2066         int scsidir;
2067         int nseg;
2068         u32 len;
2069         u32 reqlen;
2070         s32 rcode;
2071
2072         memset(msg, 0 , sizeof(msg));
2073         len = scsi_bufflen(cmd);
2074         direction = 0x00000000;
2075
2076         scsidir = 0x00000000;                   // DATA NO XFER
2077         if(len) {
2078                 /*
2079                  * Set SCBFlags to indicate if data is being transferred
2080                  * in or out, or no data transfer
2081                  * Note:  Do not have to verify index is less than 0 since
2082                  * cmd->cmnd[0] is an unsigned char
2083                  */
2084                 switch(cmd->sc_data_direction){
2085                 case DMA_FROM_DEVICE:
2086                         scsidir  =0x40000000;   // DATA IN  (iop<--dev)
2087                         break;
2088                 case DMA_TO_DEVICE:
2089                         direction=0x04000000;   // SGL OUT
2090                         scsidir  =0x80000000;   // DATA OUT (iop-->dev)
2091                         break;
2092                 case DMA_NONE:
2093                         break;
2094                 case DMA_BIDIRECTIONAL:
2095                         scsidir  =0x40000000;   // DATA IN  (iop<--dev)
2096                         // Assume In - and continue;
2097                         break;
2098                 default:
2099                         printk(KERN_WARNING"%s: scsi opcode 0x%x not supported.\n",
2100                              pHba->name, cmd->cmnd[0]);
2101                         cmd->result = (DID_OK <<16) | (INITIATOR_ERROR << 8);
2102                         cmd->scsi_done(cmd);
2103                         return  0;
2104                 }
2105         }
2106         // msg[0] is set later
2107         // I2O_CMD_SCSI_EXEC
2108         msg[1] = ((0xff<<24)|(HOST_TID<<12)|d->tid);
2109         msg[2] = 0;
2110         msg[3] = (u32)cmd;      /* We want the SCSI control block back */
2111         // Our cards use the transaction context as the tag for queueing
2112         // Adaptec/DPT Private stuff
2113         msg[4] = I2O_CMD_SCSI_EXEC|(DPT_ORGANIZATION_ID<<16);
2114         msg[5] = d->tid;
2115         /* Direction, disconnect ok | sense data | simple queue , CDBLen */
2116         // I2O_SCB_FLAG_ENABLE_DISCONNECT |
2117         // I2O_SCB_FLAG_SIMPLE_QUEUE_TAG |
2118         // I2O_SCB_FLAG_SENSE_DATA_IN_MESSAGE;
2119         msg[6] = scsidir|0x20a00000|cmd->cmd_len;
2120
2121         mptr=msg+7;
2122
2123         // Write SCSI command into the message - always 16 byte block
2124         memset(mptr, 0,  16);
2125         memcpy(mptr, cmd->cmnd, cmd->cmd_len);
2126         mptr+=4;
2127         lenptr=mptr++;          /* Remember me - fill in when we know */
2128         reqlen = 14;            // SINGLE SGE
2129         /* Now fill in the SGList and command */
2130
2131         nseg = scsi_dma_map(cmd);
2132         BUG_ON(nseg < 0);
2133         if (nseg) {
2134                 struct scatterlist *sg;
2135
2136                 len = 0;
2137                 scsi_for_each_sg(cmd, sg, nseg, i) {
2138                         *mptr++ = direction|0x10000000|sg_dma_len(sg);
2139                         len+=sg_dma_len(sg);
2140                         *mptr++ = sg_dma_address(sg);
2141                         /* Make this an end of list */
2142                         if (i == nseg - 1)
2143                                 mptr[-2] = direction|0xD0000000|sg_dma_len(sg);
2144                 }
2145                 reqlen = mptr - msg;
2146                 *lenptr = len;
2147
2148                 if(cmd->underflow && len != cmd->underflow){
2149                         printk(KERN_WARNING"Cmd len %08X Cmd underflow %08X\n",
2150                                 len, cmd->underflow);
2151                 }
2152         } else {
2153                 *lenptr = len = 0;
2154                 reqlen = 12;
2155         }
2156
2157         /* Stick the headers on */
2158         msg[0] = reqlen<<16 | ((reqlen > 12) ? SGL_OFFSET_12 : SGL_OFFSET_0);
2159
2160         // Send it on it's way
2161         rcode = adpt_i2o_post_this(pHba, msg, reqlen<<2);
2162         if (rcode == 0) {
2163                 return 0;
2164         }
2165         return rcode;
2166 }
2167
2168
2169 static s32 adpt_i2o_to_scsi(void __iomem *reply, struct scsi_cmnd* cmd)
2170 {
2171         adpt_hba* pHba;
2172         u32 hba_status;
2173         u32 dev_status;
2174         u32 reply_flags = readl(reply) & 0xff00; // Leave it shifted up 8 bits
2175         // I know this would look cleaner if I just read bytes
2176         // but the model I have been using for all the rest of the
2177         // io is in 4 byte words - so I keep that model
2178         u16 detailed_status = readl(reply+16) &0xffff;
2179         dev_status = (detailed_status & 0xff);
2180         hba_status = detailed_status >> 8;
2181
2182         // calculate resid for sg
2183         scsi_set_resid(cmd, scsi_bufflen(cmd) - readl(reply+5));
2184
2185         pHba = (adpt_hba*) cmd->device->host->hostdata[0];
2186
2187         cmd->sense_buffer[0] = '\0';  // initialize sense valid flag to false
2188
2189         if(!(reply_flags & MSG_FAIL)) {
2190                 switch(detailed_status & I2O_SCSI_DSC_MASK) {
2191                 case I2O_SCSI_DSC_SUCCESS:
2192                         cmd->result = (DID_OK << 16);
2193                         // handle underflow
2194                         if(readl(reply+5) < cmd->underflow ) {
2195                                 cmd->result = (DID_ERROR <<16);
2196                                 printk(KERN_WARNING"%s: SCSI CMD underflow\n",pHba->name);
2197                         }
2198                         break;
2199                 case I2O_SCSI_DSC_REQUEST_ABORTED:
2200                         cmd->result = (DID_ABORT << 16);
2201                         break;
2202                 case I2O_SCSI_DSC_PATH_INVALID:
2203                 case I2O_SCSI_DSC_DEVICE_NOT_PRESENT:
2204                 case I2O_SCSI_DSC_SELECTION_TIMEOUT:
2205                 case I2O_SCSI_DSC_COMMAND_TIMEOUT:
2206                 case I2O_SCSI_DSC_NO_ADAPTER:
2207                 case I2O_SCSI_DSC_RESOURCE_UNAVAILABLE:
2208                         printk(KERN_WARNING"%s: SCSI Timeout-Device (%d,%d,%d) hba status=0x%x, dev status=0x%x, cmd=0x%x\n",
2209                                 pHba->name, (u32)cmd->device->channel, (u32)cmd->device->id, (u32)cmd->device->lun, hba_status, dev_status, cmd->cmnd[0]);
2210                         cmd->result = (DID_TIME_OUT << 16);
2211                         break;
2212                 case I2O_SCSI_DSC_ADAPTER_BUSY:
2213                 case I2O_SCSI_DSC_BUS_BUSY:
2214                         cmd->result = (DID_BUS_BUSY << 16);
2215                         break;
2216                 case I2O_SCSI_DSC_SCSI_BUS_RESET:
2217                 case I2O_SCSI_DSC_BDR_MESSAGE_SENT:
2218                         cmd->result = (DID_RESET << 16);
2219                         break;
2220                 case I2O_SCSI_DSC_PARITY_ERROR_FAILURE:
2221                         printk(KERN_WARNING"%s: SCSI CMD parity error\n",pHba->name);
2222                         cmd->result = (DID_PARITY << 16);
2223                         break;
2224                 case I2O_SCSI_DSC_UNABLE_TO_ABORT:
2225                 case I2O_SCSI_DSC_COMPLETE_WITH_ERROR:
2226                 case I2O_SCSI_DSC_UNABLE_TO_TERMINATE:
2227                 case I2O_SCSI_DSC_MR_MESSAGE_RECEIVED:
2228                 case I2O_SCSI_DSC_AUTOSENSE_FAILED:
2229                 case I2O_SCSI_DSC_DATA_OVERRUN:
2230                 case I2O_SCSI_DSC_UNEXPECTED_BUS_FREE:
2231                 case I2O_SCSI_DSC_SEQUENCE_FAILURE:
2232                 case I2O_SCSI_DSC_REQUEST_LENGTH_ERROR:
2233                 case I2O_SCSI_DSC_PROVIDE_FAILURE:
2234                 case I2O_SCSI_DSC_REQUEST_TERMINATED:
2235                 case I2O_SCSI_DSC_IDE_MESSAGE_SENT:
2236                 case I2O_SCSI_DSC_UNACKNOWLEDGED_EVENT:
2237                 case I2O_SCSI_DSC_MESSAGE_RECEIVED:
2238                 case I2O_SCSI_DSC_INVALID_CDB:
2239                 case I2O_SCSI_DSC_LUN_INVALID:
2240                 case I2O_SCSI_DSC_SCSI_TID_INVALID:
2241                 case I2O_SCSI_DSC_FUNCTION_UNAVAILABLE:
2242                 case I2O_SCSI_DSC_NO_NEXUS:
2243                 case I2O_SCSI_DSC_CDB_RECEIVED:
2244                 case I2O_SCSI_DSC_LUN_ALREADY_ENABLED:
2245                 case I2O_SCSI_DSC_QUEUE_FROZEN:
2246                 case I2O_SCSI_DSC_REQUEST_INVALID:
2247                 default:
2248                         printk(KERN_WARNING"%s: SCSI error %0x-Device(%d,%d,%d) hba_status=0x%x, dev_status=0x%x, cmd=0x%x\n",
2249                                 pHba->name, detailed_status & I2O_SCSI_DSC_MASK, (u32)cmd->device->channel, (u32)cmd->device->id, (u32)cmd->device->lun,
2250                                hba_status, dev_status, cmd->cmnd[0]);
2251                         cmd->result = (DID_ERROR << 16);
2252                         break;
2253                 }
2254
2255                 // copy over the request sense data if it was a check
2256                 // condition status
2257                 if(dev_status == 0x02 /*CHECK_CONDITION*/) {
2258                         u32 len = sizeof(cmd->sense_buffer);
2259                         len = (len > 40) ?  40 : len;
2260                         // Copy over the sense data
2261                         memcpy_fromio(cmd->sense_buffer, (reply+28) , len);
2262                         if(cmd->sense_buffer[0] == 0x70 /* class 7 */ &&
2263                            cmd->sense_buffer[2] == DATA_PROTECT ){
2264                                 /* This is to handle an array failed */
2265                                 cmd->result = (DID_TIME_OUT << 16);
2266                                 printk(KERN_WARNING"%s: SCSI Data Protect-Device (%d,%d,%d) hba_status=0x%x, dev_status=0x%x, cmd=0x%x\n",
2267                                         pHba->name, (u32)cmd->device->channel, (u32)cmd->device->id, (u32)cmd->device->lun,
2268                                         hba_status, dev_status, cmd->cmnd[0]);
2269
2270                         }
2271                 }
2272         } else {
2273                 /* In this condtion we could not talk to the tid
2274                  * the card rejected it.  We should signal a retry
2275                  * for a limitted number of retries.
2276                  */
2277                 cmd->result = (DID_TIME_OUT << 16);
2278                 printk(KERN_WARNING"%s: I2O MSG_FAIL - Device (%d,%d,%d) tid=%d, cmd=0x%x\n",
2279                         pHba->name, (u32)cmd->device->channel, (u32)cmd->device->id, (u32)cmd->device->lun,
2280                         ((struct adpt_device*)(cmd->device->hostdata))->tid, cmd->cmnd[0]);
2281         }
2282
2283         cmd->result |= (dev_status);
2284
2285         if(cmd->scsi_done != NULL){
2286                 cmd->scsi_done(cmd);
2287         }
2288         return cmd->result;
2289 }
2290
2291
2292 static s32 adpt_rescan(adpt_hba* pHba)
2293 {
2294         s32 rcode;
2295         ulong flags = 0;
2296
2297         if(pHba->host)
2298                 spin_lock_irqsave(pHba->host->host_lock, flags);
2299         if ((rcode=adpt_i2o_lct_get(pHba)) < 0)
2300                 goto out;
2301         if ((rcode=adpt_i2o_reparse_lct(pHba)) < 0)
2302                 goto out;
2303         rcode = 0;
2304 out:    if(pHba->host)
2305                 spin_unlock_irqrestore(pHba->host->host_lock, flags);
2306         return rcode;
2307 }
2308
2309
2310 static s32 adpt_i2o_reparse_lct(adpt_hba* pHba)
2311 {
2312         int i;
2313         int max;
2314         int tid;
2315         struct i2o_device *d;
2316         i2o_lct *lct = pHba->lct;
2317         u8 bus_no = 0;
2318         s16 scsi_id;
2319         s16 scsi_lun;
2320         u32 buf[10]; // at least 8 u32's
2321         struct adpt_device* pDev = NULL;
2322         struct i2o_device* pI2o_dev = NULL;
2323
2324         if (lct == NULL) {
2325                 printk(KERN_ERR "%s: LCT is empty???\n",pHba->name);
2326                 return -1;
2327         }
2328
2329         max = lct->table_size;
2330         max -= 3;
2331         max /= 9;
2332
2333         // Mark each drive as unscanned
2334         for (d = pHba->devices; d; d = d->next) {
2335                 pDev =(struct adpt_device*) d->owner;
2336                 if(!pDev){
2337                         continue;
2338                 }
2339                 pDev->state |= DPTI_DEV_UNSCANNED;
2340         }
2341
2342         printk(KERN_INFO "%s: LCT has %d entries.\n", pHba->name,max);
2343
2344         for(i=0;i<max;i++) {
2345                 if( lct->lct_entry[i].user_tid != 0xfff){
2346                         continue;
2347                 }
2348
2349                 if( lct->lct_entry[i].class_id == I2O_CLASS_RANDOM_BLOCK_STORAGE ||
2350                     lct->lct_entry[i].class_id == I2O_CLASS_SCSI_PERIPHERAL ||
2351                     lct->lct_entry[i].class_id == I2O_CLASS_FIBRE_CHANNEL_PERIPHERAL ){
2352                         tid = lct->lct_entry[i].tid;
2353                         if(adpt_i2o_query_scalar(pHba, tid, 0x8000, -1, buf, 32)<0) {
2354                                 printk(KERN_ERR"%s: Could not query device\n",pHba->name);
2355                                 continue;
2356                         }
2357                         bus_no = buf[0]>>16;
2358                         scsi_id = buf[1];
2359                         scsi_lun = (buf[2]>>8 )&0xff;
2360                         pDev = pHba->channel[bus_no].device[scsi_id];
2361                         /* da lun */
2362                         while(pDev) {
2363                                 if(pDev->scsi_lun == scsi_lun) {
2364                                         break;
2365                                 }
2366                                 pDev = pDev->next_lun;
2367                         }
2368                         if(!pDev ) { // Something new add it
2369                                 d = kmalloc(sizeof(struct i2o_device), GFP_KERNEL);
2370                                 if(d==NULL)
2371                                 {
2372                                         printk(KERN_CRIT "Out of memory for I2O device data.\n");
2373                                         return -ENOMEM;
2374                                 }
2375
2376                                 d->controller = pHba;
2377                                 d->next = NULL;
2378
2379                                 memcpy(&d->lct_data, &lct->lct_entry[i], sizeof(i2o_lct_entry));
2380
2381                                 d->flags = 0;
2382                                 adpt_i2o_report_hba_unit(pHba, d);
2383                                 adpt_i2o_install_device(pHba, d);
2384
2385                                 if(bus_no >= MAX_CHANNEL) {     // Something wrong skip it
2386                                         printk(KERN_WARNING"%s: Channel number %d out of range \n", pHba->name, bus_no);
2387                                         continue;
2388                                 }
2389                                 pDev = pHba->channel[bus_no].device[scsi_id];
2390                                 if( pDev == NULL){
2391                                         pDev =  kzalloc(sizeof(struct adpt_device),GFP_KERNEL);
2392                                         if(pDev == NULL) {
2393                                                 return -ENOMEM;
2394                                         }
2395                                         pHba->channel[bus_no].device[scsi_id] = pDev;
2396                                 } else {
2397                                         while (pDev->next_lun) {
2398                                                 pDev = pDev->next_lun;
2399                                         }
2400                                         pDev = pDev->next_lun = kzalloc(sizeof(struct adpt_device),GFP_KERNEL);
2401                                         if(pDev == NULL) {
2402                                                 return -ENOMEM;
2403                                         }
2404                                 }
2405                                 pDev->tid = d->lct_data.tid;
2406                                 pDev->scsi_channel = bus_no;
2407                                 pDev->scsi_id = scsi_id;
2408                                 pDev->scsi_lun = scsi_lun;
2409                                 pDev->pI2o_dev = d;
2410                                 d->owner = pDev;
2411                                 pDev->type = (buf[0])&0xff;
2412                                 pDev->flags = (buf[0]>>8)&0xff;
2413                                 // Too late, SCSI system has made up it's mind, but what the hey ...
2414                                 if(scsi_id > pHba->top_scsi_id){
2415                                         pHba->top_scsi_id = scsi_id;
2416                                 }
2417                                 if(scsi_lun > pHba->top_scsi_lun){
2418                                         pHba->top_scsi_lun = scsi_lun;
2419                                 }
2420                                 continue;
2421                         } // end of new i2o device
2422
2423                         // We found an old device - check it
2424                         while(pDev) {
2425                                 if(pDev->scsi_lun == scsi_lun) {
2426                                         if(!scsi_device_online(pDev->pScsi_dev)) {
2427                                                 printk(KERN_WARNING"%s: Setting device (%d,%d,%d) back online\n",
2428                                                                 pHba->name,bus_no,scsi_id,scsi_lun);
2429                                                 if (pDev->pScsi_dev) {
2430                                                         scsi_device_set_state(pDev->pScsi_dev, SDEV_RUNNING);
2431                                                 }
2432                                         }
2433                                         d = pDev->pI2o_dev;
2434                                         if(d->lct_data.tid != tid) { // something changed
2435                                                 pDev->tid = tid;
2436                                                 memcpy(&d->lct_data, &lct->lct_entry[i], sizeof(i2o_lct_entry));
2437                                                 if (pDev->pScsi_dev) {
2438                                                         pDev->pScsi_dev->changed = TRUE;
2439                                                         pDev->pScsi_dev->removable = TRUE;
2440                                                 }
2441                                         }
2442                                         // Found it - mark it scanned
2443                                         pDev->state = DPTI_DEV_ONLINE;
2444                                         break;
2445                                 }
2446                                 pDev = pDev->next_lun;
2447                         }
2448                 }
2449         }
2450         for (pI2o_dev = pHba->devices; pI2o_dev; pI2o_dev = pI2o_dev->next) {
2451                 pDev =(struct adpt_device*) pI2o_dev->owner;
2452                 if(!pDev){
2453                         continue;
2454                 }
2455                 // Drive offline drives that previously existed but could not be found
2456                 // in the LCT table
2457                 if (pDev->state & DPTI_DEV_UNSCANNED){
2458                         pDev->state = DPTI_DEV_OFFLINE;
2459                         printk(KERN_WARNING"%s: Device (%d,%d,%d) offline\n",pHba->name,pDev->scsi_channel,pDev->scsi_id,pDev->scsi_lun);
2460                         if (pDev->pScsi_dev) {
2461                                 scsi_device_set_state(pDev->pScsi_dev, SDEV_OFFLINE);
2462                         }
2463                 }
2464         }
2465         return 0;
2466 }
2467
2468 static void adpt_fail_posted_scbs(adpt_hba* pHba)
2469 {
2470         struct scsi_cmnd*       cmd = NULL;
2471         struct scsi_device*     d = NULL;
2472
2473         shost_for_each_device(d, pHba->host) {
2474                 unsigned long flags;
2475                 spin_lock_irqsave(&d->list_lock, flags);
2476                 list_for_each_entry(cmd, &d->cmd_list, list) {
2477                         if(cmd->serial_number == 0){
2478                                 continue;
2479                         }
2480                         cmd->result = (DID_OK << 16) | (QUEUE_FULL <<1);
2481                         cmd->scsi_done(cmd);
2482                 }
2483                 spin_unlock_irqrestore(&d->list_lock, flags);
2484         }
2485 }
2486
2487
2488 /*============================================================================
2489  *  Routines from i2o subsystem
2490  *============================================================================
2491  */
2492
2493
2494
2495 /*
2496  *      Bring an I2O controller into HOLD state. See the spec.
2497  */
2498 static int adpt_i2o_activate_hba(adpt_hba* pHba)
2499 {
2500         int rcode;
2501
2502         if(pHba->initialized ) {
2503                 if (adpt_i2o_status_get(pHba) < 0) {
2504                         if((rcode = adpt_i2o_reset_hba(pHba)) != 0){
2505                                 printk(KERN_WARNING"%s: Could NOT reset.\n", pHba->name);
2506                                 return rcode;
2507                         }
2508                         if (adpt_i2o_status_get(pHba) < 0) {
2509                                 printk(KERN_INFO "HBA not responding.\n");
2510                                 return -1;
2511                         }
2512                 }
2513
2514                 if(pHba->status_block->iop_state == ADAPTER_STATE_FAULTED) {
2515                         printk(KERN_CRIT "%s: hardware fault\n", pHba->name);
2516                         return -1;
2517                 }
2518
2519                 if (pHba->status_block->iop_state == ADAPTER_STATE_READY ||
2520                     pHba->status_block->iop_state == ADAPTER_STATE_OPERATIONAL ||
2521                     pHba->status_block->iop_state == ADAPTER_STATE_HOLD ||
2522                     pHba->status_block->iop_state == ADAPTER_STATE_FAILED) {
2523                         adpt_i2o_reset_hba(pHba);
2524                         if (adpt_i2o_status_get(pHba) < 0 || pHba->status_block->iop_state != ADAPTER_STATE_RESET) {
2525                                 printk(KERN_ERR "%s: Failed to initialize.\n", pHba->name);
2526                                 return -1;
2527                         }
2528                 }
2529         } else {
2530                 if((rcode = adpt_i2o_reset_hba(pHba)) != 0){
2531                         printk(KERN_WARNING"%s: Could NOT reset.\n", pHba->name);
2532                         return rcode;
2533                 }
2534
2535         }
2536
2537         if (adpt_i2o_init_outbound_q(pHba) < 0) {
2538                 return -1;
2539         }
2540
2541         /* In HOLD state */
2542
2543         if (adpt_i2o_hrt_get(pHba) < 0) {
2544                 return -1;
2545         }
2546
2547         return 0;
2548 }
2549
2550 /*
2551  *      Bring a controller online into OPERATIONAL state.
2552  */
2553
2554 static int adpt_i2o_online_hba(adpt_hba* pHba)
2555 {
2556         if (adpt_i2o_systab_send(pHba) < 0) {
2557                 adpt_i2o_delete_hba(pHba);
2558                 return -1;
2559         }
2560         /* In READY state */
2561
2562         if (adpt_i2o_enable_hba(pHba) < 0) {
2563                 adpt_i2o_delete_hba(pHba);
2564                 return -1;
2565         }
2566
2567         /* In OPERATIONAL state  */
2568         return 0;
2569 }
2570
2571 static s32 adpt_send_nop(adpt_hba*pHba,u32 m)
2572 {
2573         u32 __iomem *msg;
2574         ulong timeout = jiffies + 5*HZ;
2575
2576         while(m == EMPTY_QUEUE){
2577                 rmb();
2578                 m = readl(pHba->post_port);
2579                 if(m != EMPTY_QUEUE){
2580                         break;
2581                 }
2582                 if(time_after(jiffies,timeout)){
2583                         printk(KERN_ERR "%s: Timeout waiting for message frame!\n",pHba->name);
2584                         return 2;
2585                 }
2586                 schedule_timeout_uninterruptible(1);
2587         }
2588         msg = (u32 __iomem *)(pHba->msg_addr_virt + m);
2589         writel( THREE_WORD_MSG_SIZE | SGL_OFFSET_0,&msg[0]);
2590         writel( I2O_CMD_UTIL_NOP << 24 | HOST_TID << 12 | 0,&msg[1]);
2591         writel( 0,&msg[2]);
2592         wmb();
2593
2594         writel(m, pHba->post_port);
2595         wmb();
2596         return 0;
2597 }
2598
2599 static s32 adpt_i2o_init_outbound_q(adpt_hba* pHba)
2600 {
2601         u8 *status;
2602         u32 __iomem *msg = NULL;
2603         int i;
2604         ulong timeout = jiffies + TMOUT_INITOUTBOUND*HZ;
2605         u32* ptr;
2606         u32 outbound_frame;  // This had to be a 32 bit address
2607         u32 m;
2608
2609         do {
2610                 rmb();
2611                 m = readl(pHba->post_port);
2612                 if (m != EMPTY_QUEUE) {
2613                         break;
2614                 }
2615
2616                 if(time_after(jiffies,timeout)){
2617                         printk(KERN_WARNING"%s: Timeout waiting for message frame\n",pHba->name);
2618                         return -ETIMEDOUT;
2619                 }
2620                 schedule_timeout_uninterruptible(1);
2621         } while(m == EMPTY_QUEUE);
2622
2623         msg=(u32 __iomem *)(pHba->msg_addr_virt+m);
2624
2625         status = kmalloc(4,GFP_KERNEL|ADDR32);
2626         if (status==NULL) {
2627                 adpt_send_nop(pHba, m);
2628                 printk(KERN_WARNING"%s: IOP reset failed - no free memory.\n",
2629                         pHba->name);
2630                 return -ENOMEM;
2631         }
2632         memset(status, 0, 4);
2633
2634         writel(EIGHT_WORD_MSG_SIZE| SGL_OFFSET_6, &msg[0]);
2635         writel(I2O_CMD_OUTBOUND_INIT<<24 | HOST_TID<<12 | ADAPTER_TID, &msg[1]);
2636         writel(0, &msg[2]);
2637         writel(0x0106, &msg[3]);        /* Transaction context */
2638         writel(4096, &msg[4]);          /* Host page frame size */
2639         writel((REPLY_FRAME_SIZE)<<16|0x80, &msg[5]);   /* Outbound msg frame size and Initcode */
2640         writel(0xD0000004, &msg[6]);            /* Simple SG LE, EOB */
2641         writel(virt_to_bus(status), &msg[7]);
2642
2643         writel(m, pHba->post_port);
2644         wmb();
2645
2646         // Wait for the reply status to come back
2647         do {
2648                 if (*status) {
2649                         if (*status != 0x01 /*I2O_EXEC_OUTBOUND_INIT_IN_PROGRESS*/) {
2650                                 break;
2651                         }
2652                 }
2653                 rmb();
2654                 if(time_after(jiffies,timeout)){
2655                         printk(KERN_WARNING"%s: Timeout Initializing\n",pHba->name);
2656                         return -ETIMEDOUT;
2657                 }
2658                 schedule_timeout_uninterruptible(1);
2659         } while (1);
2660
2661         // If the command was successful, fill the fifo with our reply
2662         // message packets
2663         if(*status != 0x04 /*I2O_EXEC_OUTBOUND_INIT_COMPLETE*/) {
2664                 kfree(status);
2665                 return -2;
2666         }
2667         kfree(status);
2668
2669         kfree(pHba->reply_pool);
2670
2671         pHba->reply_pool = kmalloc(pHba->reply_fifo_size * REPLY_FRAME_SIZE * 4, GFP_KERNEL|ADDR32);
2672         if(!pHba->reply_pool){
2673                 printk(KERN_ERR"%s: Could not allocate reply pool\n",pHba->name);
2674                 return -1;
2675         }
2676         memset(pHba->reply_pool, 0 , pHba->reply_fifo_size * REPLY_FRAME_SIZE * 4);
2677
2678         ptr = pHba->reply_pool;
2679         for(i = 0; i < pHba->reply_fifo_size; i++) {
2680                 outbound_frame = (u32)virt_to_bus(ptr);
2681                 writel(outbound_frame, pHba->reply_port);
2682                 wmb();
2683                 ptr +=  REPLY_FRAME_SIZE;
2684         }
2685         adpt_i2o_status_get(pHba);
2686         return 0;
2687 }
2688
2689
2690 /*
2691  * I2O System Table.  Contains information about
2692  * all the IOPs in the system.  Used to inform IOPs
2693  * about each other's existence.
2694  *
2695  * sys_tbl_ver is the CurrentChangeIndicator that is
2696  * used by IOPs to track changes.
2697  */
2698
2699
2700
2701 static s32 adpt_i2o_status_get(adpt_hba* pHba)
2702 {
2703         ulong timeout;
2704         u32 m;
2705         u32 __iomem *msg;
2706         u8 *status_block=NULL;
2707         ulong status_block_bus;
2708
2709         if(pHba->status_block == NULL) {
2710                 pHba->status_block = (i2o_status_block*)
2711                         kmalloc(sizeof(i2o_status_block),GFP_KERNEL|ADDR32);
2712                 if(pHba->status_block == NULL) {
2713                         printk(KERN_ERR
2714                         "dpti%d: Get Status Block failed; Out of memory. \n",
2715                         pHba->unit);
2716                         return -ENOMEM;
2717                 }
2718         }
2719         memset(pHba->status_block, 0, sizeof(i2o_status_block));
2720         status_block = (u8*)(pHba->status_block);
2721         status_block_bus = virt_to_bus(pHba->status_block);
2722         timeout = jiffies+TMOUT_GETSTATUS*HZ;
2723         do {
2724                 rmb();
2725                 m = readl(pHba->post_port);
2726                 if (m != EMPTY_QUEUE) {
2727                         break;
2728                 }
2729                 if(time_after(jiffies,timeout)){
2730                         printk(KERN_ERR "%s: Timeout waiting for message !\n",
2731                                         pHba->name);
2732                         return -ETIMEDOUT;
2733                 }
2734                 schedule_timeout_uninterruptible(1);
2735         } while(m==EMPTY_QUEUE);
2736
2737
2738         msg=(u32 __iomem *)(pHba->msg_addr_virt+m);
2739
2740         writel(NINE_WORD_MSG_SIZE|SGL_OFFSET_0, &msg[0]);
2741         writel(I2O_CMD_STATUS_GET<<24|HOST_TID<<12|ADAPTER_TID, &msg[1]);
2742         writel(1, &msg[2]);
2743         writel(0, &msg[3]);
2744         writel(0, &msg[4]);
2745         writel(0, &msg[5]);
2746         writel(((u32)status_block_bus)&0xffffffff, &msg[6]);
2747         writel(0, &msg[7]);
2748         writel(sizeof(i2o_status_block), &msg[8]); // 88 bytes
2749
2750         //post message
2751         writel(m, pHba->post_port);
2752         wmb();
2753
2754         while(status_block[87]!=0xff){
2755                 if(time_after(jiffies,timeout)){
2756                         printk(KERN_ERR"dpti%d: Get status timeout.\n",
2757                                 pHba->unit);
2758                         return -ETIMEDOUT;
2759                 }
2760                 rmb();
2761                 schedule_timeout_uninterruptible(1);
2762         }
2763
2764         // Set up our number of outbound and inbound messages
2765         pHba->post_fifo_size = pHba->status_block->max_inbound_frames;
2766         if (pHba->post_fifo_size > MAX_TO_IOP_MESSAGES) {
2767                 pHba->post_fifo_size = MAX_TO_IOP_MESSAGES;
2768         }
2769
2770         pHba->reply_fifo_size = pHba->status_block->max_outbound_frames;
2771         if (pHba->reply_fifo_size > MAX_FROM_IOP_MESSAGES) {
2772                 pHba->reply_fifo_size = MAX_FROM_IOP_MESSAGES;
2773         }
2774
2775         // Calculate the Scatter Gather list size
2776         pHba->sg_tablesize = (pHba->status_block->inbound_frame_size * 4 -40)/ sizeof(struct sg_simple_element);
2777         if (pHba->sg_tablesize > SG_LIST_ELEMENTS) {
2778                 pHba->sg_tablesize = SG_LIST_ELEMENTS;
2779         }
2780
2781
2782 #ifdef DEBUG
2783         printk("dpti%d: State = ",pHba->unit);
2784         switch(pHba->status_block->iop_state) {
2785                 case 0x01:
2786                         printk("INIT\n");
2787                         break;
2788                 case 0x02:
2789                         printk("RESET\n");
2790                         break;
2791                 case 0x04:
2792                         printk("HOLD\n");
2793                         break;
2794                 case 0x05:
2795                         printk("READY\n");
2796                         break;
2797                 case 0x08:
2798                         printk("OPERATIONAL\n");
2799                         break;
2800                 case 0x10:
2801                         printk("FAILED\n");
2802                         break;
2803                 case 0x11:
2804                         printk("FAULTED\n");
2805                         break;
2806                 default:
2807                         printk("%x (unknown!!)\n",pHba->status_block->iop_state);
2808         }
2809 #endif
2810         return 0;
2811 }
2812
2813 /*
2814  * Get the IOP's Logical Configuration Table
2815  */
2816 static int adpt_i2o_lct_get(adpt_hba* pHba)
2817 {
2818         u32 msg[8];
2819         int ret;
2820         u32 buf[16];
2821
2822         if ((pHba->lct_size == 0) || (pHba->lct == NULL)){
2823                 pHba->lct_size = pHba->status_block->expected_lct_size;
2824         }
2825         do {
2826                 if (pHba->lct == NULL) {
2827                         pHba->lct = kmalloc(pHba->lct_size, GFP_KERNEL|ADDR32);
2828                         if(pHba->lct == NULL) {
2829                                 printk(KERN_CRIT "%s: Lct Get failed. Out of memory.\n",
2830                                         pHba->name);
2831                                 return -ENOMEM;
2832                         }
2833                 }
2834                 memset(pHba->lct, 0, pHba->lct_size);
2835
2836                 msg[0] = EIGHT_WORD_MSG_SIZE|SGL_OFFSET_6;
2837                 msg[1] = I2O_CMD_LCT_NOTIFY<<24 | HOST_TID<<12 | ADAPTER_TID;
2838                 msg[2] = 0;
2839                 msg[3] = 0;
2840                 msg[4] = 0xFFFFFFFF;    /* All devices */
2841                 msg[5] = 0x00000000;    /* Report now */
2842                 msg[6] = 0xD0000000|pHba->lct_size;
2843                 msg[7] = virt_to_bus(pHba->lct);
2844
2845                 if ((ret=adpt_i2o_post_wait(pHba, msg, sizeof(msg), 360))) {
2846                         printk(KERN_ERR "%s: LCT Get failed (status=%#10x.\n",
2847                                 pHba->name, ret);
2848                         printk(KERN_ERR"Adaptec: Error Reading Hardware.\n");
2849                         return ret;
2850                 }
2851
2852                 if ((pHba->lct->table_size << 2) > pHba->lct_size) {
2853                         pHba->lct_size = pHba->lct->table_size << 2;
2854                         kfree(pHba->lct);
2855                         pHba->lct = NULL;
2856                 }
2857         } while (pHba->lct == NULL);
2858
2859         PDEBUG("%s: Hardware resource table read.\n", pHba->name);
2860
2861
2862         // I2O_DPT_EXEC_IOP_BUFFERS_GROUP_NO;
2863         if(adpt_i2o_query_scalar(pHba, 0 , 0x8000, -1, buf, sizeof(buf))>=0) {
2864                 pHba->FwDebugBufferSize = buf[1];
2865                 pHba->FwDebugBuffer_P    = pHba->base_addr_virt + buf[0];
2866                 pHba->FwDebugFlags_P     = pHba->FwDebugBuffer_P + FW_DEBUG_FLAGS_OFFSET;
2867                 pHba->FwDebugBLEDvalue_P = pHba->FwDebugBuffer_P + FW_DEBUG_BLED_OFFSET;
2868                 pHba->FwDebugBLEDflag_P  = pHba->FwDebugBLEDvalue_P + 1;
2869                 pHba->FwDebugStrLength_P = pHba->FwDebugBuffer_P + FW_DEBUG_STR_LENGTH_OFFSET;
2870                 pHba->FwDebugBuffer_P += buf[2];
2871                 pHba->FwDebugFlags = 0;
2872         }
2873
2874         return 0;
2875 }
2876
2877 static int adpt_i2o_build_sys_table(void)
2878 {
2879         adpt_hba* pHba = NULL;
2880         int count = 0;
2881
2882         sys_tbl_len = sizeof(struct i2o_sys_tbl) +      // Header + IOPs
2883                                 (hba_count) * sizeof(struct i2o_sys_tbl_entry);
2884
2885         kfree(sys_tbl);
2886
2887         sys_tbl = kmalloc(sys_tbl_len, GFP_KERNEL|ADDR32);
2888         if(!sys_tbl) {
2889                 printk(KERN_WARNING "SysTab Set failed. Out of memory.\n");
2890                 return -ENOMEM;
2891         }
2892         memset(sys_tbl, 0, sys_tbl_len);
2893
2894         sys_tbl->num_entries = hba_count;
2895         sys_tbl->version = I2OVERSION;
2896         sys_tbl->change_ind = sys_tbl_ind++;
2897
2898         for(pHba = hba_chain; pHba; pHba = pHba->next) {
2899                 // Get updated Status Block so we have the latest information
2900                 if (adpt_i2o_status_get(pHba)) {
2901                         sys_tbl->num_entries--;
2902                         continue; // try next one
2903                 }
2904
2905                 sys_tbl->iops[count].org_id = pHba->status_block->org_id;
2906                 sys_tbl->iops[count].iop_id = pHba->unit + 2;
2907                 sys_tbl->iops[count].seg_num = 0;
2908                 sys_tbl->iops[count].i2o_version = pHba->status_block->i2o_version;
2909                 sys_tbl->iops[count].iop_state = pHba->status_block->iop_state;
2910                 sys_tbl->iops[count].msg_type = pHba->status_block->msg_type;
2911                 sys_tbl->iops[count].frame_size = pHba->status_block->inbound_frame_size;
2912                 sys_tbl->iops[count].last_changed = sys_tbl_ind - 1; // ??
2913                 sys_tbl->iops[count].iop_capabilities = pHba->status_block->iop_capabilities;
2914                 sys_tbl->iops[count].inbound_low = (u32)virt_to_bus(pHba->post_port);
2915                 sys_tbl->iops[count].inbound_high = (u32)((u64)virt_to_bus(pHba->post_port)>>32);
2916
2917                 count++;
2918         }
2919
2920 #ifdef DEBUG
2921 {
2922         u32 *table = (u32*)sys_tbl;
2923         printk(KERN_DEBUG"sys_tbl_len=%d in 32bit words\n",(sys_tbl_len >>2));
2924         for(count = 0; count < (sys_tbl_len >>2); count++) {
2925                 printk(KERN_INFO "sys_tbl[%d] = %0#10x\n",
2926                         count, table[count]);
2927         }
2928 }
2929 #endif
2930
2931         return 0;
2932 }
2933
2934
2935 /*
2936  *       Dump the information block associated with a given unit (TID)
2937  */
2938
2939 static void adpt_i2o_report_hba_unit(adpt_hba* pHba, struct i2o_device *d)
2940 {
2941         char buf[64];
2942         int unit = d->lct_data.tid;
2943
2944         printk(KERN_INFO "TID %3.3d ", unit);
2945
2946         if(adpt_i2o_query_scalar(pHba, unit, 0xF100, 3, buf, 16)>=0)
2947         {
2948                 buf[16]=0;
2949                 printk(" Vendor: %-12.12s", buf);
2950         }
2951         if(adpt_i2o_query_scalar(pHba, unit, 0xF100, 4, buf, 16)>=0)
2952         {
2953                 buf[16]=0;
2954                 printk(" Device: %-12.12s", buf);
2955         }
2956         if(adpt_i2o_query_scalar(pHba, unit, 0xF100, 6, buf, 8)>=0)
2957         {
2958                 buf[8]=0;
2959                 printk(" Rev: %-12.12s\n", buf);
2960         }
2961 #ifdef DEBUG
2962          printk(KERN_INFO "\tClass: %.21s\n", adpt_i2o_get_class_name(d->lct_data.class_id));
2963          printk(KERN_INFO "\tSubclass: 0x%04X\n", d->lct_data.sub_class);
2964          printk(KERN_INFO "\tFlags: ");
2965
2966          if(d->lct_data.device_flags&(1<<0))
2967                   printk("C");       // ConfigDialog requested
2968          if(d->lct_data.device_flags&(1<<1))
2969                   printk("U");       // Multi-user capable
2970          if(!(d->lct_data.device_flags&(1<<4)))
2971                   printk("P");       // Peer service enabled!
2972          if(!(d->lct_data.device_flags&(1<<5)))
2973                   printk("M");       // Mgmt service enabled!
2974          printk("\n");
2975 #endif
2976 }
2977
2978 #ifdef DEBUG
2979 /*
2980  *      Do i2o class name lookup
2981  */
2982 static const char *adpt_i2o_get_class_name(int class)
2983 {
2984         int idx = 16;
2985         static char *i2o_class_name[] = {
2986                 "Executive",
2987                 "Device Driver Module",
2988                 "Block Device",
2989                 "Tape Device",
2990                 "LAN Interface",
2991                 "WAN Interface",
2992                 "Fibre Channel Port",
2993                 "Fibre Channel Device",
2994                 "SCSI Device",
2995                 "ATE Port",
2996                 "ATE Device",
2997                 "Floppy Controller",
2998                 "Floppy Device",
2999                 "Secondary Bus Port",
3000                 "Peer Transport Agent",
3001                 "Peer Transport",
3002                 "Unknown"
3003         };
3004
3005         switch(class&0xFFF) {
3006         case I2O_CLASS_EXECUTIVE:
3007                 idx = 0; break;
3008         case I2O_CLASS_DDM:
3009                 idx = 1; break;
3010         case I2O_CLASS_RANDOM_BLOCK_STORAGE:
3011                 idx = 2; break;
3012         case I2O_CLASS_SEQUENTIAL_STORAGE:
3013                 idx = 3; break;
3014         case I2O_CLASS_LAN:
3015                 idx = 4; break;
3016         case I2O_CLASS_WAN:
3017                 idx = 5; break;
3018         case I2O_CLASS_FIBRE_CHANNEL_PORT:
3019                 idx = 6; break;
3020         case I2O_CLASS_FIBRE_CHANNEL_PERIPHERAL:
3021                 idx = 7; break;
3022         case I2O_CLASS_SCSI_PERIPHERAL:
3023                 idx = 8; break;
3024         case I2O_CLASS_ATE_PORT:
3025                 idx = 9; break;
3026         case I2O_CLASS_ATE_PERIPHERAL:
3027                 idx = 10; break;
3028         case I2O_CLASS_FLOPPY_CONTROLLER:
3029                 idx = 11; break;
3030         case I2O_CLASS_FLOPPY_DEVICE:
3031                 idx = 12; break;
3032         case I2O_CLASS_BUS_ADAPTER_PORT:
3033                 idx = 13; break;
3034         case I2O_CLASS_PEER_TRANSPORT_AGENT:
3035                 idx = 14; break;
3036         case I2O_CLASS_PEER_TRANSPORT:
3037                 idx = 15; break;
3038         }
3039         return i2o_class_name[idx];
3040 }
3041 #endif
3042
3043
3044 static s32 adpt_i2o_hrt_get(adpt_hba* pHba)
3045 {
3046         u32 msg[6];
3047         int ret, size = sizeof(i2o_hrt);
3048
3049         do {
3050                 if (pHba->hrt == NULL) {
3051                         pHba->hrt=kmalloc(size, GFP_KERNEL|ADDR32);
3052                         if (pHba->hrt == NULL) {
3053                                 printk(KERN_CRIT "%s: Hrt Get failed; Out of memory.\n", pHba->name);
3054                                 return -ENOMEM;
3055                         }
3056                 }
3057
3058                 msg[0]= SIX_WORD_MSG_SIZE| SGL_OFFSET_4;
3059                 msg[1]= I2O_CMD_HRT_GET<<24 | HOST_TID<<12 | ADAPTER_TID;
3060                 msg[2]= 0;
3061                 msg[3]= 0;
3062                 msg[4]= (0xD0000000 | size);    /* Simple transaction */
3063                 msg[5]= virt_to_bus(pHba->hrt);   /* Dump it here */
3064
3065                 if ((ret = adpt_i2o_post_wait(pHba, msg, sizeof(msg),20))) {
3066                         printk(KERN_ERR "%s: Unable to get HRT (status=%#10x)\n", pHba->name, ret);
3067                         return ret;
3068                 }
3069
3070                 if (pHba->hrt->num_entries * pHba->hrt->entry_len << 2 > size) {
3071                         size = pHba->hrt->num_entries * pHba->hrt->entry_len << 2;
3072                         kfree(pHba->hrt);
3073                         pHba->hrt = NULL;
3074                 }
3075         } while(pHba->hrt == NULL);
3076         return 0;
3077 }
3078
3079 /*
3080  *       Query one scalar group value or a whole scalar group.
3081  */
3082 static int adpt_i2o_query_scalar(adpt_hba* pHba, int tid,
3083                         int group, int field, void *buf, int buflen)
3084 {
3085         u16 opblk[] = { 1, 0, I2O_PARAMS_FIELD_GET, group, 1, field };
3086         u8 *resblk;
3087
3088         int size;
3089
3090         /* 8 bytes for header */
3091         resblk = kmalloc(sizeof(u8) * (8+buflen), GFP_KERNEL|ADDR32);
3092         if (resblk == NULL) {
3093                 printk(KERN_CRIT "%s: query scalar failed; Out of memory.\n", pHba->name);
3094                 return -ENOMEM;
3095         }
3096
3097         if (field == -1)                /* whole group */
3098                         opblk[4] = -1;
3099
3100         size = adpt_i2o_issue_params(I2O_CMD_UTIL_PARAMS_GET, pHba, tid,
3101                 opblk, sizeof(opblk), resblk, sizeof(u8)*(8+buflen));
3102         if (size == -ETIME) {
3103                 printk(KERN_WARNING "%s: issue params failed; Timed out.\n", pHba->name);
3104                 return -ETIME;
3105         } else if (size == -EINTR) {
3106                 printk(KERN_WARNING "%s: issue params failed; Interrupted.\n", pHba->name);
3107                 return -EINTR;
3108         }
3109
3110         memcpy(buf, resblk+8, buflen);  /* cut off header */
3111
3112         kfree(resblk);
3113         if (size < 0)
3114                 return size;
3115
3116         return buflen;
3117 }
3118
3119
3120 /*      Issue UTIL_PARAMS_GET or UTIL_PARAMS_SET
3121  *
3122  *      This function can be used for all UtilParamsGet/Set operations.
3123  *      The OperationBlock is given in opblk-buffer,
3124  *      and results are returned in resblk-buffer.
3125  *      Note that the minimum sized resblk is 8 bytes and contains
3126  *      ResultCount, ErrorInfoSize, BlockStatus and BlockSize.
3127  */
3128 static int adpt_i2o_issue_params(int cmd, adpt_hba* pHba, int tid,
3129                   void *opblk, int oplen, void *resblk, int reslen)
3130 {
3131         u32 msg[9];
3132         u32 *res = (u32 *)resblk;
3133         int wait_status;
3134
3135         msg[0] = NINE_WORD_MSG_SIZE | SGL_OFFSET_5;
3136         msg[1] = cmd << 24 | HOST_TID << 12 | tid;
3137         msg[2] = 0;
3138         msg[3] = 0;
3139         msg[4] = 0;
3140         msg[5] = 0x54000000 | oplen;    /* OperationBlock */
3141         msg[6] = virt_to_bus(opblk);
3142         msg[7] = 0xD0000000 | reslen;   /* ResultBlock */
3143         msg[8] = virt_to_bus(resblk);
3144
3145         if ((wait_status = adpt_i2o_post_wait(pHba, msg, sizeof(msg), 20))) {
3146                 printk("adpt_i2o_issue_params: post_wait failed (%p)\n", resblk);
3147                 return wait_status;     /* -DetailedStatus */
3148         }
3149
3150         if (res[1]&0x00FF0000) {        /* BlockStatus != SUCCESS */
3151                 printk(KERN_WARNING "%s: %s - Error:\n  ErrorInfoSize = 0x%02x, "
3152                         "BlockStatus = 0x%02x, BlockSize = 0x%04x\n",
3153                         pHba->name,
3154                         (cmd == I2O_CMD_UTIL_PARAMS_SET) ? "PARAMS_SET"
3155                                                          : "PARAMS_GET",
3156                         res[1]>>24, (res[1]>>16)&0xFF, res[1]&0xFFFF);
3157                 return -((res[1] >> 16) & 0xFF); /* -BlockStatus */
3158         }
3159
3160          return 4 + ((res[1] & 0x0000FFFF) << 2); /* bytes used in resblk */
3161 }
3162
3163
3164 static s32 adpt_i2o_quiesce_hba(adpt_hba* pHba)
3165 {
3166         u32 msg[4];
3167         int ret;
3168
3169         adpt_i2o_status_get(pHba);
3170
3171         /* SysQuiesce discarded if IOP not in READY or OPERATIONAL state */
3172
3173         if((pHba->status_block->iop_state != ADAPTER_STATE_READY) &&
3174            (pHba->status_block->iop_state != ADAPTER_STATE_OPERATIONAL)){
3175                 return 0;
3176         }
3177
3178         msg[0] = FOUR_WORD_MSG_SIZE|SGL_OFFSET_0;
3179         msg[1] = I2O_CMD_SYS_QUIESCE<<24|HOST_TID<<12|ADAPTER_TID;
3180         msg[2] = 0;
3181         msg[3] = 0;
3182
3183         if((ret = adpt_i2o_post_wait(pHba, msg, sizeof(msg), 240))) {
3184                 printk(KERN_INFO"dpti%d: Unable to quiesce (status=%#x).\n",
3185                                 pHba->unit, -ret);
3186         } else {
3187                 printk(KERN_INFO"dpti%d: Quiesced.\n",pHba->unit);
3188         }
3189
3190         adpt_i2o_status_get(pHba);
3191         return ret;
3192 }
3193
3194
3195 /*
3196  * Enable IOP. Allows the IOP to resume external operations.
3197  */
3198 static int adpt_i2o_enable_hba(adpt_hba* pHba)
3199 {
3200         u32 msg[4];
3201         int ret;
3202
3203         adpt_i2o_status_get(pHba);
3204         if(!pHba->status_block){
3205                 return -ENOMEM;
3206         }
3207         /* Enable only allowed on READY state */
3208         if(pHba->status_block->iop_state == ADAPTER_STATE_OPERATIONAL)
3209                 return 0;
3210
3211         if(pHba->status_block->iop_state != ADAPTER_STATE_READY)
3212                 return -EINVAL;
3213
3214         msg[0]=FOUR_WORD_MSG_SIZE|SGL_OFFSET_0;
3215         msg[1]=I2O_CMD_SYS_ENABLE<<24|HOST_TID<<12|ADAPTER_TID;
3216         msg[2]= 0;
3217         msg[3]= 0;
3218
3219         if ((ret = adpt_i2o_post_wait(pHba, msg, sizeof(msg), 240))) {
3220                 printk(KERN_WARNING"%s: Could not enable (status=%#10x).\n",
3221                         pHba->name, ret);
3222         } else {
3223                 PDEBUG("%s: Enabled.\n", pHba->name);
3224         }
3225
3226         adpt_i2o_status_get(pHba);
3227         return ret;
3228 }
3229
3230
3231 static int adpt_i2o_systab_send(adpt_hba* pHba)
3232 {
3233          u32 msg[12];
3234          int ret;
3235
3236         msg[0] = I2O_MESSAGE_SIZE(12) | SGL_OFFSET_6;
3237         msg[1] = I2O_CMD_SYS_TAB_SET<<24 | HOST_TID<<12 | ADAPTER_TID;
3238         msg[2] = 0;
3239         msg[3] = 0;
3240         msg[4] = (0<<16) | ((pHba->unit+2) << 12); /* Host 0 IOP ID (unit + 2) */
3241         msg[5] = 0;                                /* Segment 0 */
3242
3243         /*
3244          * Provide three SGL-elements:
3245          * System table (SysTab), Private memory space declaration and
3246          * Private i/o space declaration
3247          */
3248         msg[6] = 0x54000000 | sys_tbl_len;
3249         msg[7] = virt_to_phys(sys_tbl);
3250         msg[8] = 0x54000000 | 0;
3251         msg[9] = 0;
3252         msg[10] = 0xD4000000 | 0;
3253         msg[11] = 0;
3254
3255         if ((ret=adpt_i2o_post_wait(pHba, msg, sizeof(msg), 120))) {
3256                 printk(KERN_INFO "%s: Unable to set SysTab (status=%#10x).\n",
3257                         pHba->name, ret);
3258         }
3259 #ifdef DEBUG
3260         else {
3261                 PINFO("%s: SysTab set.\n", pHba->name);
3262         }
3263 #endif
3264
3265         return ret;
3266  }
3267
3268
3269 /*============================================================================
3270  *
3271  *============================================================================
3272  */
3273
3274
3275 #ifdef UARTDELAY
3276
3277 static static void adpt_delay(int millisec)
3278 {
3279         int i;
3280         for (i = 0; i < millisec; i++) {
3281                 udelay(1000);   /* delay for one millisecond */
3282         }
3283 }
3284
3285 #endif
3286
3287 static struct scsi_host_template adpt_template = {
3288         .name                   = "dpt_i2o",
3289         .proc_name              = "dpt_i2o",
3290         .proc_info              = adpt_proc_info,
3291         .info                   = adpt_info,
3292         .queuecommand           = adpt_queue,
3293         .eh_abort_handler       = adpt_abort,
3294         .eh_device_reset_handler = adpt_device_reset,
3295         .eh_bus_reset_handler   = adpt_bus_reset,
3296         .eh_host_reset_handler  = adpt_reset,
3297         .bios_param             = adpt_bios_param,
3298         .slave_configure        = adpt_slave_configure,
3299         .can_queue              = MAX_TO_IOP_MESSAGES,
3300         .this_id                = 7,
3301         .cmd_per_lun            = 1,
3302         .use_clustering         = ENABLE_CLUSTERING,
3303 };
3304
3305 static s32 adpt_scsi_register(adpt_hba* pHba)
3306 {
3307         struct Scsi_Host *host;
3308
3309         host = scsi_host_alloc(&adpt_template, sizeof(adpt_hba*));
3310         if (host == NULL) {
3311                 printk ("%s: scsi_host_alloc returned NULL\n",pHba->name);
3312                 return -1;
3313         }
3314         host->hostdata[0] = (unsigned long)pHba;
3315         pHba->host = host;
3316
3317         host->irq = pHba->pDev->irq;
3318         /* no IO ports, so don't have to set host->io_port and
3319          * host->n_io_port
3320          */
3321         host->io_port = 0;
3322         host->n_io_port = 0;
3323                                 /* see comments in scsi_host.h */
3324         host->max_id = 16;
3325         host->max_lun = 256;
3326         host->max_channel = pHba->top_scsi_channel + 1;
3327         host->cmd_per_lun = 1;
3328         host->unique_id = (uint) pHba;
3329         host->sg_tablesize = pHba->sg_tablesize;
3330         host->can_queue = pHba->post_fifo_size;
3331
3332         if (scsi_add_host(host, &pHba->pDev->dev)) {
3333                 scsi_host_put(host);
3334                 return -1;
3335         }
3336
3337         return 0;
3338 }
3339
3340 static int __init adpt_init(void)
3341 {
3342         int count;
3343
3344         printk("Loading Adaptec I2O RAID: Version " DPT_I2O_VERSION "\n");
3345 #ifdef REBOOT_NOTIFIER
3346         register_reboot_notifier(&adpt_reboot_notifier);
3347 #endif
3348
3349         count = adpt_detect();
3350
3351         return count > 0 ? 0 : -ENODEV;
3352 }
3353
3354 static void __exit adpt_exit(void)
3355 {
3356         while (hba_chain)
3357                 adpt_release(hba_chain);
3358 }
3359
3360 module_init(adpt_init);
3361 module_exit(adpt_exit);
3362 MODULE_LICENSE("GPL");