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