drivers/scsi/dpt_i2o.c

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