drivers/scsi/dpt_i2o.c

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