git.oblomov.eu Git - linux-2.6/blob - drivers/scsi/dpt_i2o.c

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