drivers/scsi/dpt_i2o.c

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