drivers/scsi/dpt_i2o.c

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