err.no Git - linux-2.6/blob - drivers/scsi/dpt_i2o.c

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