git.oblomov.eu Git - linux-2.6/blob - drivers/scsi/dpt_i2o.c

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