drivers/scsi/dpt_i2o.c

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