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