drivers/scsi/dpt_i2o.c

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