SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/scsi/dpt_i2o.c

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