drivers/scsi/dpt_i2o.c

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