drivers/scsi/pci2000.c

   1 /****************************************************************************
   2  * Perceptive Solutions, Inc. PCI-2000 device driver for Linux.
   3  *
   4  * pci2000.c - Linux Host Driver for PCI-2000 IntelliCache SCSI Adapters
   5  *
   6  * Copyright (c) 1997-1999 Perceptive Solutions, Inc.
   7  * All Rights Reserved.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that redistributions of source
  11  * code retain the above copyright notice and this comment without
  12  * modification.
  13  *
  14  * Technical updates and product information at:
  15  *  http://www.psidisk.com
  16  *
  17  * Please send questions, comments, bug reports to:
  18  *  tech@psidisk.com Technical Support
  19  *
  20  *
  21  *      Revisions       1.10    Jan-21-1999
  22  *              - Fixed sign on message to reflect proper controller name.
  23  *              - Added support for RAID status monitoring and control.
  24  *
  25  *  Revisions   1.11    Mar-22-1999
  26  *              - Fixed control timeout to not lock up the entire system if
  27  *                controller goes offline completely.
  28  *
  29  *      Revisions 1.12          Mar-26-1999
  30  *              - Fixed spinlock and PCI configuration.
  31  *
  32  *      Revisions 1.20          Mar-27-2000
  33  *              - Added support for dynamic DMA
  34  *
  35  ****************************************************************************/
  36 #define PCI2000_VERSION         "1.20"
  37
  38 #include <linux/module.h>
  39
  40 #include <linux/kernel.h>
  41 #include <linux/types.h>
  42 #include <linux/string.h>
  43 #include <linux/pci.h>
  44 #include <linux/ioport.h>
  45 #include <linux/delay.h>
  46 #include <linux/sched.h>
  47 #include <linux/proc_fs.h>
  48 #include <asm/dma.h>
  49 #include <asm/system.h>
  50 #include <asm/io.h>
  51 #include <linux/blk.h>
  52 #include "scsi.h"
  53 #include "hosts.h"
  54 #include <linux/stat.h>
  55 #include <linux/spinlock.h>
  56
  57 #include "pci2000.h"
  58 #include "psi_roy.h"
  59
  60
  61 //#define DEBUG 1
  62
  63 #ifdef DEBUG
  64 #define DEB(x) x
  65 #define STOP_HERE       {int st;for(st=0;st<100;st++){st=1;}}
  66 #else
  67 #define DEB(x)
  68 #define STOP_HERE
  69 #endif
  70
  71 typedef struct
  72         {
  73         unsigned int    address;
  74         unsigned int    length;
  75         }       SCATGATH, *PSCATGATH;
  76
  77 typedef struct
  78         {
  79         Scsi_Cmnd               *SCpnt;
  80         PSCATGATH                scatGath;
  81         dma_addr_t               scatGathDma;
  82         UCHAR                   *cdb;
  83         dma_addr_t               cdbDma;
  84         UCHAR                    tag;
  85         }       DEV2000, *PDEV2000;
  86
  87 typedef struct
  88         {
  89         ULONG                    basePort;
  90         ULONG                    mb0;
  91         ULONG                    mb1;
  92         ULONG                    mb2;
  93         ULONG                    mb3;
  94         ULONG                    mb4;
  95         ULONG                    cmd;
  96         ULONG                    tag;
  97         ULONG                    irqOwned;
  98         struct pci_dev  *pdev;
  99         DEV2000                  dev[MAX_BUS][MAX_UNITS];
 100         }       ADAPTER2000, *PADAPTER2000;
 101
 102 #define HOSTDATA(host) ((PADAPTER2000)&host->hostdata)
 103 #define consistentLen (MAX_BUS * MAX_UNITS * (16 * sizeof (SCATGATH) + MAX_COMMAND_SIZE))
 104
 105
 106 static struct   Scsi_Host          *PsiHost[MAXADAPTER] = {NULL,};  // One for each adapter
 107 static                  int                             NumAdapters = 0;
 108 /****************************************************************
 109  *      Name:                   WaitReady       :LOCAL
 110  *
 111  *      Description:    Wait for controller ready.
 112  *
 113  *      Parameters:             padapter - Pointer adapter data structure.
 114  *
 115  *      Returns:                TRUE on not ready.
 116  *
 117  ****************************************************************/
 118 static int WaitReady (PADAPTER2000 padapter)
 119         {
 120         ULONG   z;
 121
 122         for ( z = 0;  z < (TIMEOUT_COMMAND * 4);  z++ )
 123                 {
 124                 if ( !inb_p (padapter->cmd) )
 125                         return FALSE;
 126                 udelay (250);
 127                 };
 128         return TRUE;
 129         }
 130 /****************************************************************
 131  *      Name:                   WaitReadyLong   :LOCAL
 132  *
 133  *      Description:    Wait for controller ready.
 134  *
 135  *      Parameters:             padapter - Pointer adapter data structure.
 136  *
 137  *      Returns:                TRUE on not ready.
 138  *
 139  ****************************************************************/
 140 static int WaitReadyLong (PADAPTER2000 padapter)
 141         {
 142         ULONG   z;
 143
 144         for ( z = 0;  z < (5000 * 4);  z++ )
 145                 {
 146                 if ( !inb_p (padapter->cmd) )
 147                         return FALSE;
 148                 udelay (250);
 149                 };
 150         return TRUE;
 151         }
 152 /****************************************************************
 153  *      Name:   OpDone  :LOCAL
 154  *
 155  *      Description:    Clean up operation and issue done to caller.
 156  *
 157  *      Parameters:             SCpnt   - Pointer to SCSI command structure.
 158  *                                      status  - Caller status.
 159  *
 160  *      Returns:                Nothing.
 161  *
 162  ****************************************************************/
 163 static void OpDone (Scsi_Cmnd *SCpnt, ULONG status)
 164         {
 165         SCpnt->result = status;
 166         SCpnt->scsi_done (SCpnt);
 167         }
 168 /****************************************************************
 169  *      Name:   Command         :LOCAL
 170  *
 171  *      Description:    Issue queued command to the PCI-2000.
 172  *
 173  *      Parameters:             padapter - Pointer to adapter information structure.
 174  *                                      cmd              - PCI-2000 command byte.
 175  *
 176  *      Returns:                Non-zero command tag if operation is accepted.
 177  *
 178  ****************************************************************/
 179 static UCHAR Command (PADAPTER2000 padapter, UCHAR cmd)
 180         {
 181         outb_p (cmd, padapter->cmd);
 182         if ( WaitReady (padapter) )
 183                 return 0;
 184
 185         if ( inw_p (padapter->mb0) )
 186                 return 0;
 187
 188         return inb_p (padapter->mb1);
 189         }
 190 /****************************************************************
 191  *      Name:   BuildSgList             :LOCAL
 192  *
 193  *      Description:    Build the scatter gather list for controller.
 194  *
 195  *      Parameters:             SCpnt    - Pointer to SCSI command structure.
 196  *                                      padapter - Pointer to adapter information structure.
 197  *                                      pdev     - Pointer to adapter device structure.
 198  *
 199  *      Returns:                Non-zero in not scatter gather.
 200  *
 201  ****************************************************************/
 202 static int BuildSgList (Scsi_Cmnd *SCpnt, PADAPTER2000 padapter, PDEV2000 pdev)
 203         {
 204         int                                      z;
 205         int                                      zc;
 206         struct scatterlist      *sg;
 207
 208         if ( SCpnt->use_sg )
 209                 {
 210                 sg = (struct scatterlist *)SCpnt->request_buffer;
 211                 zc = pci_map_sg (padapter->pdev, sg, SCpnt->use_sg, scsi_to_pci_dma_dir (SCpnt->sc_data_direction));
 212                 for ( z = 0;  z < zc;  z++ )
 213                         {
 214                         pdev->scatGath[z].address = cpu_to_le32 (sg_dma_address (sg));
 215                         pdev->scatGath[z].length = cpu_to_le32 (sg_dma_len (sg++));
 216                         }
 217                 outl (pdev->scatGathDma, padapter->mb2);
 218                 outl ((zc << 24) | SCpnt->request_bufflen, padapter->mb3);
 219                 return FALSE;
 220                 }
 221         if ( !SCpnt->request_bufflen)
 222                 {
 223                 outl (0, padapter->mb2);
 224                 outl (0, padapter->mb3);
 225                 return TRUE;
 226                 }
 227         SCpnt->SCp.have_data_in = pci_map_single (padapter->pdev, SCpnt->request_buffer, SCpnt->request_bufflen, scsi_to_pci_dma_dir (SCpnt->sc_data_direction));
 228         outl (SCpnt->SCp.have_data_in, padapter->mb2);
 229         outl (SCpnt->request_bufflen, padapter->mb3);
 230         return TRUE;
 231         }
 232 /*********************************************************************
 233  *      Name:   PsiRaidCmd
 234  *
 235  *      Description:    Execute a simple command.
 236  *
 237  *      Parameters:             padapter - Pointer to adapter control structure.
 238  *                                      cmd              - Roy command byte.
 239  *
 240  *      Returns:                Return error status.
 241  *
 242  ********************************************************************/
 243 static int PsiRaidCmd (PADAPTER2000 padapter, char cmd)
 244         {
 245         if ( WaitReady (padapter) )                                             // test for command register ready
 246                 return DID_TIME_OUT;
 247         outb_p (cmd, padapter->cmd);                                    // issue command
 248         if ( WaitReadyLong (padapter) )                                 // wait for adapter ready
 249                 return DID_TIME_OUT;
 250         return DID_OK;
 251         }
 252 /****************************************************************
 253  *      Name:   Irq_Handler     :LOCAL
 254  *
 255  *      Description:    Interrupt handler.
 256  *
 257  *      Parameters:             irq             - Hardware IRQ number.
 258  *                                      dev_id  -
 259  *                                      regs    -
 260  *
 261  *      Returns:                TRUE if drive is not ready in time.
 262  *
 263  ****************************************************************/
 264 static void Irq_Handler (int irq, void *dev_id, struct pt_regs *regs)
 265         {
 266         struct Scsi_Host   *shost = NULL;       // Pointer to host data block
 267         PADAPTER2000            padapter;               // Pointer to adapter control structure
 268         PDEV2000                        pdev;
 269         Scsi_Cmnd                  *SCpnt;
 270         UCHAR                           tag = 0;
 271         UCHAR                           tag0;
 272         ULONG                           error;
 273         int                                     pun;
 274         int                                     bus;
 275         int                                     z;
 276     unsigned long               flags;
 277
 278     /*
 279      * Disable interrupts, if they aren't already disabled and acquire
 280      * the I/O spinlock.
 281      */
 282     spin_lock_irqsave (&io_request_lock, flags);
 283
 284         DEB(printk ("\npci2000 received interrupt "));
 285         for ( z = 0; z < NumAdapters;  z++ )                                                                            // scan for interrupt to process
 286                 {
 287                 if ( PsiHost[z]->irq == (UCHAR)(irq & 0xFF) )
 288                         {
 289                         tag = inb_p (HOSTDATA(PsiHost[z])->tag);
 290                         if (  tag )
 291                                 {
 292                                 shost = PsiHost[z];
 293                                 break;
 294                                 }
 295                         }
 296                 }
 297
 298         if ( !shost )
 299                 {
 300                 DEB (printk ("\npci2000: not my interrupt"));
 301                 goto irq_return;
 302                 }
 303
 304         padapter = HOSTDATA(shost);
 305
 306         tag0 = tag & 0x7F;                                                                                                                      // mask off the error bit
 307         for ( bus = 0;  bus < MAX_BUS;  bus++ )                                                                         // scan the busses
 308         {
 309                 for ( pun = 0;  pun < MAX_UNITS;  pun++ )                                                               // scan the targets
 310                 {
 311                         pdev = &padapter->dev[bus][pun];
 312                         if ( !pdev->tag )
 313                         continue;
 314                         if ( pdev->tag == tag0 )                                                                                        // is this it?
 315                                 {
 316                                 pdev->tag = 0;
 317                                 SCpnt = pdev->SCpnt;
 318                                 goto unmapProceed;
 319                         }
 320                         }
 321         }
 322
 323         outb_p (0xFF, padapter->tag);                                                                                           // clear the op interrupt
 324         outb_p (CMD_DONE, padapter->cmd);                                                                                       // complete the op
 325         goto irq_return;;                                                                                                                       // done, but, with what?
 326
 327 unmapProceed:;
 328         if ( !bus )
 329                 {
 330                 switch ( SCpnt->cmnd[0] )
 331                         {
 332                         case SCSIOP_TEST_UNIT_READY:
 333                                 pci_unmap_single (padapter->pdev, SCpnt->SCp.have_data_in, sizeof (SCpnt->sense_buffer), PCI_DMA_FROMDEVICE);
 334                                 goto irqProceed;
 335                         case SCSIOP_READ_CAPACITY:
 336                                 pci_unmap_single (padapter->pdev, SCpnt->SCp.have_data_in, 8, PCI_DMA_FROMDEVICE);
 337                                 goto irqProceed;
 338                         case SCSIOP_VERIFY:
 339                         case SCSIOP_START_STOP_UNIT:
 340                         case SCSIOP_MEDIUM_REMOVAL:
 341                                 goto irqProceed;
 342                         }
 343                 }
 344         if ( SCpnt->SCp.have_data_in )
 345                 pci_unmap_single (padapter->pdev, SCpnt->SCp.have_data_in, SCpnt->request_bufflen, scsi_to_pci_dma_dir(SCpnt->sc_data_direction));
 346         else
 347                 {
 348                 if ( SCpnt->use_sg )
 349                         pci_unmap_sg (padapter->pdev, (struct scatterlist *)SCpnt->request_buffer, SCpnt->use_sg, scsi_to_pci_dma_dir(SCpnt->sc_data_direction));
 350                 }
 351
 352 irqProceed:;
 353         if ( tag & ERR08_TAGGED )                                                                                               // is there an error here?
 354                 {
 355                 if ( WaitReady (padapter) )
 356                         {
 357                         OpDone (SCpnt, DID_TIME_OUT << 16);
 358                         goto irq_return;;
 359                         }
 360
 361                 outb_p (tag0, padapter->mb0);                                                                           // get real error code
 362                 outb_p (CMD_ERROR, padapter->cmd);
 363                 if ( WaitReady (padapter) )                                                                                     // wait for controller to suck up the op
 364                         {
 365                         OpDone (SCpnt, DID_TIME_OUT << 16);
 366                         goto irq_return;;
 367                         }
 368
 369                 error = inl (padapter->mb0);                                                                            // get error data
 370                 outb_p (0xFF, padapter->tag);                                                                           // clear the op interrupt
 371                 outb_p (CMD_DONE, padapter->cmd);                                                                       // complete the op
 372
 373                 DEB (printk ("status: %lX ", error));
 374                 if ( error == 0x00020002 )                                                                                      // is this error a check condition?
 375                         {
 376                         if ( bus )                                                                                                              // are we doint SCSI commands?
 377                                 {
 378                                 OpDone (SCpnt, (DID_OK << 16) | 2);
 379                                 goto irq_return;;
 380                                 }
 381                         if ( *SCpnt->cmnd == SCSIOP_TEST_UNIT_READY )
 382                                 OpDone (SCpnt, (DRIVER_SENSE << 24) | (DID_OK << 16) | 2);      // test caller we have sense data too
 383                         else
 384                                 OpDone (SCpnt, DID_ERROR << 16);
 385                         goto irq_return;;
 386                         }
 387                 OpDone (SCpnt, DID_ERROR << 16);
 388                 goto irq_return;;
 389                 }
 390
 391         outb_p (0xFF, padapter->tag);                                                                                   // clear the op interrupt
 392         outb_p (CMD_DONE, padapter->cmd);                                                                               // complete the op
 393         OpDone (SCpnt, DID_OK << 16);
 394
 395 irq_return:;
 396     /*
 397      * Release the I/O spinlock and restore the original flags
 398      * which will enable interrupts if and only if they were
 399      * enabled on entry.
 400      */
 401     spin_unlock_irqrestore (&io_request_lock, flags);
 402         }
 403 /****************************************************************
 404  *      Name:   Pci2000_QueueCommand
 405  *
 406  *      Description:    Process a queued command from the SCSI manager.
 407  *
 408  *      Parameters:             SCpnt - Pointer to SCSI command structure.
 409  *                                      done  - Pointer to done function to call.
 410  *
 411  *      Returns:                Status code.
 412  *
 413  ****************************************************************/
 414 int Pci2000_QueueCommand (Scsi_Cmnd *SCpnt, void (*done)(Scsi_Cmnd *))
 415         {
 416         UCHAR              *cdb = (UCHAR *)SCpnt->cmnd;                                 // Pointer to SCSI CDB
 417         PADAPTER2000    padapter = HOSTDATA(SCpnt->host);                       // Pointer to adapter control structure
 418         int                             rc               = -1;                                                          // command return code
 419         UCHAR                   bus              = SCpnt->channel;
 420         UCHAR                   pun              = SCpnt->target;
 421         UCHAR                   lun              = SCpnt->lun;
 422         UCHAR                   cmd;
 423         PDEV2000                pdev     = &padapter->dev[bus][pun];
 424
 425         if ( !done )
 426                 {
 427                 printk("pci2000_queuecommand: %02X: done can't be NULL\n", *cdb);
 428                 return 0;
 429                 }
 430
 431         SCpnt->scsi_done = done;
 432         SCpnt->SCp.have_data_in = 0;
 433         pdev->SCpnt = SCpnt;                                                                    // Save this command data
 434
 435         if ( WaitReady (padapter) )
 436                 {
 437                 rc = DID_ERROR;
 438                 goto finished;
 439                 }
 440
 441         outw_p (pun | (lun << 8), padapter->mb0);
 442
 443         if ( bus )
 444                 {
 445                 DEB (if(*cdb) printk ("\nCDB: %X-  %X %X %X %X %X %X %X %X %X %X ", SCpnt->cmd_len, cdb[0], cdb[1], cdb[2], cdb[3], cdb[4], cdb[5], cdb[6], cdb[7], cdb[8], cdb[9]));
 446                 DEB (if(*cdb) printk ("\ntimeout_per_command: %d, timeout_total: %d, timeout: %d, internal_timout: %d", SCpnt->timeout_per_command,
 447                                                           SCpnt->timeout_total, SCpnt->timeout, SCpnt->internal_timeout));
 448                 outl (SCpnt->timeout_per_command, padapter->mb1);
 449                 outb_p (CMD_SCSI_TIMEOUT, padapter->cmd);
 450                 if ( WaitReady (padapter) )
 451                         {
 452                         rc = DID_ERROR;
 453                         goto finished;
 454                         }
 455
 456                 outw_p (pun | (lun << 8), padapter->mb0);
 457                 outw_p (SCpnt->cmd_len << 8, padapter->mb0 + 2);
 458                 memcpy (pdev->cdb, cdb, MAX_COMMAND_SIZE);
 459
 460                 outl (pdev->cdbDma, padapter->mb1);
 461                 if ( BuildSgList (SCpnt, padapter, pdev) )
 462                         cmd = CMD_SCSI_THRU;
 463                 else
 464                         cmd = CMD_SCSI_THRU_SG;
 465                 if ( (pdev->tag = Command (padapter, cmd)) == 0 )
 466                         rc = DID_TIME_OUT;
 467                 goto finished;
 468                 }
 469         else
 470                 {
 471                 if ( lun )
 472                         {
 473                         rc = DID_BAD_TARGET;
 474                         goto finished;
 475                         }
 476                 }
 477
 478         switch ( *cdb )
 479                 {
 480                 case SCSIOP_INQUIRY:                                    // inquiry CDB
 481                         if ( cdb[2] == SC_MY_RAID )
 482                                 {
 483                                 switch ( cdb[3] )
 484                                         {
 485                                         case MY_SCSI_REBUILD:
 486                                                 OpDone (SCpnt, PsiRaidCmd (padapter, CMD_RAID_REBUILD) << 16);
 487                                                 return 0;
 488                                         case MY_SCSI_ALARMMUTE:
 489                                                 OpDone (SCpnt, PsiRaidCmd (padapter, CMD_RAID_MUTE) << 16);
 490                                                 return 0;
 491                                         case MY_SCSI_DEMOFAIL:
 492                                                 OpDone (SCpnt, PsiRaidCmd (padapter, CMD_RAID_FAIL) << 16);
 493                                                 return 0;
 494                                         default:
 495                                                 if ( SCpnt->use_sg )
 496                                                         {
 497                                                         rc = DID_ERROR;
 498                                                         goto finished;
 499                                                         }
 500                                                 else
 501                                                         {
 502                                                         SCpnt->SCp.have_data_in = pci_map_single (padapter->pdev, SCpnt->request_buffer, SCpnt->request_bufflen,
 503                                                                                                           scsi_to_pci_dma_dir(SCpnt->sc_data_direction));
 504                                                         outl (SCpnt->SCp.have_data_in, padapter->mb2);
 505                                                         }
 506                                                 outl (cdb[5], padapter->mb0);
 507                                                 outl (cdb[3], padapter->mb3);
 508                                                 cmd = CMD_DASD_RAID_RQ;
 509                                                 break;
 510                                         }
 511                                 break;
 512                                 }
 513
 514                         if ( SCpnt->use_sg )
 515                                 {
 516                                 SCpnt->SCp.have_data_in = pci_map_single (padapter->pdev, ((struct scatterlist *)SCpnt->request_buffer)->address,
 517                                                                                   SCpnt->request_bufflen, scsi_to_pci_dma_dir (SCpnt->sc_data_direction));
 518                                 }
 519                         else
 520                                 {
 521                                 SCpnt->SCp.have_data_in = pci_map_single (padapter->pdev, SCpnt->request_buffer,
 522                                                                                   SCpnt->request_bufflen, scsi_to_pci_dma_dir (SCpnt->sc_data_direction));
 523                                 }
 524                         outl (SCpnt->SCp.have_data_in, padapter->mb2);
 525                         outl (SCpnt->request_bufflen, padapter->mb3);
 526                         cmd = CMD_DASD_SCSI_INQ;
 527                         break;
 528
 529                 case SCSIOP_TEST_UNIT_READY:                    // test unit ready CDB
 530                         SCpnt->SCp.have_data_in = pci_map_single (padapter->pdev, SCpnt->sense_buffer, sizeof (SCpnt->sense_buffer), PCI_DMA_FROMDEVICE);
 531                         outl (SCpnt->SCp.have_data_in, padapter->mb2);
 532                         outl (sizeof (SCpnt->sense_buffer), padapter->mb3);
 533                         cmd = CMD_TEST_READY;
 534                         break;
 535
 536                 case SCSIOP_READ_CAPACITY:                              // read capacity CDB
 537                         if ( SCpnt->use_sg )
 538                                 {
 539                                 SCpnt->SCp.have_data_in = pci_map_single (padapter->pdev, ((struct scatterlist *)(SCpnt->request_buffer))->address,
 540                                                                                   8, PCI_DMA_FROMDEVICE);
 541                                 }
 542                         else
 543                                 SCpnt->SCp.have_data_in = pci_map_single (padapter->pdev, SCpnt->request_buffer, 8, PCI_DMA_FROMDEVICE);
 544                         outl (SCpnt->SCp.have_data_in, padapter->mb2);
 545                         outl (8, padapter->mb3);
 546                         cmd = CMD_DASD_CAP;
 547                         break;
 548                 case SCSIOP_VERIFY:                                             // verify CDB
 549                         outw_p ((USHORT)cdb[8] | ((USHORT)cdb[7] << 8), padapter->mb0 + 2);
 550                         outl (XSCSI2LONG (&cdb[2]), padapter->mb1);
 551                         cmd = CMD_READ_SG;
 552                         break;
 553                 case SCSIOP_READ:                                               // read10 CDB
 554                         outw_p ((USHORT)cdb[8] | ((USHORT)cdb[7] << 8), padapter->mb0 + 2);
 555                         outl (XSCSI2LONG (&cdb[2]), padapter->mb1);
 556                         if ( BuildSgList (SCpnt, padapter, pdev) )
 557                                 cmd = CMD_READ;
 558                         else
 559                                 cmd = CMD_READ_SG;
 560                         break;
 561                 case SCSIOP_READ6:                                              // read6  CDB
 562                         outw_p (cdb[4], padapter->mb0 + 2);
 563                         outl ((SCSI2LONG (&cdb[1])) & 0x001FFFFF, padapter->mb1);
 564                         if ( BuildSgList (SCpnt, padapter, pdev) )
 565                                 cmd = CMD_READ;
 566                         else
 567                                 cmd = CMD_READ_SG;
 568                         break;
 569                 case SCSIOP_WRITE:                                              // write10 CDB
 570                         outw_p ((USHORT)cdb[8] | ((USHORT)cdb[7] << 8), padapter->mb0 + 2);
 571                         outl (XSCSI2LONG (&cdb[2]), padapter->mb1);
 572                         if ( BuildSgList (SCpnt, padapter, pdev) )
 573                                 cmd = CMD_WRITE;
 574                         else
 575                                 cmd = CMD_WRITE_SG;
 576                         break;
 577                 case SCSIOP_WRITE6:                                             // write6  CDB
 578                         outw_p (cdb[4], padapter->mb0 + 2);
 579                         outl ((SCSI2LONG (&cdb[1])) & 0x001FFFFF, padapter->mb1);
 580                         if ( BuildSgList (SCpnt, padapter, pdev) )
 581                                 cmd = CMD_WRITE;
 582                         else
 583                                 cmd = CMD_WRITE_SG;
 584                         break;
 585                 case SCSIOP_START_STOP_UNIT:
 586                         cmd = CMD_EJECT_MEDIA;
 587                         break;
 588                 case SCSIOP_MEDIUM_REMOVAL:
 589                         switch ( cdb[4] )
 590                                 {
 591                                 case 0:
 592                                         cmd = CMD_UNLOCK_DOOR;
 593                                         break;
 594                                 case 1:
 595                                         cmd = CMD_LOCK_DOOR;
 596                                         break;
 597                                 default:
 598                                         cmd = 0;
 599                                         break;
 600                                 }
 601                         if ( cmd )
 602                                 break;
 603                 default:
 604                         DEB (printk ("pci2000_queuecommand: Unsupported command %02X\n", *cdb));
 605                         OpDone (SCpnt, DID_ERROR << 16);
 606                         return 0;
 607                 }
 608
 609         if ( (pdev->tag = Command (padapter, cmd)) == 0 )
 610                 rc = DID_TIME_OUT;
 611 finished:;
 612         if ( rc != -1 )
 613                 OpDone (SCpnt, rc << 16);
 614         return 0;
 615         }
 616 /****************************************************************
 617  *      Name:   internal_done :LOCAL
 618  *
 619  *      Description:    Done handler for non-queued commands
 620  *
 621  *      Parameters:             SCpnt - Pointer to SCSI command structure.
 622  *
 623  *      Returns:                Nothing.
 624  *
 625  ****************************************************************/
 626 static void internal_done (Scsi_Cmnd * SCpnt)
 627         {
 628         SCpnt->SCp.Status++;
 629         }
 630 /****************************************************************
 631  *      Name:   Pci2000_Command
 632  *
 633  *      Description:    Process a command from the SCSI manager.
 634  *
 635  *      Parameters:             SCpnt - Pointer to SCSI command structure.
 636  *
 637  *      Returns:                Status code.
 638  *
 639  ****************************************************************/
 640 int Pci2000_Command (Scsi_Cmnd *SCpnt)
 641         {
 642         DEB(printk("pci2000_command: ..calling pci2000_queuecommand\n"));
 643
 644         Pci2000_QueueCommand (SCpnt, internal_done);
 645
 646     SCpnt->SCp.Status = 0;
 647         while (!SCpnt->SCp.Status)
 648                 barrier ();
 649         return SCpnt->result;
 650         }
 651 /****************************************************************
 652  *      Name:   Pci2000_Detect
 653  *
 654  *      Description:    Detect and initialize our boards.
 655  *
 656  *      Parameters:             tpnt - Pointer to SCSI host template structure.
 657  *
 658  *      Returns:                Number of adapters installed.
 659  *
 660  ****************************************************************/
 661 int Pci2000_Detect (Scsi_Host_Template *tpnt)
 662         {
 663         int                                     found = 0;
 664         int                                     installed = 0;
 665         struct Scsi_Host   *pshost;
 666         PADAPTER2000        padapter;
 667         int                                     z, zz;
 668         int                                     setirq;
 669         struct pci_dev     *pdev = NULL;
 670         UCHAR                      *consistent;
 671         dma_addr_t                      consistentDma;
 672
 673
 674         if ( !pci_present () )
 675                 {
 676                 printk ("pci2000: PCI BIOS not present\n");
 677                 return 0;
 678                 }
 679
 680         while ( (pdev = pci_find_device (VENDOR_PSI, DEVICE_ROY_1, pdev)) != NULL )
 681                 {
 682                 if (pci_enable_device(pdev))
 683                         continue;
 684                 pshost = scsi_register (tpnt, sizeof(ADAPTER2000));
 685                 if(pshost == NULL)
 686                         continue;
 687                 padapter = HOSTDATA(pshost);
 688
 689                 padapter->basePort = pci_resource_start (pdev, 1);
 690                 DEB (printk ("\nBase Regs = %#04X", padapter->basePort));                       // get the base I/O port address
 691                 padapter->mb0   = padapter->basePort + RTR_MAILBOX;                                     // get the 32 bit mail boxes
 692                 padapter->mb1   = padapter->basePort + RTR_MAILBOX + 4;
 693                 padapter->mb2   = padapter->basePort + RTR_MAILBOX + 8;
 694                 padapter->mb3   = padapter->basePort + RTR_MAILBOX + 12;
 695                 padapter->mb4   = padapter->basePort + RTR_MAILBOX + 16;
 696                 padapter->cmd   = padapter->basePort + RTR_LOCAL_DOORBELL;                      // command register
 697                 padapter->tag   = padapter->basePort + RTR_PCI_DOORBELL;                        // tag/response register
 698                 padapter->pdev = pdev;
 699
 700                 if ( WaitReady (padapter) )
 701                         goto unregister;
 702                 outb_p (0x84, padapter->mb0);
 703                 outb_p (CMD_SPECIFY, padapter->cmd);
 704                 if ( WaitReady (padapter) )
 705                         goto unregister;
 706
 707                 consistent = pci_alloc_consistent (pdev, consistentLen, &consistentDma);
 708                 if ( !consistent )
 709                         {
 710                         printk ("Unable to allocate DMA memory for PCI-2000 controller.\n");
 711                         goto unregister;
 712                         }
 713
 714                 scsi_set_pci_device(pshost, pdev);
 715                 pshost->irq = pdev->irq;
 716                 setirq = 1;
 717                 padapter->irqOwned = 0;
 718                 for ( z = 0;  z < installed;  z++ )                                                                     // scan for shared interrupts
 719                         {
 720                         if ( PsiHost[z]->irq == pshost->irq )                                                   // if shared then, don't posses
 721                                 setirq = 0;
 722                         }
 723                 if ( setirq )                                                                                           // if not shared, posses
 724                         {
 725                         if ( request_irq (pshost->irq, Irq_Handler, SA_SHIRQ, "pci2000", padapter) < 0 )
 726                                 {
 727                                 if ( request_irq (pshost->irq, Irq_Handler, SA_INTERRUPT | SA_SHIRQ, "pci2000", padapter) < 0 )
 728                                         {
 729                                         printk ("Unable to allocate IRQ for PCI-2000 controller.\n");
 730                                         pci_free_consistent (pdev, consistentLen, consistent, consistentDma);
 731                                         goto unregister;
 732                                         }
 733                                 }
 734                         padapter->irqOwned = pshost->irq;                                               // set IRQ as owned
 735                         }
 736                 PsiHost[installed]      = pshost;                                                                               // save SCSI_HOST pointer
 737
 738                 pshost->io_port         = padapter->basePort;
 739                 pshost->n_io_port       = 0xFF;
 740                 pshost->unique_id       = padapter->basePort;
 741                 pshost->max_id          = 16;
 742                 pshost->max_channel     = 1;
 743
 744                 for ( zz = 0;  zz < MAX_BUS;  zz++ )
 745                         for ( z = 0; z < MAX_UNITS;  z++ )
 746                                 {
 747                                 padapter->dev[zz][z].tag = 0;
 748                                 padapter->dev[zz][z].scatGath = (PSCATGATH)consistent;
 749                                 padapter->dev[zz][z].scatGathDma = consistentDma;
 750                                 consistent += 16 * sizeof (SCATGATH);
 751                                 consistentDma += 16 * sizeof (SCATGATH);
 752                                 padapter->dev[zz][z].cdb = (UCHAR *)consistent;
 753                                 padapter->dev[zz][z].cdbDma = consistentDma;
 754                                 consistent += MAX_COMMAND_SIZE;
 755                                 consistentDma += MAX_COMMAND_SIZE;
 756                                 }
 757
 758                 printk("\nPSI-2000 Intelligent Storage SCSI CONTROLLER: at I/O = %lX  IRQ = %d\n", padapter->basePort, pshost->irq);
 759                 printk("Version %s, Compiled %s %s\n\n", PCI2000_VERSION,  __DATE__, __TIME__);
 760                 found++;
 761                 if ( ++installed < MAXADAPTER )
 762                         continue;
 763                 break;
 764 unregister:;
 765                 scsi_unregister (pshost);
 766                 found++;
 767                 }
 768         NumAdapters = installed;
 769         return installed;
 770         }
 771 /****************************************************************
 772  *      Name:   Pci2000_Abort
 773  *
 774  *      Description:    Process the Abort command from the SCSI manager.
 775  *
 776  *      Parameters:             SCpnt - Pointer to SCSI command structure.
 777  *
 778  *      Returns:                Allways snooze.
 779  *
 780  ****************************************************************/
 781 int Pci2000_Abort (Scsi_Cmnd *SCpnt)
 782         {
 783         DEB (printk ("pci2000_abort\n"));
 784         return SCSI_ABORT_SNOOZE;
 785         }
 786 /****************************************************************
 787  *      Name:   Pci2000_Reset
 788  *
 789  *      Description:    Process the Reset command from the SCSI manager.
 790  *
 791  *      Parameters:             SCpnt - Pointer to SCSI command structure.
 792  *                                      flags - Flags about the reset command
 793  *
 794  *      Returns:                No active command at this time, so this means
 795  *                                      that each time we got some kind of response the
 796  *                                      last time through.  Tell the mid-level code to
 797  *                                      request sense information in order to decide what
 798  *                                      to do next.
 799  *
 800  ****************************************************************/
 801 int Pci2000_Reset (Scsi_Cmnd *SCpnt, unsigned int reset_flags)
 802         {
 803         return SCSI_RESET_PUNT;
 804         }
 805 /****************************************************************
 806  *      Name:   Pci2000_Release
 807  *
 808  *      Description:    Release resources allocated for a single each adapter.
 809  *
 810  *      Parameters:             pshost - Pointer to SCSI command structure.
 811  *
 812  *      Returns:                zero.
 813  *
 814  ****************************************************************/
 815 int Pci2000_Release (struct Scsi_Host *pshost)
 816         {
 817     PADAPTER2000        padapter = HOSTDATA (pshost);
 818
 819         if ( padapter->irqOwned )
 820                 free_irq (pshost->irq, padapter);
 821         pci_free_consistent (padapter->pdev, consistentLen, padapter->dev[0][0].scatGath, padapter->dev[0][0].scatGathDma);
 822         release_region (pshost->io_port, pshost->n_io_port);
 823     scsi_unregister(pshost);
 824     return 0;
 825         }
 826
 827 #include "sd.h"
 828 /****************************************************************
 829  *      Name:   Pci2000_BiosParam
 830  *
 831  *      Description:    Process the biosparam request from the SCSI manager to
 832  *                                      return C/H/S data.
 833  *
 834  *      Parameters:             disk - Pointer to SCSI disk structure.
 835  *                                      dev      - Major/minor number from kernel.
 836  *                                      geom - Pointer to integer array to place geometry data.
 837  *
 838  *      Returns:                zero.
 839  *
 840  ****************************************************************/
 841 int Pci2000_BiosParam (Scsi_Disk *disk, kdev_t dev, int geom[])
 842         {
 843         PADAPTER2000        padapter;
 844
 845         padapter = HOSTDATA(disk->device->host);
 846
 847         if ( WaitReady (padapter) )
 848                 return 0;
 849         outb_p (disk->device->id, padapter->mb0);
 850         outb_p (CMD_GET_PARMS, padapter->cmd);
 851         if ( WaitReady (padapter) )
 852                 return 0;
 853
 854         geom[0] = inb_p (padapter->mb2 + 3);
 855         geom[1] = inb_p (padapter->mb2 + 2);
 856         geom[2] = inw_p (padapter->mb2);
 857         return 0;
 858         }
 859
 860
 861 MODULE_LICENSE("Dual BSD/GPL");
 862 /* Eventually this will go into an include file, but this will be later */
 863 static Scsi_Host_Template driver_template = PCI2000;
 864
 865 #include "scsi_module.c"