git.oblomov.eu Git - linux-2.6/blob - drivers/scsi/dpt_i2o.c

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