URL
https://opencores.org/ocsvn/or1k/or1k/trunk
Subversion Repositories or1k
[/] [or1k/] [trunk/] [rc203soc/] [sw/] [uClinux/] [drivers/] [scsi/] [AM53C974.c] - Rev 1765
Compare with Previous | Blame | View Log
#include <linux/module.h> #include <linux/config.h> #include <linux/delay.h> #include <linux/signal.h> #include <linux/sched.h> #include <linux/errno.h> #include <linux/bios32.h> #include <linux/pci.h> #include <linux/string.h> #include <linux/blk.h> #include <asm/io.h> #include <asm/system.h> #include "scsi.h" #include "hosts.h" #include "AM53C974.h" #include "constants.h" #include "sd.h" /* AM53/79C974 (PCscsi) driver release 0.5 * * The architecture and much of the code of this device * driver was originally developed by Drew Eckhardt for * the NCR5380. The following copyrights apply: * For the architecture and all pieces of code which can also be found * in the NCR5380 device driver: * Copyright 1993, Drew Eckhardt * Visionary Computing * (Unix and Linux consulting and custom programming) * drew@colorado.edu * +1 (303) 666-5836 * * The AM53C974_nobios_detect code was originally developed by * Robin Cutshaw (robin@xfree86.org) and is used here in a * slightly modified form. * * For the remaining code: * Copyright 1994, D. Frieauff * EMail: fri@rsx42sun0.dofn.de * Phone: x49-7545-8-2256 , x49-7541-42305 */ /* * $Log: not supported by cvs2svn $ * Revision 1.1.1.1 2001/09/10 07:44:28 simons * Initial import * * Revision 1.1.1.1 2001/07/02 17:58:29 simons * Initial revision * */ #ifdef AM53C974_DEBUG #define DEB(x) x #ifdef AM53C974_DEBUG_KEYWAIT #define KEYWAIT() AM53C974_keywait() #else #define KEYWAIT() #endif #ifdef AM53C974_DEBUG_INIT #define DEB_INIT(x) x #else #define DEB_INIT(x) #endif #ifdef AM53C974_DEBUG_MSG #define DEB_MSG(x) x #else #define DEB_MSG(x) #endif #ifdef AM53C974_DEB_RESEL #define DEB_RESEL(x) x #else #define DEB_RESEL(x) #endif #ifdef AM53C974_DEBUG_QUEUE #define DEB_QUEUE(x) x #define LIST(x,y) {printk("LINE:%d Adding %p to %p\n", __LINE__, (void*)(x), (void*)(y)); if ((x)==(y)) udelay(5); } #define REMOVE(w,x,y,z) {printk("LINE:%d Removing: %p->%p %p->%p \n", __LINE__, (void*)(w), (void*)(x), (void*)(y), (void*)(z)); if ((x)==(y)) udelay(5); } #else #define DEB_QUEUE(x) #define LIST(x,y) #define REMOVE(w,x,y,z) #endif #ifdef AM53C974_DEBUG_INFO #define DEB_INFO(x) x #else #define DEB_INFO(x) #endif #ifdef AM53C974_DEBUG_LINKED #define DEB_LINKED(x) x #else #define DEB_LINKED(x) #endif #ifdef AM53C974_DEBUG_INTR #define DEB_INTR(x) x #else #define DEB_INTR(x) #endif #else #define DEB_INIT(x) #define DEB(x) #define DEB_QUEUE(x) #define LIST(x,y) #define REMOVE(w,x,y,z) #define DEB_INFO(x) #define DEB_LINKED(x) #define DEB_INTR(x) #define DEB_MSG(x) #define DEB_RESEL(x) #define KEYWAIT() #endif #ifdef AM53C974_DEBUG_ABORT #define DEB_ABORT(x) x #else #define DEB_ABORT(x) #endif #ifdef VERBOSE_AM53C974_DEBUG #define VDEB(x) x #else #define VDEB(x) #endif #define INSIDE(x,l,h) ( ((x) >= (l)) && ((x) <= (h)) ) #ifdef AM53C974_DEBUG static void AM53C974_print_pci(struct Scsi_Host *instance); static void AM53C974_print_phase(struct Scsi_Host *instance); static void AM53C974_print_queues(struct Scsi_Host *instance); #endif /* AM53C974_DEBUG */ static void AM53C974_print(struct Scsi_Host *instance); static void AM53C974_keywait(void); static int AM53C974_bios_detect(Scsi_Host_Template *tpnt); static int AM53C974_nobios_detect(Scsi_Host_Template *tpnt); static int AM53C974_init(Scsi_Host_Template *tpnt, pci_config_t pci_config); static void AM53C974_config_after_reset(struct Scsi_Host *instance); static __inline__ void initialize_SCp(Scsi_Cmnd *cmd); static __inline__ void run_main(void); static void AM53C974_main (void); static void AM53C974_intr(int irq, void *dev_id, struct pt_regs *regs); static void AM53C974_intr_disconnect(struct Scsi_Host *instance); static int AM53C974_sync_neg(struct Scsi_Host *instance, int target, unsigned char *msg); static __inline__ void AM53C974_set_async(struct Scsi_Host *instance, int target); static __inline__ void AM53C974_set_sync(struct Scsi_Host *instance, int target); static void AM53C974_information_transfer(struct Scsi_Host *instance, unsigned char statreg, unsigned char isreg, unsigned char instreg, unsigned char cfifo, unsigned char dmastatus); static int AM53C974_message(struct Scsi_Host *instance, Scsi_Cmnd *cmd, unsigned char msg); static void AM53C974_select(struct Scsi_Host *instance, Scsi_Cmnd *cmd, int tag); static void AM53C974_intr_reselect(struct Scsi_Host *instance, unsigned char statreg); static __inline__ void AM53C974_transfer_dma(struct Scsi_Host *instance, short dir, unsigned long length, char *data); static void AM53C974_dma_blast(struct Scsi_Host *instance, unsigned char dmastatus, unsigned char statreg); static void AM53C974_intr_bus_reset(struct Scsi_Host *instance); static struct Scsi_Host *first_instance = NULL; static Scsi_Host_Template *the_template = NULL; static struct Scsi_Host *first_host = NULL; /* Head of list of AMD boards */ static volatile int main_running = 0; static int commandline_current = 0; override_t overrides[7] = { {-1, 0, 0, 0}, }; /* LILO overrides */ struct proc_dir_entry proc_scsi_am53c974 = { PROC_SCSI_AM53C974, 8, "am53c974", S_IFDIR | S_IRUGO | S_IXUGO, 2 }; #ifdef AM53C974_DEBUG static int deb_stop = 1; /************************************************************************** * Function : void AM53C974_print_pci(struct Scsi_Host *instance) * * Purpose : dump the PCI registers for debugging purposes * * Input : instance - which AM53C974 **************************************************************************/ static void AM53C974_print_pci(struct Scsi_Host *instance) { int i; unsigned short vendor_id, device_id, command, status, scratch[8]; unsigned long class_revision, base; unsigned char irq, cache_line_size, latency_timer, header_type; AM53C974_PCIREG_OPEN(); for (i = 0; i < 8; i++) *(scratch + i) = AM53C974_PCIREG_READ_WORD(instance, PCI_SCRATCH_REG_0 + 2*i); vendor_id = AM53C974_PCIREG_READ_WORD(instance, PCI_VENDOR_ID); device_id = AM53C974_PCIREG_READ_WORD(instance, PCI_DEVICE_ID); command = AM53C974_PCIREG_READ_WORD(instance, PCI_COMMAND); status = AM53C974_PCIREG_READ_WORD(instance, PCI_STATUS); class_revision = AM53C974_PCIREG_READ_DWORD(instance, PCI_CLASS_REVISION); cache_line_size = AM53C974_PCIREG_READ_BYTE(instance, PCI_CACHE_LINE_SIZE); latency_timer = AM53C974_PCIREG_READ_BYTE(instance, PCI_LATENCY_TIMER); header_type = AM53C974_PCIREG_READ_BYTE(instance, PCI_HEADER_TYPE); base = AM53C974_PCIREG_READ_DWORD(instance, PCI_BASE_ADDRESS_0); irq = AM53C974_PCIREG_READ_BYTE(instance, PCI_INTERRUPT_LINE); AM53C974_PCIREG_CLOSE(); printk("------------- start of PCI register dump -------------\n"); printk("PCI_VENDOR_ID: 0x%x\n", vendor_id); printk("PCI_DEVICE_ID: 0x%x\n", device_id); printk("PCI_COMMAND: 0x%x\n", command); printk("PCI_STATUS: 0x%x\n", status); printk("PCI_CLASS_REVISION: 0x%lx\n", class_revision); printk("PCI_CACHE_LINE_SIZE: 0x%x\n", cache_line_size); printk("PCI_LATENCY_TIMER: 0x%x\n", latency_timer); printk("PCI_HEADER_TYPE: 0x%x\n", header_type); printk("PCI_BASE_ADDRESS_0: 0x%lx\n", base); printk("PCI_INTERRUPT_LINE: %d\n", irq); for (i = 0; i < 8; i++) printk("PCI_SCRATCH_%d: 0x%x\n", i, scratch[i]); printk("------------- end of PCI register dump -------------\n\n"); } static struct { unsigned char value; char *name; } phases[] = { {PHASE_DATAOUT, "DATAOUT"}, {PHASE_DATAIN, "DATAIN"}, {PHASE_CMDOUT, "CMDOUT"}, {PHASE_STATIN, "STATIN"}, {PHASE_MSGOUT, "MSGOUT"}, {PHASE_MSGIN, "MSGIN"}, {PHASE_RES_0, "RESERVED 0"}, {PHASE_RES_1, "RESERVED 1"}}; /************************************************************************** * Function : void AM53C974_print_phase(struct Scsi_Host *instance) * * Purpose : print the current SCSI phase for debugging purposes * * Input : instance - which AM53C974 **************************************************************************/ static void AM53C974_print_phase(struct Scsi_Host *instance) { AM53C974_local_declare(); unsigned char statreg, latched; int i; AM53C974_setio(instance); latched = (AM53C974_read_8(CNTLREG2)) & CNTLREG2_ENF; statreg = AM53C974_read_8(STATREG); for (i = 0; (phases[i].value != PHASE_RES_1) && (phases[i].value != (statreg & STATREG_PHASE)); ++i); if (latched) printk("scsi%d : phase %s, latched at end of last command\n", instance->host_no, phases[i].name); else printk("scsi%d : phase %s, real time\n", instance->host_no, phases[i].name); } /************************************************************************** * Function : void AM53C974_print_queues(struct Scsi_Host *instance) * * Purpose : print commands in the various queues * * Inputs : instance - which AM53C974 **************************************************************************/ static void AM53C974_print_queues(struct Scsi_Host *instance) { struct AM53C974_hostdata *hostdata = (struct AM53C974_hostdata *)instance->hostdata; Scsi_Cmnd *ptr; printk("AM53C974: coroutine is%s running.\n", main_running ? "" : "n't"); cli(); if (!hostdata->connected) { printk ("scsi%d: no currently connected command\n", instance->host_no); } else { print_Scsi_Cmnd ((Scsi_Cmnd *)hostdata->connected); } if (!hostdata->sel_cmd) { printk ("scsi%d: no currently arbitrating command\n", instance->host_no); } else { print_Scsi_Cmnd ((Scsi_Cmnd *)hostdata->sel_cmd); } printk ("scsi%d: issue_queue ", instance->host_no); if (!hostdata->issue_queue) printk("empty\n"); else { printk(":\n"); for (ptr = (Scsi_Cmnd *)hostdata->issue_queue; ptr; ptr = (Scsi_Cmnd *)ptr->host_scribble) print_Scsi_Cmnd (ptr); } printk ("scsi%d: disconnected_queue ", instance->host_no); if (!hostdata->disconnected_queue) printk("empty\n"); else { printk(":\n"); for (ptr = (Scsi_Cmnd *) hostdata->disconnected_queue; ptr; ptr = (Scsi_Cmnd *)ptr->host_scribble) print_Scsi_Cmnd (ptr); } sti(); } #endif /* AM53C974_DEBUG */ /************************************************************************** * Function : void AM53C974_print(struct Scsi_Host *instance) * * Purpose : dump the chip registers for debugging purposes * * Input : instance - which AM53C974 **************************************************************************/ static void AM53C974_print(struct Scsi_Host *instance) { AM53C974_local_declare(); unsigned long ctcreg, dmastc, dmaspa, dmawbc, dmawac; unsigned char cmdreg, statreg, isreg, cfireg, cntlreg[4], dmacmd, dmastatus; AM53C974_setio(instance); cli(); ctcreg = AM53C974_read_8(CTCHREG) << 16; ctcreg |= AM53C974_read_8(CTCMREG) << 8; ctcreg |= AM53C974_read_8(CTCLREG); cmdreg = AM53C974_read_8(CMDREG); statreg = AM53C974_read_8(STATREG); isreg = AM53C974_read_8(ISREG); cfireg = AM53C974_read_8(CFIREG); cntlreg[0] = AM53C974_read_8(CNTLREG1); cntlreg[1] = AM53C974_read_8(CNTLREG2); cntlreg[2] = AM53C974_read_8(CNTLREG3); cntlreg[3] = AM53C974_read_8(CNTLREG4); dmacmd = AM53C974_read_8(DMACMD); dmastc = AM53C974_read_32(DMASTC); dmaspa = AM53C974_read_32(DMASPA); dmawbc = AM53C974_read_32(DMAWBC); dmawac = AM53C974_read_32(DMAWAC); dmastatus = AM53C974_read_8(DMASTATUS); sti(); printk("AM53C974 register dump:\n"); printk("IO base: 0x%04lx; CTCREG: 0x%04lx; CMDREG: 0x%02x; STATREG: 0x%02x; ISREG: 0x%02x\n", io_port, ctcreg, cmdreg, statreg, isreg); printk("CFIREG: 0x%02x; CNTLREG1-4: 0x%02x; 0x%02x; 0x%02x; 0x%02x\n", cfireg, cntlreg[0], cntlreg[1], cntlreg[2], cntlreg[3]); printk("DMACMD: 0x%02x; DMASTC: 0x%04lx; DMASPA: 0x%04lx\n", dmacmd, dmastc, dmaspa); printk("DMAWBC: 0x%04lx; DMAWAC: 0x%04lx; DMASTATUS: 0x%02x\n", dmawbc, dmawac, dmastatus); printk("---------------------------------------------------------\n"); } /************************************************************************** * Function : void AM53C974_keywait(void) * * Purpose : wait until a key is pressed, if it was the 'r' key leave singlestep mode; * this function is used for debugging only * * Input : none **************************************************************************/ static void AM53C974_keywait(void) { #ifdef AM53C974_DEBUG int key; if (!deb_stop) return; #endif cli(); while ((inb_p(0x64) & 0x01) != 0x01) ; #ifdef AM53C974_DEBUG key = inb(0x60); if (key == 0x93) deb_stop = 0; /* don't stop if 'r' was pressed */ #endif sti(); } /************************************************************************** * Function : AM53C974_setup(char *str, int *ints) * * Purpose : LILO command line initialization of the overrides array, * * Inputs : str - unused, ints - array of integer parameters with ints[0] * equal to the number of ints. * * NOTE : this function needs to be declared as an external function * in init/main.c and included there in the bootsetups list ***************************************************************************/ void AM53C974_setup(char *str, int *ints) { if (ints[0] < 4) printk("AM53C974_setup: wrong number of parameters;\n correct syntax is: AM53C974=host-scsi-id, target-scsi-id, max-rate, max-offset\n"); else { if (commandline_current < (sizeof(overrides) / sizeof(override_t))) { if ((ints[1] < 0) || (ints[1] > 7) || (ints[2] < 0) || (ints[2] > 7) || (ints[1] == ints[2]) || (ints[3] < (DEF_CLK / MAX_PERIOD)) || (ints[3] > (DEF_CLK / MIN_PERIOD)) || (ints[4] < 0) || (ints[4] > MAX_OFFSET)) printk("AM53C974_setup: illegal parameter\n"); else { overrides[commandline_current].host_scsi_id = ints[1]; overrides[commandline_current].target_scsi_id = ints[2]; overrides[commandline_current].max_rate = ints[3]; overrides[commandline_current].max_offset = ints[4]; commandline_current++; } } else printk("AM53C974_setup: too many overrides\n"); } } #if defined (CONFIG_PCI) /************************************************************************** * Function : int AM53C974_bios_detect(Scsi_Host_Template *tpnt) * * Purpose : detects and initializes AM53C974 SCSI chips with PCI Bios * * Inputs : tpnt - host template * * Returns : number of host adapters detected **************************************************************************/ int AM53C974_bios_detect(Scsi_Host_Template *tpnt) { int count = 0; /* number of boards detected */ int pci_index; pci_config_t pci_config; for (pci_index = 0; pci_index <= 16; ++pci_index) { unsigned char pci_bus, pci_device_fn; if (pcibios_find_device(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_SCSI, pci_index, &pci_bus, &pci_device_fn) != 0) break; pcibios_read_config_word(pci_bus, pci_device_fn, PCI_VENDOR_ID, &pci_config._vendor); pcibios_read_config_word(pci_bus, pci_device_fn, PCI_DEVICE_ID, &pci_config._device); pcibios_read_config_word(pci_bus, pci_device_fn, PCI_COMMAND, &pci_config._command); pcibios_read_config_word(pci_bus, pci_device_fn, PCI_STATUS, &pci_config._status); pcibios_read_config_dword(pci_bus, pci_device_fn, PCI_CLASS_REVISION, &pci_config._class_revision); pcibios_read_config_byte(pci_bus, pci_device_fn, PCI_CACHE_LINE_SIZE, &pci_config._cache_line_size); pcibios_read_config_byte(pci_bus, pci_device_fn, PCI_LATENCY_TIMER, &pci_config._latency_timer); pcibios_read_config_byte(pci_bus, pci_device_fn, PCI_HEADER_TYPE, &pci_config._header_type); pcibios_read_config_byte(pci_bus, pci_device_fn, PCI_BIST, &pci_config._bist); pcibios_read_config_dword(pci_bus, pci_device_fn, PCI_BASE_ADDRESS_0, &pci_config._base0); pcibios_read_config_dword(pci_bus, pci_device_fn, PCI_BASE_ADDRESS_1, &pci_config._base1); pcibios_read_config_dword(pci_bus, pci_device_fn, PCI_BASE_ADDRESS_2, &pci_config._base2); pcibios_read_config_dword(pci_bus, pci_device_fn, PCI_BASE_ADDRESS_3, &pci_config._base3); pcibios_read_config_dword(pci_bus, pci_device_fn, PCI_BASE_ADDRESS_4, &pci_config._base4); pcibios_read_config_dword(pci_bus, pci_device_fn, PCI_BASE_ADDRESS_5, &pci_config._base5); pcibios_read_config_dword(pci_bus, pci_device_fn, PCI_ROM_ADDRESS, &pci_config._baserom); pcibios_read_config_byte(pci_bus, pci_device_fn, PCI_INTERRUPT_LINE, &pci_config._int_line); pcibios_read_config_byte(pci_bus, pci_device_fn, PCI_INTERRUPT_PIN, &pci_config._int_pin); pcibios_read_config_byte(pci_bus, pci_device_fn, PCI_MIN_GNT, &pci_config._min_gnt); pcibios_read_config_byte(pci_bus, pci_device_fn, PCI_MAX_LAT, &pci_config._max_lat); pci_config._pcibus = 0xFFFFFFFF; pci_config._cardnum = 0xFFFFFFFF; /* check whether device is I/O mapped -- should be */ if (!(pci_config._command & PCI_COMMAND_IO)) continue; /* PCI Spec 2.1 states that it is either the driver's or the PCI card's responsibility to set the PCI Master Enable Bit if needed. (from Mark Stockton <marks@schooner.sys.hou.compaq.com>) */ if (!(pci_config._command & PCI_COMMAND_MASTER)) { pci_config._command |= PCI_COMMAND_MASTER; printk("PCI Master Bit has not been set. Setting...\n"); pcibios_write_config_word(pci_bus, pci_device_fn, PCI_COMMAND, pci_config._command); } /* everything seems OK now, so initialize */ if (AM53C974_init(tpnt, pci_config)) count++ ; } return (count); } #endif /************************************************************************** * Function : int AM53C974_nobios_detect(Scsi_Host_Template *tpnt) * * Purpose : detects and initializes AM53C974 SCSI chips using PCI config 2 * * Inputs : tpnt - host template * * Returns : number of host adapters detected * * NOTE : This code assumes the controller on PCI bus 0. * * Origin: Robin Cutshaw (robin@xfree86.org) **************************************************************************/ int AM53C974_nobios_detect(Scsi_Host_Template *tpnt) { int count = 0; /* number of boards detected */ pci_config_t pci_config; /* first try PCI config method 1 */ for (pci_config._pcibus = 0; pci_config._pcibus < 0x10; pci_config._pcibus++) { for (pci_config._cardnum = 0; pci_config._cardnum < 0x20; pci_config._cardnum++) { unsigned long config_cmd; config_cmd = 0x80000000 | (pci_config._pcibus<<16) | (pci_config._cardnum<<11); outl(config_cmd, 0xCF8); /* ioreg 0 */ pci_config._device_vendor = inl(0xCFC); if ((pci_config._vendor == PCI_VENDOR_ID_AMD) && (pci_config._device == PCI_DEVICE_ID_AMD_SCSI)) { outl(config_cmd | PCI_COMMAND, 0xCF8); pci_config._status_command = inl(0xCFC); outl(config_cmd | PCI_CLASS_REVISION, 0xCF8); pci_config._class_revision = inl(0xCFC); outl(config_cmd | PCI_CACHE_LINE_SIZE, 0xCF8); pci_config._bist_header_latency_cache = inl(0xCFC); outl(config_cmd | PCI_BASE_ADDRESS_0, 0xCF8); pci_config._base0 = inl(0xCFC); outl(config_cmd | PCI_BASE_ADDRESS_1, 0xCF8); pci_config._base1 = inl(0xCFC); outl(config_cmd | PCI_BASE_ADDRESS_2, 0xCF8); pci_config._base2 = inl(0xCFC); outl(config_cmd | PCI_BASE_ADDRESS_3, 0xCF8); pci_config._base3 = inl(0xCFC); outl(config_cmd | PCI_BASE_ADDRESS_4, 0xCF8); pci_config._base4 = inl(0xCFC); outl(config_cmd | PCI_BASE_ADDRESS_5, 0xCF8); pci_config._base5 = inl(0xCFC); outl(config_cmd | PCI_ROM_ADDRESS, 0xCF8); pci_config._baserom = inl(0xCFC); outl(config_cmd | PCI_INTERRUPT_LINE, 0xCF8); pci_config._max_min_ipin_iline = inl(0xCFC); /* check whether device is I/O mapped -- should be */ if (!(pci_config._command & PCI_COMMAND_IO)) continue; /* PCI Spec 2.1 states that it is either the driver's or the PCI card's responsibility to set the PCI Master Enable Bit if needed. From Mark Stockton <marks@schooner.sys.hou.compaq.com> */ if (!(pci_config._command & PCI_COMMAND_MASTER)) { pci_config._command |= PCI_COMMAND_MASTER; printk("Config 1; PCI Master Bit has not been set. Setting...\n"); outl(config_cmd | PCI_COMMAND, 0xCF8); outw(pci_config._command, 0xCFC); } /* everything seems OK now, so initialize */ if (AM53C974_init(tpnt, pci_config)) count++ ; } } } outb(0, 0xCF8); /* is this really necessary? */ /* try PCI config method 2, if no device was detected by method 1 */ if (!count) { AM53C974_PCIREG_OPEN(); pci_config._pcibus = 0xFFFFFFFF; pci_config._cardnum = 0xFFFFFFFF; for (pci_config._ioaddr = 0xC000; pci_config._ioaddr < 0xD000; pci_config._ioaddr += 0x0100) { pci_config._device_vendor = inl(pci_config._ioaddr); if ((pci_config._vendor == PCI_VENDOR_ID_AMD) && (pci_config._device == PCI_DEVICE_ID_AMD_SCSI)) { pci_config._status_command = inl(pci_config._ioaddr + PCI_COMMAND); pci_config._class_revision = inl(pci_config._ioaddr + PCI_CLASS_REVISION); pci_config._bist_header_latency_cache = inl(pci_config._ioaddr + PCI_CACHE_LINE_SIZE); pci_config._base0 = inl(pci_config._ioaddr + PCI_BASE_ADDRESS_0); pci_config._base1 = inl(pci_config._ioaddr + PCI_BASE_ADDRESS_1); pci_config._base2 = inl(pci_config._ioaddr + PCI_BASE_ADDRESS_2); pci_config._base3 = inl(pci_config._ioaddr + PCI_BASE_ADDRESS_3); pci_config._base4 = inl(pci_config._ioaddr + PCI_BASE_ADDRESS_4); pci_config._base5 = inl(pci_config._ioaddr + PCI_BASE_ADDRESS_5); pci_config._baserom = inl(pci_config._ioaddr + PCI_ROM_ADDRESS); pci_config._max_min_ipin_iline = inl(pci_config._ioaddr + PCI_INTERRUPT_LINE); /* check whether device is I/O mapped -- should be */ if (!(pci_config._command & PCI_COMMAND_IO)) continue; /* PCI Spec 2.1 states that it is either the driver's or the PCI card's responsibility to set the PCI Master Enable Bit if needed. From Mark Stockton <marks@schooner.sys.hou.compaq.com> */ if (!(pci_config._command & PCI_COMMAND_MASTER)) { pci_config._command |= PCI_COMMAND_MASTER; printk("Config 2; PCI Master Bit has not been set. Setting...\n"); outw(pci_config._command, pci_config._ioaddr + PCI_COMMAND); } /* everything seems OK now, so initialize */ if (AM53C974_init(tpnt, pci_config)) count++ ; } } AM53C974_PCIREG_CLOSE(); } return(count); } /************************************************************************** * Function : int AM53C974_detect(Scsi_Host_Template *tpnt) * * Purpose : detects and initializes AM53C974 SCSI chips * * Inputs : tpnt - host template * * Returns : number of host adapters detected **************************************************************************/ int AM53C974_detect(Scsi_Host_Template *tpnt) { int count; /* number of boards detected */ tpnt->proc_dir = &proc_scsi_am53c974; #if defined (CONFIG_PCI) if (pcibios_present()) count = AM53C974_bios_detect(tpnt); else #endif count = AM53C974_nobios_detect(tpnt); return (count); } /************************************************************************** * Function : int AM53C974_init(Scsi_Host_Template *tpnt, pci_config_t pci_config) * * Purpose : initializes instance and corresponding AM53/79C974 chip, * * Inputs : tpnt - template, pci_config - PCI configuration, * * Returns : 1 on success, 0 on failure. * * NOTE: If no override for the controller's SCSI id is given and AM53C974_SCSI_ID * is not defined we assume that the SCSI address of this controller is correctly * set up by the BIOS (as reflected by contents of register CNTLREG1). * This is the only BIOS assistance we need. **************************************************************************/ static int AM53C974_init(Scsi_Host_Template *tpnt, pci_config_t pci_config) { AM53C974_local_declare(); int i, j; struct Scsi_Host *instance, *search; struct AM53C974_hostdata *hostdata; #ifdef AM53C974_OPTION_DEBUG_PROBE_ONLY printk ("AM53C974: probe only enabled, aborting initialization\n"); return 0; #endif instance = scsi_register(tpnt, sizeof(struct AM53C974_hostdata)); hostdata = (struct AM53C974_hostdata *)instance->hostdata; instance->base = NULL; instance->io_port = pci_config._base0 & (pci_config._base0 & 0x1 ? 0xFFFFFFFC : 0xFFFFFFF0); instance->irq = pci_config._int_line; instance->dma_channel = -1; AM53C974_setio(instance); #ifdef AM53C974_SCSI_ID instance->this_id = AM53C974_SCSI_ID; AM53C974_write_8(CNTLREG1, instance->this_id & CNTLREG1_SID); #else instance->this_id = AM53C974_read_8(CNTLREG1) & CNTLREG1_SID; if (instance->this_id != 7) printk("scsi%d: WARNING: unusual hostadapter SCSI id %d; please verify!\n", instance->host_no, instance->this_id); #endif for (i = 0; i < sizeof(hostdata->msgout); i++) { hostdata->msgout[i] = NOP; hostdata->last_message[i] = NOP; } for (i = 0; i < 8; i++) { hostdata->busy[i] = 0; hostdata->sync_per[i] = DEF_STP; hostdata->sync_off[i] = 0; hostdata->sync_neg[i] = 0; hostdata->sync_en[i] = DEFAULT_SYNC_NEGOTIATION_ENABLED; hostdata->max_rate[i] = DEFAULT_RATE; hostdata->max_offset[i] = DEFAULT_SYNC_OFFSET; } /* overwrite defaults by LILO overrides */ for (i = 0; i < commandline_current; i++) { if (overrides[i].host_scsi_id == instance->this_id) { j = overrides[i].target_scsi_id; hostdata->sync_en[j] = 1; hostdata->max_rate[j] = overrides[i].max_rate; hostdata->max_offset[j] = overrides[i].max_offset; } } hostdata->sel_cmd = NULL; hostdata->connected = NULL; hostdata->issue_queue = NULL; hostdata->disconnected_queue = NULL; hostdata->in_reset = 0; hostdata->aborted = 0; hostdata->selecting = 0; hostdata->disconnecting = 0; hostdata->dma_busy = 0; /* Set up an interrupt handler if we aren't already sharing an IRQ with another board */ for (search = first_host; search && ( ((the_template != NULL) && (search->hostt != the_template)) || (search->irq != instance->irq) || (search == instance) ); search = search->next); if (!search) { if (request_irq(instance->irq, AM53C974_intr, SA_INTERRUPT, "AM53C974", NULL)) { printk("scsi%d: IRQ%d not free, detaching\n", instance->host_no, instance->irq); scsi_unregister(instance); return 0; } } else { printk("scsi%d: using interrupt handler previously installed for scsi%d\n", instance->host_no, search->host_no); } if (!the_template) { the_template = instance->hostt; first_instance = instance; } /* do hard reset */ AM53C974_write_8(CMDREG, CMDREG_RDEV); /* reset device */ udelay(5); AM53C974_write_8(CMDREG, CMDREG_NOP); AM53C974_write_8(CNTLREG1, CNTLREG1_DISR | instance->this_id); AM53C974_write_8(CMDREG, CMDREG_RBUS); /* reset SCSI bus */ udelay(10); AM53C974_config_after_reset(instance); udelay(500000); return(1); } /********************************************************************* * Function : AM53C974_config_after_reset(struct Scsi_Host *instance) * * * * Purpose : initializes chip registers after reset * * * * Inputs : instance - which AM53C974 * * * * Returns : nothing * **********************************************************************/ static void AM53C974_config_after_reset(struct Scsi_Host *instance) { AM53C974_local_declare(); AM53C974_setio(instance); /* clear SCSI FIFO */ AM53C974_write_8(CMDREG, CMDREG_CFIFO); /* configure device */ AM53C974_write_8(STIMREG, DEF_SCSI_TIMEOUT); AM53C974_write_8(STPREG, DEF_STP & STPREG_STP); AM53C974_write_8(SOFREG, (DEF_SOF_RAD<<6) | (DEF_SOF_RAA<<4)); AM53C974_write_8(CLKFREG, DEF_CLKF & CLKFREG_MASK); AM53C974_write_8(CNTLREG1, (DEF_ETM<<7) | CNTLREG1_DISR | (DEF_PERE<<4) | instance->this_id); AM53C974_write_8(CNTLREG2, (DEF_ENF<<6)); AM53C974_write_8(CNTLREG3, (DEF_ADIDCHK<<7) | (DEF_FASTSCSI<<4) | (DEF_FASTCLK<<3)); AM53C974_write_8(CNTLREG4, (DEF_GLITCH<<6) | (DEF_PWD<<5) | (DEF_RAE<<3) | (DEF_RADE<<2) | CNTLREG4_RES); } /*********************************************************************** * Function : const char *AM53C974_info(struct Scsi_Host *instance) * * * * Purpose : return device driver information * * * * Inputs : instance - which AM53C974 * * * * Returns : info string * ************************************************************************/ const char *AM53C974_info(struct Scsi_Host *instance) { static char info[100]; sprintf(info, "AM53/79C974 PCscsi driver rev. %d.%d; host I/O address: 0x%x; irq: %d\n", AM53C974_DRIVER_REVISION_MAJOR, AM53C974_DRIVER_REVISION_MINOR, instance->io_port, instance->irq); return (info); } /************************************************************************** * Function : int AM53C974_command (Scsi_Cmnd *SCpnt) * * * * Purpose : the unqueued SCSI command function, replaced by the * * AM53C974_queue_command function * * * * Inputs : SCpnt - pointer to command structure * * * * Returns :status, see hosts.h for details * ***************************************************************************/ int AM53C974_command(Scsi_Cmnd *SCpnt) { DEB(printk("AM53C974_command called\n")); return 0; } /************************************************************************** * Function : void initialize_SCp(Scsi_Cmnd *cmd) * * * * Purpose : initialize the saved data pointers for cmd to point to the * * start of the buffer. * * * * Inputs : cmd - Scsi_Cmnd structure to have pointers reset. * * * * Returns : nothing * **************************************************************************/ static __inline__ void initialize_SCp(Scsi_Cmnd *cmd) { if (cmd->use_sg) { cmd->SCp.buffer = (struct scatterlist *)cmd->buffer; cmd->SCp.buffers_residual = cmd->use_sg - 1; cmd->SCp.ptr = (char *)cmd->SCp.buffer->address; cmd->SCp.this_residual = cmd->SCp.buffer->length; } else { cmd->SCp.buffer = NULL; cmd->SCp.buffers_residual = 0; cmd->SCp.ptr = (char *)cmd->request_buffer; cmd->SCp.this_residual = cmd->request_bufflen; } } /************************************************************************** * Function : run_main(void) * * * * Purpose : insure that the coroutine is running and will process our * * request. main_running is checked/set here (in an inline * * function rather than in AM53C974_main itself to reduce the * * chances of stack overflow. * * * * * * Inputs : none * * * * Returns : nothing * **************************************************************************/ static __inline__ void run_main(void) { cli(); if (!main_running) { /* main_running is cleared in AM53C974_main once it can't do more work, and AM53C974_main exits with interrupts disabled. */ main_running = 1; AM53C974_main(); sti(); } else sti(); } /************************************************************************** * Function : int AM53C974_queue_command(Scsi_Cmnd *cmd, void (*done)(Scsi_Cmnd *)) * * Purpose : writes SCSI command into AM53C974 FIFO * * Inputs : cmd - SCSI command, done - function called on completion, with * a pointer to the command descriptor. * * Returns : status, see hosts.h for details * * Side effects : * cmd is added to the per instance issue_queue, with minor * twiddling done to the host specific fields of cmd. If the * main coroutine is not running, it is restarted. **************************************************************************/ int AM53C974_queue_command(Scsi_Cmnd *cmd, void (*done)(Scsi_Cmnd *)) { struct Scsi_Host *instance = cmd->host; struct AM53C974_hostdata *hostdata = (struct AM53C974_hostdata *)instance->hostdata; Scsi_Cmnd *tmp; cli(); DEB_QUEUE(printk(SEPARATOR_LINE)); DEB_QUEUE(printk("scsi%d: AM53C974_queue_command called\n", instance->host_no)); DEB_QUEUE(printk("cmd=%02x target=%02x lun=%02x bufflen=%d use_sg = %02x\n", cmd->cmnd[0], cmd->target, cmd->lun, cmd->request_bufflen, cmd->use_sg)); /* We use the host_scribble field as a pointer to the next command in a queue */ cmd->host_scribble = NULL; cmd->scsi_done = done; cmd->result = 0; cmd->device->disconnect = 0; /* Insert the cmd into the issue queue. Note that REQUEST SENSE * commands are added to the head of the queue since any command will * clear the contingent allegiance condition that exists and the * sense data is only guaranteed to be valid while the condition exists. */ if (!(hostdata->issue_queue) || (cmd->cmnd[0] == REQUEST_SENSE)) { LIST(cmd, hostdata->issue_queue); cmd->host_scribble = (unsigned char *)hostdata->issue_queue; hostdata->issue_queue = cmd; } else { for (tmp = (Scsi_Cmnd *)hostdata->issue_queue; tmp->host_scribble; tmp = (Scsi_Cmnd *)tmp->host_scribble); LIST(cmd, tmp); tmp->host_scribble = (unsigned char *)cmd; } DEB_QUEUE(printk("scsi%d : command added to %s of queue\n", instance->host_no, (cmd->cmnd[0] == REQUEST_SENSE) ? "head" : "tail")); /* Run the coroutine if it isn't already running. */ run_main(); return 0; } /************************************************************************** * Function : AM53C974_main (void) * * Purpose : AM53C974_main is a coroutine that runs as long as more work can * be done on the AM53C974 host adapters in a system. Both * AM53C974_queue_command() and AM53C974_intr() will try to start it * in case it is not running. * * NOTE : AM53C974_main exits with interrupts *disabled*, the caller should * reenable them. This prevents reentrancy and kernel stack overflow. **************************************************************************/ static void AM53C974_main(void) { AM53C974_local_declare(); Scsi_Cmnd *tmp, *prev; struct Scsi_Host *instance; struct AM53C974_hostdata *hostdata; int done; /* We run (with interrupts disabled) until we're sure that none of * the host adapters have anything that can be done, at which point * we set main_running to 0 and exit. */ do { cli(); /* Freeze request queues */ done = 1; for (instance = first_instance; instance && instance->hostt == the_template; instance = instance->next) { hostdata = (struct AM53C974_hostdata *)instance->hostdata; AM53C974_setio(instance); /* start to select target if we are not connected and not in the selection process */ if (!hostdata->connected && !hostdata->sel_cmd) { /* Search through the issue_queue for a command destined for a target that is not busy. */ for (tmp = (Scsi_Cmnd *)hostdata->issue_queue, prev = NULL; tmp; prev = tmp, tmp = (Scsi_Cmnd *)tmp->host_scribble) { /* When we find one, remove it from the issue queue. */ if (!(hostdata->busy[tmp->target] & (1 << tmp->lun))) { if (prev) { REMOVE(prev, (Scsi_Cmnd *)(prev->host_scribble), tmp, (Scsi_Cmnd *)(tmp->host_scribble)); prev->host_scribble = tmp->host_scribble; } else { REMOVE(-1, hostdata->issue_queue, tmp, tmp->host_scribble); hostdata->issue_queue = (Scsi_Cmnd *)tmp->host_scribble; } tmp->host_scribble = NULL; /* go into selection mode, disable reselection and wait for SO interrupt which will continue with the selection process */ hostdata->selecting = 1; hostdata->sel_cmd = tmp; AM53C974_write_8(CMDREG, CMDREG_DSR); break; } /* if target/lun is not busy */ } /* for */ } /* if (!hostdata->connected) */ else { DEB(printk("main: connected; cmd = 0x%lx, sel_cmd = 0x%lx\n", (long)hostdata->connected, (long)hostdata->sel_cmd)); } } /* for instance */ } while (!done); main_running = 0; } /************************************************************************ * Function : AM53C974_intr(int irq, void *dev_id, struct pt_regs *regs) * * * * Purpose : interrupt handler * * * * Inputs : irq - interrupt line, regs - ? * * * * Returns : nothing * ************************************************************************/ static void AM53C974_intr(int irq, void *dev_id, struct pt_regs *regs) { AM53C974_local_declare(); struct Scsi_Host *instance; struct AM53C974_hostdata *hostdata; unsigned char cmdreg, dmastatus, statreg, isreg, instreg, cfifo; /* find AM53C974 hostadapter responsible for this interrupt */ for (instance = first_instance; instance; instance = instance->next) if ((instance->irq == irq) && (instance->hostt == the_template)) goto FOUND; sti(); return; /* found; now decode and process */ FOUND: hostdata = (struct AM53C974_hostdata *)instance->hostdata; AM53C974_setio(instance); dmastatus = AM53C974_read_8(DMASTATUS); DEB_INTR(printk(SEPARATOR_LINE)); DEB_INTR(printk("AM53C974 interrupt; dmastatus=0x%02x\n", dmastatus)); KEYWAIT(); /*** DMA related interrupts ***/ if (hostdata->connected && (dmastatus & (DMASTATUS_ERROR | DMASTATUS_PWDN | DMASTATUS_ABORT))) { /* DMA error or POWERDOWN */ printk("scsi%d: DMA error or powerdown; dmastatus: 0x%02x\n", instance->host_no, dmastatus); #ifdef AM53C974_DEBUG deb_stop = 1; #endif panic("scsi%d: cannot recover\n", instance->host_no); } if (hostdata->connected && (dmastatus & DMASTATUS_DONE)) { /* DMA transfer done */ unsigned long residual; cli(); if (!(AM53C974_read_8(DMACMD) & DMACMD_DIR)) { do { dmastatus = AM53C974_read_8(DMASTATUS); residual = AM53C974_read_8(CTCLREG) | (AM53C974_read_8(CTCMREG) << 8) | (AM53C974_read_8(CTCHREG) << 16); residual += AM53C974_read_8(CFIREG) & CFIREG_CF; } while (!(dmastatus & DMASTATUS_SCSIINT) && residual); residual = AM53C974_read_8(CTCLREG) | (AM53C974_read_8(CTCMREG) << 8) | (AM53C974_read_8(CTCHREG) << 16); residual += AM53C974_read_8(CFIREG) & CFIREG_CF; } else residual = 0; hostdata->connected->SCp.ptr += hostdata->connected->SCp.this_residual - residual; hostdata->connected->SCp.this_residual = residual; AM53C974_write_8(DMACMD, DMACMD_IDLE); /* if service request missed before, process it now (ugly) */ if (hostdata->dma_busy) { hostdata->dma_busy = 0; cmdreg = AM53C974_read_8(CMDREG); statreg = AM53C974_read_8(STATREG); isreg = AM53C974_read_8(ISREG); instreg = AM53C974_read_8(INSTREG); cfifo = AM53C974_cfifo(); AM53C974_information_transfer(instance, statreg, isreg, instreg, cfifo, dmastatus); } sti(); } if (!(dmastatus & DMASTATUS_SCSIINT)) { sti(); return; } /*** SCSI related interrupts ***/ cmdreg = AM53C974_read_8(CMDREG); statreg = AM53C974_read_8(STATREG); isreg = AM53C974_read_8(ISREG); instreg = AM53C974_read_8(INSTREG); cfifo = AM53C974_cfifo(); DEB_INTR(printk("scsi%d: statreg: 0x%02x; isreg: 0x%02x; instreg: 0x%02x; cfifo: 0x%02x\n", instance->host_no, statreg, isreg, instreg, cfifo)); if (statreg & STATREG_PE) { /* parity error */ #ifdef AM53C974_DEBUG deb_stop = 1; #endif printk("scsi%d : PARITY error\n", instance->host_no); if (hostdata->connected) hostdata->sync_off[hostdata->connected->target] = 0; /* setup asynchronous transfer */ hostdata->aborted = 1; } if (statreg & STATREG_IOE) { /* illegal operation error */ #ifdef AM53C974_DEBUG deb_stop = 1; #endif printk("scsi%d : ILLEGAL OPERATION error\n", instance->host_no); printk("cmdreg: 0x%02x; dmacmd: 0x%02x; statreg: 0x%02x; \n" "isreg: 0x%02x; instreg: 0x%02x; cfifo: 0x%02x\n", cmdreg, AM53C974_read_8(DMACMD), statreg, isreg, instreg, cfifo); } if (hostdata->in_reset && (instreg & INSTREG_SRST)) { /* RESET INTERRUPT */ #ifdef AM53C974_DEBUG deb_stop = 1; #endif DEB(printk("Bus reset interrupt received\n")); AM53C974_intr_bus_reset(instance); cli(); if (hostdata->connected) { hostdata->connected->result = DID_RESET << 16; hostdata->connected->scsi_done((Scsi_Cmnd *)hostdata->connected); hostdata->connected = NULL; } else { if (hostdata->sel_cmd) { hostdata->sel_cmd->result = DID_RESET << 16; hostdata->sel_cmd->scsi_done((Scsi_Cmnd *)hostdata->sel_cmd); hostdata->sel_cmd = NULL; } } sti(); if (hostdata->in_reset == 1) goto EXIT; else return; } if (instreg & INSTREG_ICMD) { /* INVALID COMMAND INTERRUPT */ #ifdef AM53C974_DEBUG deb_stop = 1; #endif printk("scsi%d: Invalid command interrupt\n", instance->host_no); printk("cmdreg: 0x%02x; dmacmd: 0x%02x; statreg: 0x%02x; dmastatus: 0x%02x; \n" "isreg: 0x%02x; instreg: 0x%02x; cfifo: 0x%02x\n", cmdreg, AM53C974_read_8(DMACMD), statreg, dmastatus, isreg, instreg, cfifo); panic("scsi%d: cannot recover\n", instance->host_no); } if (instreg & INSTREG_DIS) { /* DISCONNECT INTERRUPT */ DEB_INTR(printk("Disconnect interrupt received; ")); cli(); AM53C974_intr_disconnect(instance); sti(); goto EXIT; } if (instreg & INSTREG_RESEL) { /* RESELECTION INTERRUPT */ DEB_INTR(printk("Reselection interrupt received\n")); cli(); AM53C974_intr_reselect(instance, statreg); sti(); goto EXIT; } if (instreg & INSTREG_SO) { DEB_INTR(printk("Successful operation interrupt received\n")); if (hostdata->selecting) { DEB_INTR(printk("DSR completed, starting select\n")); cli(); AM53C974_select(instance, (Scsi_Cmnd *)hostdata->sel_cmd, (hostdata->sel_cmd->cmnd[0] == REQUEST_SENSE) ? TAG_NONE : TAG_NEXT); hostdata->selecting = 0; AM53C974_set_sync(instance, hostdata->sel_cmd->target); sti(); return; } if (hostdata->sel_cmd != NULL) { if ( ((isreg & ISREG_IS) != ISREG_OK_NO_STOP) && ((isreg & ISREG_IS) != ISREG_OK_STOP) ) { /* UNSUCCESSFUL SELECTION */ DEB_INTR(printk("unsuccessful selection\n")); cli(); hostdata->dma_busy = 0; LIST(hostdata->sel_cmd, hostdata->issue_queue); hostdata->sel_cmd->host_scribble = (unsigned char *)hostdata->issue_queue; hostdata->issue_queue = hostdata->sel_cmd; hostdata->sel_cmd = NULL; hostdata->selecting = 0; sti(); goto EXIT; } else { /* SUCCESSFUL SELECTION */ DEB(printk("successful selection; cmd=0x%02lx\n", (long)hostdata->sel_cmd)); cli(); hostdata->dma_busy = 0; hostdata->disconnecting = 0; hostdata->connected = hostdata->sel_cmd; hostdata->sel_cmd = NULL; hostdata->selecting = 0; #ifdef SCSI2 if (!hostdata->connected->device->tagged_queue) #endif hostdata->busy[hostdata->connected->target] |= (1 << hostdata->connected->lun); /* very strange -- use_sg is sometimes nonzero for request sense commands !! */ if ((hostdata->connected->cmnd[0] == REQUEST_SENSE) && hostdata->connected->use_sg) { DEB(printk("scsi%d: REQUEST_SENSE command with nonzero use_sg\n", instance->host_no)); KEYWAIT(); hostdata->connected->use_sg = 0; } initialize_SCp((Scsi_Cmnd *)hostdata->connected); hostdata->connected->SCp.phase = PHASE_CMDOUT; AM53C974_information_transfer(instance, statreg, isreg, instreg, cfifo, dmastatus); sti(); return; } } else { cli(); AM53C974_information_transfer(instance, statreg, isreg, instreg, cfifo, dmastatus); sti(); return; } } if (instreg & INSTREG_SR) { DEB_INTR(printk("Service request interrupt received, ")); if (hostdata->connected) { DEB_INTR(printk("calling information_transfer\n")); cli(); AM53C974_information_transfer(instance, statreg, isreg, instreg, cfifo, dmastatus); sti(); } else { printk("scsi%d: weird: service request when no command connected\n", instance->host_no); AM53C974_write_8(CMDREG, CMDREG_CFIFO); } /* clear FIFO */ return; } EXIT: DEB_INTR(printk("intr: starting main\n")); run_main(); DEB_INTR(printk("end of intr\n")); } /************************************************************************** * Function : AM53C974_intr_disconnect(struct Scsi_Host *instance) * * Purpose : manage target disconnection * * Inputs : instance -- which AM53C974 * * Returns : nothing **************************************************************************/ static void AM53C974_intr_disconnect(struct Scsi_Host *instance) { AM53C974_local_declare(); struct AM53C974_hostdata *hostdata = (struct AM53C974_hostdata *)instance->hostdata; Scsi_Cmnd *cmd; AM53C974_setio(instance); if (hostdata->sel_cmd != NULL) { /* normal selection timeout, typical for nonexisting targets */ cmd = (Scsi_Cmnd *)hostdata->sel_cmd; DEB_INTR(printk("bad target\n")); cmd->result = DID_BAD_TARGET << 16; goto EXIT_FINISHED; } if (!hostdata->connected) { /* can happen if controller was reset, a device tried to reconnect, failed and disconnects now */ AM53C974_write_8(CMDREG, CMDREG_CFIFO); return; } if (hostdata->disconnecting) { /* target sent disconnect message, so we are prepared */ cmd = (Scsi_Cmnd *)hostdata->connected; AM53C974_set_async(instance, cmd->target); DEB_INTR(printk("scsi%d : disc. from cmnd %d for ta %d, lun %d\n", instance->host_no, cmd->cmnd[0], cmd->target, cmd->lun)); if (cmd->device->disconnect) { /* target wants to reselect later */ DEB_INTR(printk("ok, re-enabling selection\n")); LIST(cmd,hostdata->disconnected_queue); cmd->host_scribble = (unsigned char *)hostdata->disconnected_queue; hostdata->disconnected_queue = cmd; DEB_QUEUE(printk("scsi%d : command for target %d lun %d this %d was moved from connected to" " the disconnected_queue\n", instance->host_no, cmd->target, cmd->lun, hostdata->disconnected_queue->SCp.this_residual)); DEB_QUEUE(AM53C974_print_queues(instance)); goto EXIT_UNFINISHED; } else { /* target does not want to reselect later, we are really finished */ #ifdef AM53C974_DEBUG if (cmd->cmnd[0] == REQUEST_SENSE) { int i; printk("Request sense data dump:\n"); for (i = 0; i < cmd->request_bufflen; i++) { printk("%02x ", *((char *)(cmd->request_buffer) + i)); if (i && !(i % 16)) printk("\n"); } printk("\n"); } #endif goto EXIT_FINISHED; } /* !cmd->device->disconnect */ } /* if (hostdata->disconnecting) */ /* no disconnect message received; unexpected disconnection */ cmd = (Scsi_Cmnd *)hostdata->connected; if (cmd) { #ifdef AM53C974_DEBUG deb_stop = 1; #endif AM53C974_set_async(instance, cmd->target); printk("scsi%d: Unexpected disconnect; phase: %d; target: %d; this_residual: %d; buffers_residual: %d; message: %d\n", instance->host_no, cmd->SCp.phase, cmd->target, cmd->SCp.this_residual, cmd->SCp.buffers_residual, cmd->SCp.Message); printk("cmdreg: 0x%02x; statreg: 0x%02x; isreg: 0x%02x; cfifo: 0x%02x\n", AM53C974_read_8(CMDREG), AM53C974_read_8(STATREG), AM53C974_read_8(ISREG), AM53C974_read_8(CFIREG) & CFIREG_CF); if ((hostdata->last_message[0] == EXTENDED_MESSAGE) && (hostdata->last_message[2] == EXTENDED_SDTR)) { /* sync. negotiation was aborted, setup asynchronous transfer with target */ hostdata->sync_off[cmd->target] = 0; } if (hostdata->aborted || hostdata->msgout[0] == ABORT) cmd->result = DID_ABORT << 16; else cmd->result = DID_ERROR << 16; goto EXIT_FINISHED; } EXIT_FINISHED: hostdata->aborted = 0; hostdata->msgout[0] = NOP; hostdata->sel_cmd = NULL; hostdata->connected = NULL; hostdata->selecting = 0; hostdata->disconnecting = 0; hostdata->dma_busy = 0; hostdata->busy[cmd->target] &= ~(1 << cmd->lun); AM53C974_write_8(CMDREG, CMDREG_CFIFO); DEB(printk("disconnect; issue_queue: 0x%lx, disconnected_queue: 0x%lx\n", (long)hostdata->issue_queue, (long)hostdata->disconnected_queue)); cmd->scsi_done(cmd); if (!hostdata->selecting) { AM53C974_set_async(instance, cmd->target); AM53C974_write_8(CMDREG, CMDREG_ESR); } /* allow reselect */ return; EXIT_UNFINISHED: hostdata->msgout[0] = NOP; hostdata->sel_cmd = NULL; hostdata->connected = NULL; hostdata->aborted = 0; hostdata->selecting = 0; hostdata->disconnecting = 0; hostdata->dma_busy = 0; DEB(printk("disconnect; issue_queue: 0x%lx, disconnected_queue: 0x%lx\n", (long)hostdata->issue_queue, (long)hostdata->disconnected_queue)); if (!hostdata->selecting) { AM53C974_set_async(instance, cmd->target); AM53C974_write_8(CMDREG, CMDREG_ESR); } /* allow reselect */ return; } /************************************************************************** * Function : int AM53C974_sync_neg(struct Scsi_Host *instance, int target, unsigned char *msg) * * Purpose : setup message string for sync. negotiation * * Inputs : instance -- which AM53C974 * target -- which SCSI target to deal with * msg -- input message string * * Returns : 0 if parameters accepted or 1 if not accepted * * Side effects: hostdata is changed * * Note: we assume here that fastclk is enabled **************************************************************************/ static int AM53C974_sync_neg(struct Scsi_Host *instance, int target, unsigned char *msg) { AM53C974_local_declare(); struct AM53C974_hostdata *hostdata = (struct AM53C974_hostdata *)instance->hostdata; int period, offset, i, rate, rate_rem; AM53C974_setio(instance); period = (DEF_CLK * msg[3] * 8 + 1000) / 2000; if (period < MIN_PERIOD) { period = MIN_PERIOD; hostdata->msgout[3] = period / 4; } else if (period > MAX_PERIOD) { period = MAX_PERIOD; hostdata->msgout[3] = period / 4; } else hostdata->msgout[3] = msg[3]; offset = msg[4]; if (offset > MAX_OFFSET) offset = MAX_OFFSET; hostdata->msgout[4] = offset; hostdata->sync_per[target] = period; hostdata->sync_off[target] = offset; for (i = 0; i < 3; i++) hostdata->msgout[i] = msg[i]; if ((hostdata->msgout[3] != msg[3]) || (msg[4] != offset)) return(1); rate = DEF_CLK / period; rate_rem = 10 * (DEF_CLK - period * rate) / period; if (offset) printk("\ntarget %d: rate=%d.%d Mhz, synchronous, sync offset=%d bytes\n", target, rate, rate_rem, offset); else printk("\ntarget %d: rate=%d.%d Mhz, asynchronous\n", target, rate, rate_rem); return(0); } /************************************************************************** * Function : AM53C974_set_async(struct Scsi_Host *instance, int target) * * Purpose : put controller into async. mode * * Inputs : instance -- which AM53C974 * target -- which SCSI target to deal with * * Returns : nothing **************************************************************************/ static __inline__ void AM53C974_set_async(struct Scsi_Host *instance, int target) { AM53C974_local_declare(); struct AM53C974_hostdata *hostdata = (struct AM53C974_hostdata *)instance->hostdata; AM53C974_setio(instance); AM53C974_write_8(STPREG, hostdata->sync_per[target]); AM53C974_write_8(SOFREG, (DEF_SOF_RAD<<6) | (DEF_SOF_RAA<<4)); } /************************************************************************** * Function : AM53C974_set_sync(struct Scsi_Host *instance, int target) * * Purpose : put controller into sync. mode * * Inputs : instance -- which AM53C974 * target -- which SCSI target to deal with * * Returns : nothing **************************************************************************/ static __inline__ void AM53C974_set_sync(struct Scsi_Host *instance, int target) { AM53C974_local_declare(); struct AM53C974_hostdata *hostdata = (struct AM53C974_hostdata *)instance->hostdata; AM53C974_setio(instance); AM53C974_write_8(STPREG, hostdata->sync_per[target]); AM53C974_write_8(SOFREG, (SOFREG_SO & hostdata->sync_off[target]) | (DEF_SOF_RAD<<6) | (DEF_SOF_RAA<<4)); } /*********************************************************************** * Function : AM53C974_information_transfer(struct Scsi_Host *instance, * * unsigned char statreg, unsigned char isreg, * * unsigned char instreg, unsigned char cfifo, * * unsigned char dmastatus) * * * * Purpose : handle phase changes * * * * Inputs : instance - which AM53C974 * * statreg - status register * * isreg - internal state register * * instreg - interrupt status register * * cfifo - number of bytes in FIFO * * dmastatus - dma status register * * * * Returns : nothing * ************************************************************************/ static void AM53C974_information_transfer(struct Scsi_Host *instance, unsigned char statreg, unsigned char isreg, unsigned char instreg, unsigned char cfifo, unsigned char dmastatus) { AM53C974_local_declare(); struct AM53C974_hostdata *hostdata = (struct AM53C974_hostdata *)instance->hostdata; Scsi_Cmnd *cmd = (Scsi_Cmnd *)hostdata->connected; int ret, i, len, residual=-1; AM53C974_setio(instance); DEB_INFO(printk(SEPARATOR_LINE)); switch (statreg & STATREG_PHASE) { /* scsi phase */ case PHASE_DATAOUT: DEB_INFO(printk("Dataout phase; cmd=0x%lx, sel_cmd=0x%lx, this_residual=%d, buffers_residual=%d\n", (long)hostdata->connected, (long)hostdata->sel_cmd, cmd->SCp.this_residual, cmd->SCp.buffers_residual)); cmd->SCp.phase = PHASE_DATAOUT; goto PHASE_DATA_IO; case PHASE_DATAIN: DEB_INFO(printk("Datain phase; cmd=0x%lx, sel_cmd=0x%lx, this_residual=%d, buffers_residual=%d\n", (long)hostdata->connected, (long)hostdata->sel_cmd, cmd->SCp.this_residual, cmd->SCp.buffers_residual)); cmd->SCp.phase = PHASE_DATAIN; PHASE_DATA_IO: if (hostdata->aborted) { AM53C974_write_8(DMACMD, DMACMD_IDLE); AM53C974_write_8(CMDREG, CMDREG_CFIFO); AM53C974_write_8(CMDREG, CMDREG_SATN); return; } if ((!cmd->SCp.this_residual) && cmd->SCp.buffers_residual) { cmd->SCp.buffer++; cmd->SCp.buffers_residual--; cmd->SCp.ptr = (unsigned char *)cmd->SCp.buffer->address; cmd->SCp.this_residual = cmd->SCp.buffer->length; } if (cmd->SCp.this_residual) { if (!(AM53C974_read_8(DMACMD) & DMACMD_START)) { hostdata->dma_busy = 0; AM53C974_transfer_dma(instance, statreg & STATREG_IO, (unsigned long)cmd->SCp.this_residual, cmd->SCp.ptr); } else hostdata->dma_busy = 1; } return; case PHASE_MSGIN: DEB_INFO(printk("Message-In phase; cmd=0x%lx, sel_cmd=0x%lx\n", (long)hostdata->connected, (long)hostdata->sel_cmd)); AM53C974_set_async(instance, cmd->target); if (cmd->SCp.phase == PHASE_DATAIN) AM53C974_dma_blast(instance, dmastatus, statreg); if ((cmd->SCp.phase == PHASE_DATAOUT) && (AM53C974_read_8(DMACMD) & DMACMD_START)) { AM53C974_write_8(DMACMD, DMACMD_IDLE); residual = cfifo + (AM53C974_read_8(CTCLREG) | (AM53C974_read_8(CTCMREG) << 8) | (AM53C974_read_8(CTCHREG) << 16)); cmd->SCp.ptr += cmd->SCp.this_residual - residual; cmd->SCp.this_residual = residual; if (cfifo) { AM53C974_write_8(CMDREG, CMDREG_CFIFO); cfifo = 0; } } if (cmd->SCp.phase == PHASE_STATIN) { while ((AM53C974_read_8(CFIREG) & CFIREG_CF) < 2) ; cmd->SCp.Status = AM53C974_read_8(FFREG); cmd->SCp.Message = AM53C974_read_8(FFREG); DEB_INFO(printk("Message-In phase; status=0x%02x, message=0x%02x\n", cmd->SCp.Status, cmd->SCp.Message)); ret = AM53C974_message(instance, cmd, cmd->SCp.Message); } else { if (!cfifo) { AM53C974_write_8(CMDREG, CMDREG_IT); AM53C974_poll_int(); cmd->SCp.Message = AM53C974_read_8(FFREG); } ret = AM53C974_message(instance, cmd, cmd->SCp.Message); } cmd->SCp.phase = PHASE_MSGIN; AM53C974_set_sync(instance, cmd->target); break; case PHASE_MSGOUT: DEB_INFO(printk("Message-Out phase; cfifo=%d; msgout[0]=0x%02x\n", AM53C974_read_8(CFIREG) & CFIREG_CF, hostdata->msgout[0])); AM53C974_write_8(DMACMD, DMACMD_IDLE); AM53C974_set_async(instance, cmd->target); for (i = 0; i < sizeof(hostdata->last_message); i++) hostdata->last_message[i] = hostdata->msgout[i]; if ((hostdata->msgout[0] == 0) || INSIDE(hostdata->msgout[0], 0x02, 0x1F) || INSIDE(hostdata->msgout[0], 0x80, 0xFF)) len = 1; else { if (hostdata->msgout[0] == EXTENDED_MESSAGE) { #ifdef AM53C974_DEBUG_INFO printk("Extended message dump:\n"); for (i = 0; i < hostdata->msgout[1] + 2; i++) { printk("%02x ", hostdata->msgout[i]); if (i && !(i % 16)) printk("\n"); } printk("\n"); #endif len = hostdata->msgout[1] + 2; } else len = 2; } for (i = 0; i < len; i++) AM53C974_write_8(FFREG, hostdata->msgout[i]); AM53C974_write_8(CMDREG, CMDREG_IT); cmd->SCp.phase = PHASE_MSGOUT; hostdata->msgout[0] = NOP; AM53C974_set_sync(instance, cmd->target); break; case PHASE_CMDOUT: DEB_INFO(printk("Command-Out phase\n")); AM53C974_set_async(instance, cmd->target); for (i = 0; i < cmd->cmd_len; i++) AM53C974_write_8(FFREG, cmd->cmnd[i]); AM53C974_write_8(CMDREG, CMDREG_IT); cmd->SCp.phase = PHASE_CMDOUT; AM53C974_set_sync(instance, cmd->target); break; case PHASE_STATIN: DEB_INFO(printk("Status phase\n")); if (cmd->SCp.phase == PHASE_DATAIN) AM53C974_dma_blast(instance, dmastatus, statreg); AM53C974_set_async(instance, cmd->target); if (cmd->SCp.phase == PHASE_DATAOUT) { unsigned long residual; if (AM53C974_read_8(DMACMD) & DMACMD_START) { AM53C974_write_8(DMACMD, DMACMD_IDLE); residual = cfifo + (AM53C974_read_8(CTCLREG) | (AM53C974_read_8(CTCMREG) << 8) | (AM53C974_read_8(CTCHREG) << 16)); cmd->SCp.ptr += cmd->SCp.this_residual - residual; cmd->SCp.this_residual = residual; } if (cfifo) { AM53C974_write_8(CMDREG, CMDREG_CFIFO); cfifo = 0; } } cmd->SCp.phase = PHASE_STATIN; AM53C974_write_8(CMDREG, CMDREG_ICCS); /* command complete */ break; case PHASE_RES_0: case PHASE_RES_1: #ifdef AM53C974_DEBUG deb_stop = 1; #endif DEB_INFO(printk("Reserved phase\n")); break; } KEYWAIT(); } /****************************************************************************** * Function : int AM53C974_message(struct Scsi_Host *instance, Scsi_Cmnd *cmd, * unsigned char msg) * * Purpose : handle SCSI messages * * Inputs : instance -- which AM53C974 * cmd -- SCSI command the message belongs to * msg -- message id byte * * Returns : 1 on success, 0 on failure. **************************************************************************/ static int AM53C974_message(struct Scsi_Host *instance, Scsi_Cmnd *cmd, unsigned char msg) { AM53C974_local_declare(); static unsigned char extended_msg[10]; unsigned char statreg; int len, ret = 0; unsigned char *p; #ifdef AM53C974_DEBUG_MSG int j; #endif struct AM53C974_hostdata *hostdata = (struct AM53C974_hostdata *)instance->hostdata; AM53C974_setio(instance); DEB_MSG(printk(SEPARATOR_LINE)); /* Linking lets us reduce the time required to get the * next command out to the device, hopefully this will * mean we don't waste another revolution due to the delays * required by ARBITRATION and another SELECTION. * In the current implementation proposal, low level drivers * merely have to start the next command, pointed to by * next_link, done() is called as with unlinked commands. */ switch (msg) { #ifdef LINKED case LINKED_CMD_COMPLETE: case LINKED_FLG_CMD_COMPLETE: /* Accept message by releasing ACK */ DEB_LINKED(printk("scsi%d : target %d lun %d linked command complete.\n", instance->host_no, cmd->target, cmd->lun)); /* Sanity check : A linked command should only terminate with * one of these messages if there are more linked commands available. */ if (!cmd->next_link) { printk("scsi%d : target %d lun %d linked command complete, no next_link\n" instance->host_no, cmd->target, cmd->lun); hostdata->aborted = 1; AM53C974_write_8(CMDREG, CMDREG_SATN); AM53C974_write_8(CMDREG, CMDREG_MA); break; } if (hostdata->aborted) { DEB_ABORT(printk("ATN set for cmnd %d upon reception of LINKED_CMD_COMPLETE or" "LINKED_FLG_CMD_COMPLETE message\n", cmd->cmnd[0])); AM53C974_write_8(CMDREG, CMDREG_SATN); } AM53C974_write_8(CMDREG, CMDREG_MA); initialize_SCp(cmd->next_link); /* The next command is still part of this process */ cmd->next_link->tag = cmd->tag; cmd->result = cmd->SCp.Status | (cmd->SCp.Message << 8); DEB_LINKED(printk("scsi%d : target %d lun %d linked request done, calling scsi_done().\n", instance->host_no, cmd->target, cmd->lun)); cmd->scsi_done(cmd); cmd = hostdata->connected; break; #endif /* def LINKED */ case ABORT: case COMMAND_COMPLETE: DEB_MSG(printk("scsi%d: command complete message received; cmd %d for target %d, lun %d\n", instance->host_no, cmd->cmnd[0], cmd->target, cmd->lun)); hostdata->disconnecting = 1; cmd->device->disconnect = 0; /* I'm not sure what the correct thing to do here is : * * If the command that just executed is NOT a request * sense, the obvious thing to do is to set the result * code to the values of the stored parameters. * If it was a REQUEST SENSE command, we need some way * to differentiate between the failure code of the original * and the failure code of the REQUEST sense - the obvious * case is success, where we fall through and leave the result * code unchanged. * * The non-obvious place is where the REQUEST SENSE failed */ if (cmd->cmnd[0] != REQUEST_SENSE) cmd->result = cmd->SCp.Status | (cmd->SCp.Message << 8); else if (cmd->SCp.Status != GOOD) cmd->result = (cmd->result & 0x00ffff) | (DID_ERROR << 16); if (hostdata->aborted) { AM53C974_write_8(CMDREG, CMDREG_SATN); AM53C974_write_8(CMDREG, CMDREG_MA); DEB_ABORT(printk("ATN set for cmnd %d upon reception of ABORT or" "COMMAND_COMPLETE message\n", cmd->cmnd[0])); break; } if ((cmd->cmnd[0] != REQUEST_SENSE) && (cmd->SCp.Status == CHECK_CONDITION)) { DEB_MSG(printk("scsi%d : performing request sense\n", instance->host_no)); cmd->cmnd[0] = REQUEST_SENSE; cmd->cmnd[1] &= 0xe0; cmd->cmnd[2] = 0; cmd->cmnd[3] = 0; cmd->cmnd[4] = sizeof(cmd->sense_buffer); cmd->cmnd[5] = 0; cmd->SCp.buffer = NULL; cmd->SCp.buffers_residual = 0; cmd->SCp.ptr = (char *)cmd->sense_buffer; cmd->SCp.this_residual = sizeof(cmd->sense_buffer); LIST(cmd,hostdata->issue_queue); cmd->host_scribble = (unsigned char *)hostdata->issue_queue; hostdata->issue_queue = (Scsi_Cmnd *)cmd; DEB_MSG(printk("scsi%d : REQUEST SENSE added to head of issue queue\n",instance->host_no)); } /* Accept message by clearing ACK */ AM53C974_write_8(CMDREG, CMDREG_MA); break; case MESSAGE_REJECT: DEB_MSG(printk("scsi%d: reject message received; cmd %d for target %d, lun %d\n", instance->host_no, cmd->cmnd[0], cmd->target, cmd->lun)); switch (hostdata->last_message[0]) { case EXTENDED_MESSAGE: if (hostdata->last_message[2] == EXTENDED_SDTR) { /* sync. negotiation was rejected, setup asynchronous transfer with target */ printk("\ntarget %d: rate=%d Mhz, asynchronous (sync. negotiation rejected)\n", cmd->target, DEF_CLK / DEF_STP); hostdata->sync_off[cmd->target] = 0; hostdata->sync_per[cmd->target] = DEF_STP; } break; case HEAD_OF_QUEUE_TAG: case ORDERED_QUEUE_TAG: case SIMPLE_QUEUE_TAG: cmd->device->tagged_queue = 0; hostdata->busy[cmd->target] |= (1 << cmd->lun); break; default: break; } if (hostdata->aborted) AM53C974_write_8(CMDREG, CMDREG_SATN); AM53C974_write_8(CMDREG, CMDREG_MA); break; case DISCONNECT: DEB_MSG(printk("scsi%d: disconnect message received; cmd %d for target %d, lun %d\n", instance->host_no, cmd->cmnd[0], cmd->target, cmd->lun)); cmd->device->disconnect = 1; hostdata->disconnecting = 1; AM53C974_write_8(CMDREG, CMDREG_MA); /* Accept message by clearing ACK */ break; case SAVE_POINTERS: case RESTORE_POINTERS: DEB_MSG(printk("scsi%d: save/restore pointers message received; cmd %d for target %d, lun %d\n", instance->host_no, cmd->cmnd[0], cmd->target, cmd->lun)); /* The SCSI data pointer is *IMPLICITLY* saved on a disconnect * operation, in violation of the SCSI spec so we can safely * ignore SAVE/RESTORE pointers calls. * * Unfortunately, some disks violate the SCSI spec and * don't issue the required SAVE_POINTERS message before * disconnecting, and we have to break spec to remain * compatible. */ if (hostdata->aborted) { DEB_ABORT(printk("ATN set for cmnd %d upon reception of SAVE/REST. POINTERS message\n", cmd->cmnd[0])); AM53C974_write_8(CMDREG, CMDREG_SATN); } AM53C974_write_8(CMDREG, CMDREG_MA); break; case EXTENDED_MESSAGE: DEB_MSG(printk("scsi%d: extended message received; cmd %d for target %d, lun %d\n", instance->host_no, cmd->cmnd[0], cmd->target, cmd->lun)); /* Extended messages are sent in the following format : * Byte * 0 EXTENDED_MESSAGE == 1 * 1 length (includes one byte for code, doesn't include first two bytes) * 2 code * 3..length+1 arguments */ /* BEWARE!! THIS CODE IS EXTREMELY UGLY */ extended_msg[0] = EXTENDED_MESSAGE; AM53C974_read_8(INSTREG) ; /* clear int */ AM53C974_write_8(CMDREG, CMDREG_MA); /* ack. msg byte, then wait for SO */ AM53C974_poll_int(); /* get length */ AM53C974_write_8(CMDREG, CMDREG_IT); AM53C974_poll_int(); AM53C974_write_8(CMDREG, CMDREG_MA); /* ack. msg byte, then wait for SO */ AM53C974_poll_int(); extended_msg[1] = len = AM53C974_read_8(FFREG); /* get length */ p = extended_msg+2; /* read the remaining (len) bytes */ while (len) { AM53C974_write_8(CMDREG, CMDREG_IT); AM53C974_poll_int(); if (len > 1) { AM53C974_write_8(CMDREG, CMDREG_MA); /* ack. msg byte, then wait for SO */ AM53C974_poll_int(); } *p = AM53C974_read_8(FFREG); p++; len--; } #ifdef AM53C974_DEBUG_MSG printk("scsi%d: received extended message: ", instance->host_no); for (j = 0; j < extended_msg[1] + 2; j++) { printk("0x%02x ", extended_msg[j]); if (j && !(j % 16)) printk("\n"); } printk("\n"); #endif /* check message */ if (extended_msg[2] == EXTENDED_SDTR) ret = AM53C974_sync_neg(instance, cmd->target, extended_msg); if (ret || hostdata->aborted) AM53C974_write_8(CMDREG, CMDREG_SATN); AM53C974_write_8(CMDREG, CMDREG_MA); break; default: printk("scsi%d: unknown message 0x%02x received\n",instance->host_no, msg); #ifdef AM53C974_DEBUG deb_stop = 1; #endif /* reject message */ hostdata->msgout[0] = MESSAGE_REJECT; AM53C974_write_8(CMDREG, CMDREG_SATN); AM53C974_write_8(CMDREG, CMDREG_MA); return(0); break; } /* switch (msg) */ KEYWAIT(); return(1); } /************************************************************************** * Function : AM53C974_select(struct Scsi_Host *instance, Scsi_Cmnd *cmd, int tag) * * Purpose : try to establish nexus for the command; * start sync negotiation via start stop and transfer the command in * cmdout phase in case of an inquiry or req. sense command with no * sync. neg. performed yet * * Inputs : instance -- which AM53C974 * cmd -- command which requires the selection * tag -- tagged queueing * * Returns : nothing * * Note: this function initializes the selection process, which is continued * in the interrupt handler **************************************************************************/ static void AM53C974_select(struct Scsi_Host *instance, Scsi_Cmnd *cmd, int tag) { AM53C974_local_declare(); struct AM53C974_hostdata *hostdata = (struct AM53C974_hostdata *)instance->hostdata; unsigned char cfifo, tmp[3]; unsigned int i, len, cmd_size = COMMAND_SIZE(cmd->cmnd[0]); AM53C974_setio(instance); cfifo = AM53C974_cfifo(); if (cfifo) { printk("scsi%d: select error; %d residual bytes in FIFO\n", instance->host_no, cfifo); AM53C974_write_8(CMDREG, CMDREG_CFIFO); /* clear FIFO */ } tmp[0] = IDENTIFY(1, cmd->lun); #ifdef SCSI2 if (cmd->device->tagged_queue && (tag != TAG_NONE)) { tmp[1] = SIMPLE_QUEUE_TAG; if (tag == TAG_NEXT) { /* 0 is TAG_NONE, used to imply no tag for this command */ if (cmd->device->current_tag == 0) cmd->device->current_tag = 1; cmd->tag = cmd->device->current_tag; cmd->device->current_tag++; } else cmd->tag = (unsigned char)tag; tmp[2] = cmd->tag; hostdata->last_message[0] = SIMPLE_QUEUE_TAG; len = 3; AM53C974_write_8(FFREG, tmp[0]); AM53C974_write_8(FFREG, tmp[1]); AM53C974_write_8(FFREG, tmp[2]); } else #endif /* def SCSI2 */ { len = 1; AM53C974_write_8(FFREG, tmp[0]); cmd->tag = 0; } /* in case of an inquiry or req. sense command with no sync. neg performed yet, we start sync negotiation via start stops and transfer the command in cmdout phase */ if (((cmd->cmnd[0] == INQUIRY) || (cmd->cmnd[0] == REQUEST_SENSE)) && !(hostdata->sync_neg[cmd->target]) && hostdata->sync_en[cmd->target]) { hostdata->sync_neg[cmd->target] = 1; hostdata->msgout[0] = EXTENDED_MESSAGE; hostdata->msgout[1] = 3; hostdata->msgout[2] = EXTENDED_SDTR; hostdata->msgout[3] = 250 / (int)hostdata->max_rate[cmd->target]; hostdata->msgout[4] = hostdata->max_offset[cmd->target]; len += 5; } AM53C974_write_8(SDIDREG, SDIREG_MASK & cmd->target); /* setup dest. id */ AM53C974_write_8(STIMREG, DEF_SCSI_TIMEOUT); /* setup timeout reg */ switch (len) { case 1: for (i = 0; i < cmd_size; i++) AM53C974_write_8(FFREG, cmd->cmnd[i]); AM53C974_write_8(CMDREG, CMDREG_SAS); /* select with ATN, 1 msg byte */ hostdata->msgout[0] = NOP; break; case 3: for (i = 0; i < cmd_size; i++) AM53C974_write_8(FFREG, cmd->cmnd[i]); AM53C974_write_8(CMDREG, CMDREG_SA3S); /* select with ATN, 3 msg bytes */ hostdata->msgout[0] = NOP; break; default: AM53C974_write_8(CMDREG, CMDREG_SASS); /* select with ATN, stop steps; continue in message out phase */ break; } } /************************************************************************** * Function : AM53C974_intr_select(struct Scsi_Host *instance, unsigned char statreg) * * Purpose : handle reselection * * Inputs : instance -- which AM53C974 * statreg -- status register * * Returns : nothing * * side effects: manipulates hostdata **************************************************************************/ static void AM53C974_intr_reselect(struct Scsi_Host *instance, unsigned char statreg) { AM53C974_local_declare(); struct AM53C974_hostdata *hostdata = (struct AM53C974_hostdata *)instance->hostdata; unsigned char cfifo, msg[3], lun, t, target = 0; #ifdef SCSI2 unsigned char tag; #endif Scsi_Cmnd *tmp = NULL, *prev; AM53C974_setio(instance); cfifo = AM53C974_cfifo(); if (hostdata->selecting) { /* caught reselect interrupt in selection process; put selecting command back into the issue queue and continue with the reselecting command */ DEB_RESEL(printk("AM53C974_intr_reselect: in selection process\n")); LIST(hostdata->sel_cmd, hostdata->issue_queue); hostdata->sel_cmd->host_scribble = (unsigned char *)hostdata->issue_queue; hostdata->issue_queue = hostdata->sel_cmd; hostdata->sel_cmd = NULL; hostdata->selecting = 0; } /* 2 bytes must be in the FIFO now */ if (cfifo != 2) { printk("scsi %d: error: %d bytes in fifo, 2 expected\n", instance->host_no, cfifo); hostdata->aborted = 1; goto EXIT_ABORT; } /* determine target which reselected */ t = AM53C974_read_8(FFREG); if (!(t & (1 << instance->this_id))) { printk("scsi %d: error: invalid host id\n", instance->host_no); hostdata->aborted = 1; goto EXIT_ABORT; } t ^= (1 << instance->this_id); target = 0; while (t != 1) { t >>= 1; target++; } DEB_RESEL(printk("scsi %d: reselect; target: %d\n", instance->host_no, target)); if (hostdata->aborted) goto EXIT_ABORT; if ((statreg & STATREG_PHASE) != PHASE_MSGIN) { printk("scsi %d: error: upon reselection interrupt not in MSGIN\n", instance->host_no); hostdata->aborted = 1; goto EXIT_ABORT; } msg[0] = AM53C974_read_8(FFREG); if (!msg[0] & 0x80) { printk("scsi%d: error: expecting IDENTIFY message, got ", instance->host_no); print_msg(msg); hostdata->aborted = 1; goto EXIT_ABORT; } lun = (msg[0] & 0x07); /* We need to add code for SCSI-II to track which devices have * I_T_L_Q nexuses established, and which have simple I_T_L * nexuses so we can chose to do additional data transfer. */ #ifdef SCSI2 #error "SCSI-II tagged queueing is not supported yet" #endif /* Find the command corresponding to the I_T_L or I_T_L_Q nexus we * just reestablished, and remove it from the disconnected queue. */ for (tmp = (Scsi_Cmnd *)hostdata->disconnected_queue, prev = NULL; tmp; prev = tmp, tmp = (Scsi_Cmnd *)tmp->host_scribble) if ((target == tmp->target) && (lun == tmp->lun) #ifdef SCSI2 && (tag == tmp->tag) #endif ) { if (prev) { REMOVE(prev, (Scsi_Cmnd *)(prev->host_scribble), tmp, (Scsi_Cmnd *)(tmp->host_scribble)); prev->host_scribble = tmp->host_scribble; } else { REMOVE(-1, hostdata->disconnected_queue, tmp, tmp->host_scribble); hostdata->disconnected_queue = (Scsi_Cmnd *)tmp->host_scribble; } tmp->host_scribble = NULL; hostdata->connected = tmp; break; } if (!tmp) { #ifdef SCSI2 printk("scsi%d: warning : target %d lun %d tag %d not in disconnect_queue.\n", instance->host_no, target, lun, tag); #else printk("scsi%d: warning : target %d lun %d not in disconnect_queue.\n", instance->host_no, target, lun); #endif /* Since we have an established nexus that we can't do anything with, we must abort it. */ hostdata->aborted = 1; DEB(AM53C974_keywait()); goto EXIT_ABORT; } else goto EXIT_OK; EXIT_ABORT: AM53C974_write_8(CMDREG, CMDREG_SATN); AM53C974_write_8(CMDREG, CMDREG_MA); return; EXIT_OK: DEB_RESEL(printk("scsi%d: nexus established, target = %d, lun = %d, tag = %d\n", instance->host_no, target, tmp->lun, tmp->tag)); AM53C974_set_sync(instance, target); AM53C974_write_8(SDIDREG, SDIREG_MASK & target); /* setup dest. id */ AM53C974_write_8(CMDREG, CMDREG_MA); hostdata->dma_busy = 0; hostdata->connected->SCp.phase = PHASE_CMDOUT; } /************************************************************************** * Function : AM53C974_transfer_dma(struct Scsi_Host *instance, short dir, * unsigned long length, char *data) * * Purpose : setup DMA transfer * * Inputs : instance -- which AM53C974 * dir -- direction flag, 0: write to device, read from memory; * 1: read from device, write to memory * length -- number of bytes to transfer to from buffer * data -- pointer to data buffer * * Returns : nothing **************************************************************************/ static __inline__ void AM53C974_transfer_dma(struct Scsi_Host *instance, short dir, unsigned long length, char *data) { AM53C974_local_declare(); AM53C974_setio(instance); AM53C974_write_8(CMDREG, CMDREG_NOP); AM53C974_write_8(DMACMD, (dir << 7) | DMACMD_INTE_D); /* idle command */ AM53C974_write_8(STCLREG, (unsigned char)(length & 0xff)); AM53C974_write_8(STCMREG, (unsigned char)((length & 0xff00) >> 8)); AM53C974_write_8(STCHREG, (unsigned char)((length & 0xff0000) >> 16)); AM53C974_write_32(DMASTC, length & 0xffffff); AM53C974_write_32(DMASPA, virt_to_bus(data)); AM53C974_write_8(CMDREG, CMDREG_IT | CMDREG_DMA); AM53C974_write_8(DMACMD, (dir << 7) | DMACMD_INTE_D | DMACMD_START); } /************************************************************************** * Function : AM53C974_dma_blast(struct Scsi_Host *instance, unsigned char dmastatus, * unsigned char statreg) * * Purpose : cleanup DMA transfer * * Inputs : instance -- which AM53C974 * dmastatus -- dma status register * statreg -- status register * * Returns : nothing **************************************************************************/ static void AM53C974_dma_blast(struct Scsi_Host *instance, unsigned char dmastatus, unsigned char statreg) { AM53C974_local_declare(); struct AM53C974_hostdata *hostdata = (struct AM53C974_hostdata *)instance->hostdata; unsigned long ctcreg; int dir = statreg & STATREG_IO; int cfifo, pio, i = 0; AM53C974_setio(instance); do { cfifo = AM53C974_cfifo(); i++; } while (cfifo && (i < 50000)); pio = (i == 50000) ? 1: 0; if (statreg & STATREG_CTZ) { AM53C974_write_8(DMACMD, DMACMD_IDLE); return; } if (dmastatus & DMASTATUS_DONE) { AM53C974_write_8(DMACMD, DMACMD_IDLE); return; } AM53C974_write_8(DMACMD, ((dir << 7) & DMACMD_DIR) | DMACMD_BLAST); while(!(AM53C974_read_8(DMASTATUS) & DMASTATUS_BCMPLT)) ; AM53C974_write_8(DMACMD, DMACMD_IDLE); if (pio) { /* transfer residual bytes via PIO */ unsigned char *wac = (unsigned char *)AM53C974_read_32(DMAWAC); printk("pio mode, residual=%d\n", AM53C974_read_8(CFIREG) & CFIREG_CF); while (AM53C974_read_8(CFIREG) & CFIREG_CF) *(wac++) = AM53C974_read_8(FFREG); } ctcreg = AM53C974_read_8(CTCLREG) | (AM53C974_read_8(CTCMREG) << 8) | (AM53C974_read_8(CTCHREG) << 16); hostdata->connected->SCp.ptr += hostdata->connected->SCp.this_residual - ctcreg; hostdata->connected->SCp.this_residual = ctcreg; } /************************************************************************** * Function : AM53C974_intr_bus_reset(struct Scsi_Host *instance) * * Purpose : handle bus reset interrupt * * Inputs : instance -- which AM53C974 * * Returns : nothing **************************************************************************/ static void AM53C974_intr_bus_reset(struct Scsi_Host *instance) { AM53C974_local_declare(); unsigned char cntlreg1; AM53C974_setio(instance); AM53C974_write_8(CMDREG, CMDREG_CFIFO); AM53C974_write_8(CMDREG, CMDREG_NOP); cntlreg1 = AM53C974_read_8(CNTLREG1); AM53C974_write_8(CNTLREG1, cntlreg1 | CNTLREG1_DISR); } /************************************************************************** * Function : int AM53C974_abort(Scsi_Cmnd *cmd) * * Purpose : abort a command * * Inputs : cmd - the Scsi_Cmnd to abort, code - code to set the * host byte of the result field to, if zero DID_ABORTED is * used. * * Returns : 0 - success, -1 on failure. **************************************************************************/ int AM53C974_abort(Scsi_Cmnd *cmd) { AM53C974_local_declare(); struct Scsi_Host *instance = cmd->host; struct AM53C974_hostdata *hostdata = (struct AM53C974_hostdata *)instance->hostdata; Scsi_Cmnd *tmp, **prev; #ifdef AM53C974_DEBUG deb_stop = 1; #endif cli(); AM53C974_setio(instance); DEB_ABORT(printk(SEPARATOR_LINE)); DEB_ABORT(printk("scsi%d : AM53C974_abort called -- trouble starts!!\n", instance->host_no)); DEB_ABORT(AM53C974_print(instance)); DEB_ABORT(AM53C974_keywait()); /* Case 1 : If the command is the currently executing command, we'll set the aborted flag and return control so that the information transfer routine can exit cleanly. */ if ((hostdata->connected == cmd) || (hostdata->sel_cmd == cmd)) { DEB_ABORT(printk("scsi%d: aborting connected command\n", instance->host_no)); hostdata->aborted = 1; hostdata->msgout[0] = ABORT; sti(); return(SCSI_ABORT_PENDING); } /* Case 2 : If the command hasn't been issued yet, we simply remove it from the issue queue. */ for (prev = (Scsi_Cmnd **)&(hostdata->issue_queue), tmp = (Scsi_Cmnd *)hostdata->issue_queue; tmp; prev = (Scsi_Cmnd **)&(tmp->host_scribble), tmp = (Scsi_Cmnd *)tmp->host_scribble) { if (cmd == tmp) { DEB_ABORT(printk("scsi%d : abort removed command from issue queue.\n", instance->host_no)); REMOVE(5, *prev, tmp, tmp->host_scribble); (*prev) = (Scsi_Cmnd *)tmp->host_scribble; tmp->host_scribble = NULL; tmp->result = DID_ABORT << 16; sti(); tmp->done(tmp); return(SCSI_ABORT_SUCCESS); } #ifdef AM53C974_DEBUG_ABORT else { if (prev == (Scsi_Cmnd **)tmp) printk("scsi%d : LOOP\n", instance->host_no); } #endif } /* Case 3 : If any commands are connected, we're going to fail the abort * and let the high level SCSI driver retry at a later time or * issue a reset. * * Timeouts, and therefore aborted commands, will be highly unlikely * and handling them cleanly in this situation would make the common * case of noresets less efficient, and would pollute our code. So, * we fail. */ if (hostdata->connected || hostdata->sel_cmd) { DEB_ABORT(printk("scsi%d : abort failed, other command connected.\n", instance->host_no)); sti(); return(SCSI_ABORT_NOT_RUNNING); } /* Case 4: If the command is currently disconnected from the bus, and * there are no connected commands, we reconnect the I_T_L or * I_T_L_Q nexus associated with it, go into message out, and send * an abort message. */ for (tmp = (Scsi_Cmnd *)hostdata->disconnected_queue; tmp; tmp = (Scsi_Cmnd *)tmp->host_scribble) { if (cmd == tmp) { DEB_ABORT(printk("scsi%d: aborting disconnected command\n", instance->host_no)); hostdata->aborted = 1; hostdata->msgout[0] = ABORT; hostdata->selecting = 1; hostdata->sel_cmd = tmp; AM53C974_write_8(CMDREG, CMDREG_DSR); sti(); return(SCSI_ABORT_PENDING); } } /* Case 5 : If we reached this point, the command was not found in any of * the queues. * * We probably reached this point because of an unlikely race condition * between the command completing successfully and the abortion code, * so we won't panic, but we will notify the user in case something really * broke. */ DEB_ABORT(printk("scsi%d : abort failed, command not found.\n", instance->host_no)); sti(); return(SCSI_ABORT_NOT_RUNNING); } /************************************************************************** * Function : int AM53C974_reset(Scsi_Cmnd *cmd) * * Purpose : reset the SCSI controller and bus * * Inputs : cmd -- which command within the command block was responsible for the reset * * Returns : status (SCSI_ABORT_SUCCESS) **************************************************************************/ int AM53C974_reset(Scsi_Cmnd *cmd, unsigned int flags) { AM53C974_local_declare(); int i; struct Scsi_Host *instance = cmd->host; struct AM53C974_hostdata *hostdata = (struct AM53C974_hostdata *)instance->hostdata; AM53C974_setio(instance); cli(); DEB(printk("AM53C974_reset called; ")); printk("AM53C974_reset called\n"); AM53C974_print(instance); AM53C974_keywait(); /* do hard reset */ AM53C974_write_8(CMDREG, CMDREG_RDEV); AM53C974_write_8(CMDREG, CMDREG_NOP); hostdata->msgout[0] = NOP; for (i = 0; i < 8; i++) { hostdata->busy[i] = 0; hostdata->sync_per[i] = DEF_STP; hostdata->sync_off[i] = 0; hostdata->sync_neg[i] = 0; } hostdata->last_message[0] = NOP; hostdata->sel_cmd = NULL; hostdata->connected = NULL; hostdata->issue_queue = NULL; hostdata->disconnected_queue = NULL; hostdata->in_reset = 0; hostdata->aborted = 0; hostdata->selecting = 0; hostdata->disconnecting = 0; hostdata->dma_busy = 0; /* reset bus */ AM53C974_write_8(CNTLREG1, CNTLREG1_DISR | instance->this_id); /* disable interrupt upon SCSI RESET */ AM53C974_write_8(CMDREG, CMDREG_RBUS); /* reset SCSI bus */ udelay(40); AM53C974_config_after_reset(instance); sti(); cmd->result = DID_RESET << 16; cmd->scsi_done(cmd); return SCSI_ABORT_SUCCESS; } /* * AM53C974_release() * * Release resources allocated for a single AM53C974 adapter. */ int AM53C974_release(struct Scsi_Host *shp) { free_irq(shp->irq, NULL); scsi_unregister(shp); return 0; } #ifdef MODULE /* Eventually this will go into an include file, but this will be later */ Scsi_Host_Template driver_template = AM53C974; #include "scsi_module.c" #endif