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