You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
836 lines
24 KiB
836 lines
24 KiB
/****************************************************************************
|
|
* Perceptive Solutions, Inc. PCI-2000 device driver for Linux.
|
|
*
|
|
* pci2000.c - Linux Host Driver for PCI-2000 IntelliCache SCSI Adapters
|
|
*
|
|
* Copyright (c) 1997-1999 Perceptive Solutions, Inc.
|
|
* All Rights Reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that redistributions of source
|
|
* code retain the above copyright notice and this comment without
|
|
* modification.
|
|
*
|
|
* Technical updates and product information at:
|
|
* http://www.psidisk.com
|
|
*
|
|
* Please send questions, comments, bug reports to:
|
|
* tech@psidisk.com Technical Support
|
|
*
|
|
*
|
|
* Revisions 1.10 Jan-21-1999
|
|
* - Fixed sign on message to reflect proper controller name.
|
|
* - Added support for RAID status monitoring and control.
|
|
*
|
|
* Revisions 1.11 Mar-22-1999
|
|
* - Fixed control timeout to not lock up the entire system if
|
|
* controller goes offline completely.
|
|
*
|
|
* Revisions 1.12 Mar-26-1999
|
|
* - Fixed spinlock and PCI configuration.
|
|
*
|
|
* Revisions 1.20 Mar-27-2000
|
|
* - Added support for dynamic DMA
|
|
*
|
|
****************************************************************************/
|
|
#define PCI2000_VERSION "1.20"
|
|
|
|
#include <linux/blkdev.h>
|
|
#include <linux/interrupt.h>
|
|
#include <linux/module.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/types.h>
|
|
#include <linux/string.h>
|
|
#include <linux/pci.h>
|
|
#include <linux/ioport.h>
|
|
#include <linux/delay.h>
|
|
#include <linux/sched.h>
|
|
#include <linux/proc_fs.h>
|
|
#include <linux/stat.h>
|
|
#include <linux/spinlock.h>
|
|
|
|
#include <asm/dma.h>
|
|
#include <asm/system.h>
|
|
#include <asm/io.h>
|
|
|
|
#include "scsi.h"
|
|
#include <scsi/scsi_host.h>
|
|
#include "pci2000.h"
|
|
#include "psi_roy.h"
|
|
|
|
|
|
//#define DEBUG 1
|
|
|
|
#ifdef DEBUG
|
|
#define DEB(x) x
|
|
#define STOP_HERE {int st;for(st=0;st<100;st++){st=1;}}
|
|
#else
|
|
#define DEB(x)
|
|
#define STOP_HERE
|
|
#endif
|
|
|
|
typedef struct
|
|
{
|
|
unsigned int address;
|
|
unsigned int length;
|
|
} SCATGATH, *PSCATGATH;
|
|
|
|
typedef struct
|
|
{
|
|
Scsi_Cmnd *SCpnt;
|
|
PSCATGATH scatGath;
|
|
dma_addr_t scatGathDma;
|
|
UCHAR *cdb;
|
|
dma_addr_t cdbDma;
|
|
UCHAR tag;
|
|
} DEV2000, *PDEV2000;
|
|
|
|
typedef struct
|
|
{
|
|
ULONG basePort;
|
|
ULONG mb0;
|
|
ULONG mb1;
|
|
ULONG mb2;
|
|
ULONG mb3;
|
|
ULONG mb4;
|
|
ULONG cmd;
|
|
ULONG tag;
|
|
ULONG irqOwned;
|
|
struct pci_dev *pdev;
|
|
DEV2000 dev[MAX_BUS][MAX_UNITS];
|
|
} ADAPTER2000, *PADAPTER2000;
|
|
|
|
#define HOSTDATA(host) ((PADAPTER2000)&host->hostdata)
|
|
#define consistentLen (MAX_BUS * MAX_UNITS * (16 * sizeof (SCATGATH) + MAX_COMMAND_SIZE))
|
|
|
|
|
|
static struct Scsi_Host *PsiHost[MAXADAPTER] = {NULL,}; // One for each adapter
|
|
static int NumAdapters = 0;
|
|
/****************************************************************
|
|
* Name: WaitReady :LOCAL
|
|
*
|
|
* Description: Wait for controller ready.
|
|
*
|
|
* Parameters: padapter - Pointer adapter data structure.
|
|
*
|
|
* Returns: TRUE on not ready.
|
|
*
|
|
****************************************************************/
|
|
static int WaitReady (PADAPTER2000 padapter)
|
|
{
|
|
ULONG z;
|
|
|
|
for ( z = 0; z < (TIMEOUT_COMMAND * 4); z++ )
|
|
{
|
|
if ( !inb_p (padapter->cmd) )
|
|
return FALSE;
|
|
udelay (250);
|
|
};
|
|
return TRUE;
|
|
}
|
|
/****************************************************************
|
|
* Name: WaitReadyLong :LOCAL
|
|
*
|
|
* Description: Wait for controller ready.
|
|
*
|
|
* Parameters: padapter - Pointer adapter data structure.
|
|
*
|
|
* Returns: TRUE on not ready.
|
|
*
|
|
****************************************************************/
|
|
static int WaitReadyLong (PADAPTER2000 padapter)
|
|
{
|
|
ULONG z;
|
|
|
|
for ( z = 0; z < (5000 * 4); z++ )
|
|
{
|
|
if ( !inb_p (padapter->cmd) )
|
|
return FALSE;
|
|
udelay (250);
|
|
};
|
|
return TRUE;
|
|
}
|
|
/****************************************************************
|
|
* Name: OpDone :LOCAL
|
|
*
|
|
* Description: Clean up operation and issue done to caller.
|
|
*
|
|
* Parameters: SCpnt - Pointer to SCSI command structure.
|
|
* status - Caller status.
|
|
*
|
|
* Returns: Nothing.
|
|
*
|
|
****************************************************************/
|
|
static void OpDone (Scsi_Cmnd *SCpnt, ULONG status)
|
|
{
|
|
SCpnt->result = status;
|
|
SCpnt->scsi_done (SCpnt);
|
|
}
|
|
/****************************************************************
|
|
* Name: Command :LOCAL
|
|
*
|
|
* Description: Issue queued command to the PCI-2000.
|
|
*
|
|
* Parameters: padapter - Pointer to adapter information structure.
|
|
* cmd - PCI-2000 command byte.
|
|
*
|
|
* Returns: Non-zero command tag if operation is accepted.
|
|
*
|
|
****************************************************************/
|
|
static UCHAR Command (PADAPTER2000 padapter, UCHAR cmd)
|
|
{
|
|
outb_p (cmd, padapter->cmd);
|
|
if ( WaitReady (padapter) )
|
|
return 0;
|
|
|
|
if ( inw_p (padapter->mb0) )
|
|
return 0;
|
|
|
|
return inb_p (padapter->mb1);
|
|
}
|
|
/****************************************************************
|
|
* Name: BuildSgList :LOCAL
|
|
*
|
|
* Description: Build the scatter gather list for controller.
|
|
*
|
|
* Parameters: SCpnt - Pointer to SCSI command structure.
|
|
* padapter - Pointer to adapter information structure.
|
|
* pdev - Pointer to adapter device structure.
|
|
*
|
|
* Returns: Non-zero in not scatter gather.
|
|
*
|
|
****************************************************************/
|
|
static int BuildSgList (Scsi_Cmnd *SCpnt, PADAPTER2000 padapter, PDEV2000 pdev)
|
|
{
|
|
int z;
|
|
int zc;
|
|
struct scatterlist *sg;
|
|
|
|
if ( SCpnt->use_sg )
|
|
{
|
|
sg = (struct scatterlist *)SCpnt->request_buffer;
|
|
zc = pci_map_sg (padapter->pdev, sg, SCpnt->use_sg, SCpnt->sc_data_direction);
|
|
for ( z = 0; z < zc; z++ )
|
|
{
|
|
pdev->scatGath[z].address = cpu_to_le32 (sg_dma_address (sg));
|
|
pdev->scatGath[z].length = cpu_to_le32 (sg_dma_len (sg++));
|
|
}
|
|
outl (pdev->scatGathDma, padapter->mb2);
|
|
outl ((zc << 24) | SCpnt->request_bufflen, padapter->mb3);
|
|
return FALSE;
|
|
}
|
|
if ( !SCpnt->request_bufflen)
|
|
{
|
|
outl (0, padapter->mb2);
|
|
outl (0, padapter->mb3);
|
|
return TRUE;
|
|
}
|
|
SCpnt->SCp.have_data_in = pci_map_single (padapter->pdev,
|
|
SCpnt->request_buffer, SCpnt->request_bufflen,
|
|
SCpnt->sc_data_direction);
|
|
outl (SCpnt->SCp.have_data_in, padapter->mb2);
|
|
outl (SCpnt->request_bufflen, padapter->mb3);
|
|
return TRUE;
|
|
}
|
|
/*********************************************************************
|
|
* Name: PsiRaidCmd
|
|
*
|
|
* Description: Execute a simple command.
|
|
*
|
|
* Parameters: padapter - Pointer to adapter control structure.
|
|
* cmd - Roy command byte.
|
|
*
|
|
* Returns: Return error status.
|
|
*
|
|
********************************************************************/
|
|
static int PsiRaidCmd (PADAPTER2000 padapter, char cmd)
|
|
{
|
|
if ( WaitReady (padapter) ) // test for command register ready
|
|
return DID_TIME_OUT;
|
|
outb_p (cmd, padapter->cmd); // issue command
|
|
if ( WaitReadyLong (padapter) ) // wait for adapter ready
|
|
return DID_TIME_OUT;
|
|
return DID_OK;
|
|
}
|
|
/****************************************************************
|
|
* Name: Irq_Handler :LOCAL
|
|
*
|
|
* Description: Interrupt handler.
|
|
*
|
|
* Parameters: irq - Hardware IRQ number.
|
|
* dev_id -
|
|
* regs -
|
|
*
|
|
* Returns: TRUE if drive is not ready in time.
|
|
*
|
|
****************************************************************/
|
|
static irqreturn_t Irq_Handler (int irq, void *dev_id, struct pt_regs *regs)
|
|
{
|
|
struct Scsi_Host *shost = NULL; // Pointer to host data block
|
|
PADAPTER2000 padapter; // Pointer to adapter control structure
|
|
PDEV2000 pdev;
|
|
Scsi_Cmnd *SCpnt;
|
|
UCHAR tag = 0;
|
|
UCHAR tag0;
|
|
ULONG error;
|
|
int pun;
|
|
int bus;
|
|
int z;
|
|
unsigned long flags;
|
|
int handled = 0;
|
|
|
|
DEB(printk ("\npci2000 received interrupt "));
|
|
for ( z = 0; z < NumAdapters; z++ ) // scan for interrupt to process
|
|
{
|
|
if ( PsiHost[z]->irq == (UCHAR)(irq & 0xFF) )
|
|
{
|
|
tag = inb_p (HOSTDATA(PsiHost[z])->tag);
|
|
if ( tag )
|
|
{
|
|
shost = PsiHost[z];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( !shost )
|
|
{
|
|
DEB (printk ("\npci2000: not my interrupt"));
|
|
goto out;
|
|
}
|
|
|
|
handled = 1;
|
|
spin_lock_irqsave(shost->host_lock, flags);
|
|
padapter = HOSTDATA(shost);
|
|
|
|
tag0 = tag & 0x7F; // mask off the error bit
|
|
for ( bus = 0; bus < MAX_BUS; bus++ ) // scan the busses
|
|
{
|
|
for ( pun = 0; pun < MAX_UNITS; pun++ ) // scan the targets
|
|
{
|
|
pdev = &padapter->dev[bus][pun];
|
|
if ( !pdev->tag )
|
|
continue;
|
|
if ( pdev->tag == tag0 ) // is this it?
|
|
{
|
|
pdev->tag = 0;
|
|
SCpnt = pdev->SCpnt;
|
|
goto unmapProceed;
|
|
}
|
|
}
|
|
}
|
|
|
|
outb_p (0xFF, padapter->tag); // clear the op interrupt
|
|
outb_p (CMD_DONE, padapter->cmd); // complete the op
|
|
goto irq_return; // done, but, with what?
|
|
|
|
unmapProceed:;
|
|
if ( !bus )
|
|
{
|
|
switch ( SCpnt->cmnd[0] )
|
|
{
|
|
case SCSIOP_TEST_UNIT_READY:
|
|
pci_unmap_single (padapter->pdev, SCpnt->SCp.have_data_in, sizeof (SCpnt->sense_buffer), PCI_DMA_FROMDEVICE);
|
|
goto irqProceed;
|
|
case SCSIOP_READ_CAPACITY:
|
|
pci_unmap_single (padapter->pdev, SCpnt->SCp.have_data_in, 8, PCI_DMA_FROMDEVICE);
|
|
goto irqProceed;
|
|
case SCSIOP_VERIFY:
|
|
case SCSIOP_START_STOP_UNIT:
|
|
case SCSIOP_MEDIUM_REMOVAL:
|
|
goto irqProceed;
|
|
}
|
|
}
|
|
if ( SCpnt->SCp.have_data_in )
|
|
pci_unmap_single (padapter->pdev, SCpnt->SCp.have_data_in, SCpnt->request_bufflen, SCpnt->sc_data_direction);
|
|
else
|
|
{
|
|
if ( SCpnt->use_sg )
|
|
pci_unmap_sg (padapter->pdev, (struct scatterlist *)SCpnt->request_buffer, SCpnt->use_sg, SCpnt->sc_data_direction);
|
|
}
|
|
|
|
irqProceed:;
|
|
if ( tag & ERR08_TAGGED ) // is there an error here?
|
|
{
|
|
if ( WaitReady (padapter) )
|
|
{
|
|
OpDone (SCpnt, DID_TIME_OUT << 16);
|
|
goto irq_return;
|
|
}
|
|
|
|
outb_p (tag0, padapter->mb0); // get real error code
|
|
outb_p (CMD_ERROR, padapter->cmd);
|
|
if ( WaitReady (padapter) ) // wait for controller to suck up the op
|
|
{
|
|
OpDone (SCpnt, DID_TIME_OUT << 16);
|
|
goto irq_return;
|
|
}
|
|
|
|
error = inl (padapter->mb0); // get error data
|
|
outb_p (0xFF, padapter->tag); // clear the op interrupt
|
|
outb_p (CMD_DONE, padapter->cmd); // complete the op
|
|
|
|
DEB (printk ("status: %lX ", error));
|
|
if ( error == 0x00020002 ) // is this error a check condition?
|
|
{
|
|
if ( bus ) // are we doint SCSI commands?
|
|
{
|
|
OpDone (SCpnt, (DID_OK << 16) | 2);
|
|
goto irq_return;
|
|
}
|
|
if ( *SCpnt->cmnd == SCSIOP_TEST_UNIT_READY )
|
|
OpDone (SCpnt, (DRIVER_SENSE << 24) | (DID_OK << 16) | 2); // test caller we have sense data too
|
|
else
|
|
OpDone (SCpnt, DID_ERROR << 16);
|
|
goto irq_return;
|
|
}
|
|
OpDone (SCpnt, DID_ERROR << 16);
|
|
goto irq_return;
|
|
}
|
|
|
|
outb_p (0xFF, padapter->tag); // clear the op interrupt
|
|
outb_p (CMD_DONE, padapter->cmd); // complete the op
|
|
OpDone (SCpnt, DID_OK << 16);
|
|
|
|
irq_return:
|
|
spin_unlock_irqrestore(shost->host_lock, flags);
|
|
out:
|
|
return IRQ_RETVAL(handled);
|
|
}
|
|
/****************************************************************
|
|
* Name: Pci2000_QueueCommand
|
|
*
|
|
* Description: Process a queued command from the SCSI manager.
|
|
*
|
|
* Parameters: SCpnt - Pointer to SCSI command structure.
|
|
* done - Pointer to done function to call.
|
|
*
|
|
* Returns: Status code.
|
|
*
|
|
****************************************************************/
|
|
int Pci2000_QueueCommand (Scsi_Cmnd *SCpnt, void (*done)(Scsi_Cmnd *))
|
|
{
|
|
UCHAR *cdb = (UCHAR *)SCpnt->cmnd; // Pointer to SCSI CDB
|
|
PADAPTER2000 padapter = HOSTDATA(SCpnt->device->host); // Pointer to adapter control structure
|
|
int rc = -1; // command return code
|
|
UCHAR bus = SCpnt->device->channel;
|
|
UCHAR pun = SCpnt->device->id;
|
|
UCHAR lun = SCpnt->device->lun;
|
|
UCHAR cmd;
|
|
PDEV2000 pdev = &padapter->dev[bus][pun];
|
|
|
|
if ( !done )
|
|
{
|
|
printk("pci2000_queuecommand: %02X: done can't be NULL\n", *cdb);
|
|
return 0;
|
|
}
|
|
|
|
SCpnt->scsi_done = done;
|
|
SCpnt->SCp.have_data_in = 0;
|
|
pdev->SCpnt = SCpnt; // Save this command data
|
|
|
|
if ( WaitReady (padapter) )
|
|
{
|
|
rc = DID_ERROR;
|
|
goto finished;
|
|
}
|
|
|
|
outw_p (pun | (lun << 8), padapter->mb0);
|
|
|
|
if ( bus )
|
|
{
|
|
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]));
|
|
DEB (if(*cdb) printk ("\ntimeout_per_command: %d, timeout_total: %d, timeout: %d", SCpnt->timeout_per_command,
|
|
SCpnt->timeout_total, SCpnt->timeout));
|
|
outl (SCpnt->timeout_per_command, padapter->mb1);
|
|
outb_p (CMD_SCSI_TIMEOUT, padapter->cmd);
|
|
if ( WaitReady (padapter) )
|
|
{
|
|
rc = DID_ERROR;
|
|
goto finished;
|
|
}
|
|
|
|
outw_p (pun | (lun << 8), padapter->mb0);
|
|
outw_p (SCpnt->cmd_len << 8, padapter->mb0 + 2);
|
|
memcpy (pdev->cdb, cdb, MAX_COMMAND_SIZE);
|
|
|
|
outl (pdev->cdbDma, padapter->mb1);
|
|
if ( BuildSgList (SCpnt, padapter, pdev) )
|
|
cmd = CMD_SCSI_THRU;
|
|
else
|
|
cmd = CMD_SCSI_THRU_SG;
|
|
if ( (pdev->tag = Command (padapter, cmd)) == 0 )
|
|
rc = DID_TIME_OUT;
|
|
goto finished;
|
|
}
|
|
else
|
|
{
|
|
if ( lun )
|
|
{
|
|
rc = DID_BAD_TARGET;
|
|
goto finished;
|
|
}
|
|
}
|
|
|
|
switch ( *cdb )
|
|
{
|
|
case SCSIOP_INQUIRY: // inquiry CDB
|
|
if ( cdb[2] == SC_MY_RAID )
|
|
{
|
|
switch ( cdb[3] )
|
|
{
|
|
case MY_SCSI_REBUILD:
|
|
OpDone (SCpnt, PsiRaidCmd (padapter, CMD_RAID_REBUILD) << 16);
|
|
return 0;
|
|
case MY_SCSI_ALARMMUTE:
|
|
OpDone (SCpnt, PsiRaidCmd (padapter, CMD_RAID_MUTE) << 16);
|
|
return 0;
|
|
case MY_SCSI_DEMOFAIL:
|
|
OpDone (SCpnt, PsiRaidCmd (padapter, CMD_RAID_FAIL) << 16);
|
|
return 0;
|
|
default:
|
|
if ( SCpnt->use_sg )
|
|
{
|
|
rc = DID_ERROR;
|
|
goto finished;
|
|
}
|
|
else
|
|
{
|
|
SCpnt->SCp.have_data_in = pci_map_single (padapter->pdev, SCpnt->request_buffer, SCpnt->request_bufflen,
|
|
SCpnt->sc_data_direction);
|
|
outl (SCpnt->SCp.have_data_in, padapter->mb2);
|
|
}
|
|
outl (cdb[5], padapter->mb0);
|
|
outl (cdb[3], padapter->mb3);
|
|
cmd = CMD_DASD_RAID_RQ;
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
|
|
if ( SCpnt->use_sg )
|
|
{
|
|
SCpnt->SCp.have_data_in = pci_map_single (padapter->pdev,
|
|
((struct scatterlist *)SCpnt->request_buffer)->address,
|
|
SCpnt->request_bufflen,
|
|
SCpnt->sc_data_direction);
|
|
}
|
|
else
|
|
{
|
|
SCpnt->SCp.have_data_in = pci_map_single (padapter->pdev, SCpnt->request_buffer,
|
|
SCpnt->request_bufflen,
|
|
SCpnt->sc_data_direction);
|
|
}
|
|
outl (SCpnt->SCp.have_data_in, padapter->mb2);
|
|
outl (SCpnt->request_bufflen, padapter->mb3);
|
|
cmd = CMD_DASD_SCSI_INQ;
|
|
break;
|
|
|
|
case SCSIOP_TEST_UNIT_READY: // test unit ready CDB
|
|
SCpnt->SCp.have_data_in = pci_map_single (padapter->pdev, SCpnt->sense_buffer, sizeof (SCpnt->sense_buffer), PCI_DMA_FROMDEVICE);
|
|
outl (SCpnt->SCp.have_data_in, padapter->mb2);
|
|
outl (sizeof (SCpnt->sense_buffer), padapter->mb3);
|
|
cmd = CMD_TEST_READY;
|
|
break;
|
|
|
|
case SCSIOP_READ_CAPACITY: // read capacity CDB
|
|
if ( SCpnt->use_sg )
|
|
{
|
|
SCpnt->SCp.have_data_in = pci_map_single (padapter->pdev, ((struct scatterlist *)(SCpnt->request_buffer))->address,
|
|
8, PCI_DMA_FROMDEVICE);
|
|
}
|
|
else
|
|
SCpnt->SCp.have_data_in = pci_map_single (padapter->pdev, SCpnt->request_buffer, 8, PCI_DMA_FROMDEVICE);
|
|
outl (SCpnt->SCp.have_data_in, padapter->mb2);
|
|
outl (8, padapter->mb3);
|
|
cmd = CMD_DASD_CAP;
|
|
break;
|
|
case SCSIOP_VERIFY: // verify CDB
|
|
outw_p ((USHORT)cdb[8] | ((USHORT)cdb[7] << 8), padapter->mb0 + 2);
|
|
outl (XSCSI2LONG (&cdb[2]), padapter->mb1);
|
|
cmd = CMD_READ_SG;
|
|
break;
|
|
case SCSIOP_READ: // read10 CDB
|
|
outw_p ((USHORT)cdb[8] | ((USHORT)cdb[7] << 8), padapter->mb0 + 2);
|
|
outl (XSCSI2LONG (&cdb[2]), padapter->mb1);
|
|
if ( BuildSgList (SCpnt, padapter, pdev) )
|
|
cmd = CMD_READ;
|
|
else
|
|
cmd = CMD_READ_SG;
|
|
break;
|
|
case SCSIOP_READ6: // read6 CDB
|
|
outw_p (cdb[4], padapter->mb0 + 2);
|
|
outl ((SCSI2LONG (&cdb[1])) & 0x001FFFFF, padapter->mb1);
|
|
if ( BuildSgList (SCpnt, padapter, pdev) )
|
|
cmd = CMD_READ;
|
|
else
|
|
cmd = CMD_READ_SG;
|
|
break;
|
|
case SCSIOP_WRITE: // write10 CDB
|
|
outw_p ((USHORT)cdb[8] | ((USHORT)cdb[7] << 8), padapter->mb0 + 2);
|
|
outl (XSCSI2LONG (&cdb[2]), padapter->mb1);
|
|
if ( BuildSgList (SCpnt, padapter, pdev) )
|
|
cmd = CMD_WRITE;
|
|
else
|
|
cmd = CMD_WRITE_SG;
|
|
break;
|
|
case SCSIOP_WRITE6: // write6 CDB
|
|
outw_p (cdb[4], padapter->mb0 + 2);
|
|
outl ((SCSI2LONG (&cdb[1])) & 0x001FFFFF, padapter->mb1);
|
|
if ( BuildSgList (SCpnt, padapter, pdev) )
|
|
cmd = CMD_WRITE;
|
|
else
|
|
cmd = CMD_WRITE_SG;
|
|
break;
|
|
case SCSIOP_START_STOP_UNIT:
|
|
cmd = CMD_EJECT_MEDIA;
|
|
break;
|
|
case SCSIOP_MEDIUM_REMOVAL:
|
|
switch ( cdb[4] )
|
|
{
|
|
case 0:
|
|
cmd = CMD_UNLOCK_DOOR;
|
|
break;
|
|
case 1:
|
|
cmd = CMD_LOCK_DOOR;
|
|
break;
|
|
default:
|
|
cmd = 0;
|
|
break;
|
|
}
|
|
if ( cmd )
|
|
break;
|
|
default:
|
|
DEB (printk ("pci2000_queuecommand: Unsupported command %02X\n", *cdb));
|
|
OpDone (SCpnt, DID_ERROR << 16);
|
|
return 0;
|
|
}
|
|
|
|
if ( (pdev->tag = Command (padapter, cmd)) == 0 )
|
|
rc = DID_TIME_OUT;
|
|
finished:;
|
|
if ( rc != -1 )
|
|
OpDone (SCpnt, rc << 16);
|
|
return 0;
|
|
}
|
|
/****************************************************************
|
|
* Name: Pci2000_Detect
|
|
*
|
|
* Description: Detect and initialize our boards.
|
|
*
|
|
* Parameters: tpnt - Pointer to SCSI host template structure.
|
|
*
|
|
* Returns: Number of adapters installed.
|
|
*
|
|
****************************************************************/
|
|
int Pci2000_Detect (Scsi_Host_Template *tpnt)
|
|
{
|
|
int found = 0;
|
|
int installed = 0;
|
|
struct Scsi_Host *pshost;
|
|
PADAPTER2000 padapter;
|
|
int z, zz;
|
|
int setirq;
|
|
struct pci_dev *pdev = NULL;
|
|
UCHAR *consistent;
|
|
dma_addr_t consistentDma;
|
|
|
|
while ( (pdev = pci_find_device (VENDOR_PSI, DEVICE_ROY_1, pdev)) != NULL )
|
|
{
|
|
if (pci_enable_device(pdev))
|
|
continue;
|
|
pshost = scsi_register (tpnt, sizeof(ADAPTER2000));
|
|
if(pshost == NULL)
|
|
continue;
|
|
padapter = HOSTDATA(pshost);
|
|
|
|
padapter->basePort = pci_resource_start (pdev, 1);
|
|
DEB (printk ("\nBase Regs = %#04X", padapter->basePort)); // get the base I/O port address
|
|
padapter->mb0 = padapter->basePort + RTR_MAILBOX; // get the 32 bit mail boxes
|
|
padapter->mb1 = padapter->basePort + RTR_MAILBOX + 4;
|
|
padapter->mb2 = padapter->basePort + RTR_MAILBOX + 8;
|
|
padapter->mb3 = padapter->basePort + RTR_MAILBOX + 12;
|
|
padapter->mb4 = padapter->basePort + RTR_MAILBOX + 16;
|
|
padapter->cmd = padapter->basePort + RTR_LOCAL_DOORBELL; // command register
|
|
padapter->tag = padapter->basePort + RTR_PCI_DOORBELL; // tag/response register
|
|
padapter->pdev = pdev;
|
|
|
|
if ( WaitReady (padapter) )
|
|
goto unregister;
|
|
outb_p (0x84, padapter->mb0);
|
|
outb_p (CMD_SPECIFY, padapter->cmd);
|
|
if ( WaitReady (padapter) )
|
|
goto unregister;
|
|
|
|
consistent = pci_alloc_consistent (pdev, consistentLen, &consistentDma);
|
|
if ( !consistent )
|
|
{
|
|
printk ("Unable to allocate DMA memory for PCI-2000 controller.\n");
|
|
goto unregister;
|
|
}
|
|
|
|
scsi_set_device(pshost, &pdev->dev);
|
|
pshost->irq = pdev->irq;
|
|
setirq = 1;
|
|
padapter->irqOwned = 0;
|
|
for ( z = 0; z < installed; z++ ) // scan for shared interrupts
|
|
{
|
|
if ( PsiHost[z]->irq == pshost->irq ) // if shared then, don't posses
|
|
setirq = 0;
|
|
}
|
|
if ( setirq ) // if not shared, posses
|
|
{
|
|
if ( request_irq (pshost->irq, Irq_Handler, SA_SHIRQ, "pci2000", padapter) < 0 )
|
|
{
|
|
if ( request_irq (pshost->irq, Irq_Handler, SA_INTERRUPT | SA_SHIRQ, "pci2000", padapter) < 0 )
|
|
{
|
|
printk ("Unable to allocate IRQ for PCI-2000 controller.\n");
|
|
pci_free_consistent (pdev, consistentLen, consistent, consistentDma);
|
|
goto unregister;
|
|
}
|
|
}
|
|
padapter->irqOwned = pshost->irq; // set IRQ as owned
|
|
}
|
|
PsiHost[installed] = pshost; // save SCSI_HOST pointer
|
|
|
|
pshost->io_port = padapter->basePort;
|
|
pshost->n_io_port = 0xFF;
|
|
pshost->unique_id = padapter->basePort;
|
|
pshost->max_id = 16;
|
|
pshost->max_channel = 1;
|
|
|
|
for ( zz = 0; zz < MAX_BUS; zz++ )
|
|
for ( z = 0; z < MAX_UNITS; z++ )
|
|
{
|
|
padapter->dev[zz][z].tag = 0;
|
|
padapter->dev[zz][z].scatGath = (PSCATGATH)consistent;
|
|
padapter->dev[zz][z].scatGathDma = consistentDma;
|
|
consistent += 16 * sizeof (SCATGATH);
|
|
consistentDma += 16 * sizeof (SCATGATH);
|
|
padapter->dev[zz][z].cdb = (UCHAR *)consistent;
|
|
padapter->dev[zz][z].cdbDma = consistentDma;
|
|
consistent += MAX_COMMAND_SIZE;
|
|
consistentDma += MAX_COMMAND_SIZE;
|
|
}
|
|
|
|
printk("\nPSI-2000 Intelligent Storage SCSI CONTROLLER: at I/O = %lX IRQ = %d\n", padapter->basePort, pshost->irq);
|
|
printk("Version %s, Compiled %s %s\n\n", PCI2000_VERSION, __DATE__, __TIME__);
|
|
found++;
|
|
if ( ++installed < MAXADAPTER )
|
|
continue;
|
|
break;
|
|
unregister:;
|
|
scsi_unregister (pshost);
|
|
found++;
|
|
}
|
|
NumAdapters = installed;
|
|
return installed;
|
|
}
|
|
/****************************************************************
|
|
* Name: Pci2000_Abort
|
|
*
|
|
* Description: Process the Abort command from the SCSI manager.
|
|
*
|
|
* Parameters: SCpnt - Pointer to SCSI command structure.
|
|
*
|
|
* Returns: Allways snooze.
|
|
*
|
|
****************************************************************/
|
|
int Pci2000_Abort (Scsi_Cmnd *SCpnt)
|
|
{
|
|
DEB (printk ("pci2000_abort\n"));
|
|
return SCSI_ABORT_SNOOZE;
|
|
}
|
|
/****************************************************************
|
|
* Name: Pci2000_Reset
|
|
*
|
|
* Description: Process the Reset command from the SCSI manager.
|
|
*
|
|
* Parameters: SCpnt - Pointer to SCSI command structure.
|
|
* flags - Flags about the reset command
|
|
*
|
|
* Returns: No active command at this time, so this means
|
|
* that each time we got some kind of response the
|
|
* last time through. Tell the mid-level code to
|
|
* request sense information in order to decide what
|
|
* to do next.
|
|
*
|
|
****************************************************************/
|
|
int Pci2000_Reset (Scsi_Cmnd *SCpnt, unsigned int reset_flags)
|
|
{
|
|
return SCSI_RESET_PUNT;
|
|
}
|
|
/****************************************************************
|
|
* Name: Pci2000_Release
|
|
*
|
|
* Description: Release resources allocated for a single each adapter.
|
|
*
|
|
* Parameters: pshost - Pointer to SCSI command structure.
|
|
*
|
|
* Returns: zero.
|
|
*
|
|
****************************************************************/
|
|
int Pci2000_Release (struct Scsi_Host *pshost)
|
|
{
|
|
PADAPTER2000 padapter = HOSTDATA (pshost);
|
|
|
|
if ( padapter->irqOwned )
|
|
free_irq (pshost->irq, padapter);
|
|
pci_free_consistent (padapter->pdev, consistentLen, padapter->dev[0][0].scatGath, padapter->dev[0][0].scatGathDma);
|
|
release_region (pshost->io_port, pshost->n_io_port);
|
|
scsi_unregister(pshost);
|
|
return 0;
|
|
}
|
|
|
|
/****************************************************************
|
|
* Name: Pci2000_BiosParam
|
|
*
|
|
* Description: Process the biosparam request from the SCSI manager to
|
|
* return C/H/S data.
|
|
*
|
|
* Parameters: disk - Pointer to SCSI disk structure.
|
|
* dev - Major/minor number from kernel.
|
|
* geom - Pointer to integer array to place geometry data.
|
|
*
|
|
* Returns: zero.
|
|
*
|
|
****************************************************************/
|
|
int Pci2000_BiosParam (struct scsi_device *sdev, struct block_device *dev,
|
|
sector_t capacity, int geom[])
|
|
{
|
|
PADAPTER2000 padapter;
|
|
|
|
padapter = HOSTDATA(sdev->host);
|
|
|
|
if ( WaitReady (padapter) )
|
|
return 0;
|
|
outb_p (sdev->id, padapter->mb0);
|
|
outb_p (CMD_GET_PARMS, padapter->cmd);
|
|
if ( WaitReady (padapter) )
|
|
return 0;
|
|
|
|
geom[0] = inb_p (padapter->mb2 + 3);
|
|
geom[1] = inb_p (padapter->mb2 + 2);
|
|
geom[2] = inw_p (padapter->mb2);
|
|
return 0;
|
|
}
|
|
|
|
|
|
MODULE_LICENSE("Dual BSD/GPL");
|
|
|
|
static Scsi_Host_Template driver_template = {
|
|
.proc_name = "pci2000",
|
|
.name = "PCI-2000 SCSI Intelligent Disk Controller",
|
|
.detect = Pci2000_Detect,
|
|
.release = Pci2000_Release,
|
|
.queuecommand = Pci2000_QueueCommand,
|
|
.abort = Pci2000_Abort,
|
|
.reset = Pci2000_Reset,
|
|
.bios_param = Pci2000_BiosParam,
|
|
.can_queue = 16,
|
|
.this_id = -1,
|
|
.sg_tablesize = 16,
|
|
.cmd_per_lun = 1,
|
|
.use_clustering = DISABLE_CLUSTERING,
|
|
};
|
|
#include "scsi_module.c"
|
|
|