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