![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to AM53C974.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / linux / src / drivers / scsi|
Return to AM53C974.c CVS log | Up to [GnuMach] / Gnu-Mach / linux / src / drivers / scsi |
1.1 root 1: #include <linux/module.h>
2:
3: #include <linux/config.h>
4: #include <linux/delay.h>
5: #include <linux/signal.h>
6: #include <linux/sched.h>
7: #include <linux/errno.h>
8: #include <linux/bios32.h>
9: #include <linux/pci.h>
10: #include <linux/string.h>
11: #include <linux/blk.h>
12:
13: #include <asm/io.h>
14: #include <asm/system.h>
15:
16: #include "scsi.h"
17: #include "hosts.h"
18: #include "AM53C974.h"
19: #include "constants.h"
20: #include "sd.h"
21:
22: /* AM53/79C974 (PCscsi) driver release 0.5
23: *
24: * The architecture and much of the code of this device
25: * driver was originally developed by Drew Eckhardt for
26: * the NCR5380. The following copyrights apply:
27: * For the architecture and all pieces of code which can also be found
28: * in the NCR5380 device driver:
29: * Copyright 1993, Drew Eckhardt
30: * Visionary Computing
31: * (Unix and Linux consulting and custom programming)
32: * [email protected]
33: * +1 (303) 666-5836
34: *
35: * The AM53C974_nobios_detect code was originally developed by
36: * Robin Cutshaw ([email protected]) and is used here in a
37: * slightly modified form.
38: *
39: * For the remaining code:
40: * Copyright 1994, D. Frieauff
41: * EMail: [email protected]
42: * Phone: x49-7545-8-2256 , x49-7541-42305
43: */
44:
45: /*
46: * $Log: AM53C974.c,v $
47: * Revision 1.1 1999/04/26 05:53:47 tb
48: * 1998-11-30 OKUJI Yoshinori <[email protected]>
49: *
50: * Clean up linux emulation code to make it architecture-independent
51: * as much as possible.
52: *
53: * * linux: Renamed from linuxdev.
54: * * Makefile.in (objfiles): Add linux.o instead of linuxdev.o.
55: * (MAKE): New variable. Used for the linux.o target.
56: * * configure.in: Add AC_CHECK_TOOL(MAKE, make).
57: * * i386/i386/spl.h: Include <i386/ipl.h>, for compatibility with
58: * OSF Mach 3.0. Suggested by Elgin Lee <[email protected]>.
59: * * linux/src: Renamed from linux/linux.
60: * * linux/dev: Renamed from linux/mach.
61: * * linux/Drivers.in (AC_INIT): Use dev/include/linux/autoconf.h,
62: * instead of mach/include/linux/autoconf.h.
63: * * Makefile.in (all): Target ../linux.o instead of ../linuxdev.o.
64: * * linux/dev/drivers/block/genhd.c: Include <machine/spl.h> instead
65: * of <i386/ipl.h>.
66: * * linux/dev/drivers/net/auto_irq.c: Remove unneeded header files,
67: * <i386/ipl.h> and <i386/pic.h>.
68: * * linux/dev/init/main.c: Many i386-dependent codes moved to ...
69: * * linux/dev/arch/i386/irq.c: ... here.
70: * * linux/dev/arch/i386/setup.c: New file.
71: * * linux/dev/arch/i386/linux_emul.h: Likewise.
72: * * linux/dev/arch/i386/glue/timer.c: Merged into sched.c.
73: * * linux/dev/arch/i386/glue/sched.c: Include <machine/spl.h> instead
74: * of <i386/ipl.h>, and moved to ...
75: * * linux/dev/kernel/sched.c: ... here.
76: * * linux/dev/arch/i386/glue/block.c: Include <machine/spl.h> and
77: * <linux_emul.h>, instead of i386-dependent header files, and
78: * moved to ...
79: * * linux/dev/glue/blocl.c: ... here.
80: * * linux/dev/arch/i386/glue/net.c: Include <machine/spl.h> and
81: * <linux_emul.h>, instead of i386-dependent header files, and
82: * moved to ...
83: * * linux/dev/glue/net.c: ... here.
84: * * linux/dev/arch/i386/glue/misc.c: Remove `x86' and moved to ...
85: * * linux/dev/glue/misc.c: ... here.
86: * * linux/dev/arch/i386/glue/kmem.c: Moved to ...
87: * * linux/dev/glue/kmem.c: ... here.
88: *
89: */
90:
91: #ifdef AM53C974_DEBUG
92: #define DEB(x) x
93: #ifdef AM53C974_DEBUG_KEYWAIT
94: #define KEYWAIT() AM53C974_keywait()
95: #else
96: #define KEYWAIT()
97: #endif
98: #ifdef AM53C974_DEBUG_INIT
99: #define DEB_INIT(x) x
100: #else
101: #define DEB_INIT(x)
102: #endif
103: #ifdef AM53C974_DEBUG_MSG
104: #define DEB_MSG(x) x
105: #else
106: #define DEB_MSG(x)
107: #endif
108: #ifdef AM53C974_DEB_RESEL
109: #define DEB_RESEL(x) x
110: #else
111: #define DEB_RESEL(x)
112: #endif
113: #ifdef AM53C974_DEBUG_QUEUE
114: #define DEB_QUEUE(x) x
115: #define LIST(x,y) {printk("LINE:%d Adding %p to %p\n", __LINE__, (void*)(x), (void*)(y)); if ((x)==(y)) udelay(5); }
116: #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); }
117: #else
118: #define DEB_QUEUE(x)
119: #define LIST(x,y)
120: #define REMOVE(w,x,y,z)
121: #endif
122: #ifdef AM53C974_DEBUG_INFO
123: #define DEB_INFO(x) x
124: #else
125: #define DEB_INFO(x)
126: #endif
127: #ifdef AM53C974_DEBUG_LINKED
128: #define DEB_LINKED(x) x
129: #else
130: #define DEB_LINKED(x)
131: #endif
132: #ifdef AM53C974_DEBUG_INTR
133: #define DEB_INTR(x) x
134: #else
135: #define DEB_INTR(x)
136: #endif
137: #else
138: #define DEB_INIT(x)
139: #define DEB(x)
140: #define DEB_QUEUE(x)
141: #define LIST(x,y)
142: #define REMOVE(w,x,y,z)
143: #define DEB_INFO(x)
144: #define DEB_LINKED(x)
145: #define DEB_INTR(x)
146: #define DEB_MSG(x)
147: #define DEB_RESEL(x)
148: #define KEYWAIT()
149: #endif
150: #ifdef AM53C974_DEBUG_ABORT
151: #define DEB_ABORT(x) x
152: #else
153: #define DEB_ABORT(x)
154: #endif
155:
156: #ifdef VERBOSE_AM53C974_DEBUG
157: #define VDEB(x) x
158: #else
159: #define VDEB(x)
160: #endif
161:
162: #define INSIDE(x,l,h) ( ((x) >= (l)) && ((x) <= (h)) )
163:
164: #ifdef AM53C974_DEBUG
165: static void AM53C974_print_pci(struct Scsi_Host *instance);
166: static void AM53C974_print_phase(struct Scsi_Host *instance);
167: static void AM53C974_print_queues(struct Scsi_Host *instance);
168: #endif /* AM53C974_DEBUG */
169: static void AM53C974_print(struct Scsi_Host *instance);
170: static void AM53C974_keywait(void);
171: static int AM53C974_bios_detect(Scsi_Host_Template *tpnt);
172: static int AM53C974_nobios_detect(Scsi_Host_Template *tpnt);
173: static int AM53C974_init(Scsi_Host_Template *tpnt, pci_config_t pci_config);
174: static void AM53C974_config_after_reset(struct Scsi_Host *instance);
175: static __inline__ void initialize_SCp(Scsi_Cmnd *cmd);
176: static __inline__ void run_main(void);
177: static void AM53C974_main (void);
178: static void AM53C974_intr(int irq, void *dev_id, struct pt_regs *regs);
179: static void AM53C974_intr_disconnect(struct Scsi_Host *instance);
180: static int AM53C974_sync_neg(struct Scsi_Host *instance, int target, unsigned char *msg);
181: static __inline__ void AM53C974_set_async(struct Scsi_Host *instance, int target);
182: static __inline__ void AM53C974_set_sync(struct Scsi_Host *instance, int target);
183: static void AM53C974_information_transfer(struct Scsi_Host *instance,
184: unsigned char statreg, unsigned char isreg,
185: unsigned char instreg, unsigned char cfifo,
186: unsigned char dmastatus);
187: static int AM53C974_message(struct Scsi_Host *instance, Scsi_Cmnd *cmd, unsigned char msg);
188: static void AM53C974_select(struct Scsi_Host *instance, Scsi_Cmnd *cmd, int tag);
189: static void AM53C974_intr_reselect(struct Scsi_Host *instance, unsigned char statreg);
190: static __inline__ void AM53C974_transfer_dma(struct Scsi_Host *instance, short dir,
191: unsigned long length, char *data);
192: static void AM53C974_dma_blast(struct Scsi_Host *instance, unsigned char dmastatus,
193: unsigned char statreg);
194: static void AM53C974_intr_bus_reset(struct Scsi_Host *instance);
195:
196: static struct Scsi_Host *first_instance = NULL;
197: static Scsi_Host_Template *the_template = NULL;
198: static struct Scsi_Host *first_host = NULL; /* Head of list of AMD boards */
199: static volatile int main_running = 0;
200: static int commandline_current = 0;
201: override_t overrides[7] = { {-1, 0, 0, 0}, }; /* LILO overrides */
202:
203: struct proc_dir_entry proc_scsi_am53c974 = {
204: PROC_SCSI_AM53C974, 8, "am53c974",
205: S_IFDIR | S_IRUGO | S_IXUGO, 2
206: };
207:
208: #ifdef AM53C974_DEBUG
209: static int deb_stop = 1;
210:
211: /**************************************************************************
212: * Function : void AM53C974_print_pci(struct Scsi_Host *instance)
213: *
214: * Purpose : dump the PCI registers for debugging purposes
215: *
216: * Input : instance - which AM53C974
217: **************************************************************************/
218: static void AM53C974_print_pci(struct Scsi_Host *instance)
219: {
220: int i;
221: unsigned short vendor_id, device_id, command, status, scratch[8];
222: unsigned long class_revision, base;
223: unsigned char irq, cache_line_size, latency_timer, header_type;
224:
225: AM53C974_PCIREG_OPEN();
226:
227: for (i = 0; i < 8; i++) *(scratch + i) = AM53C974_PCIREG_READ_WORD(instance, PCI_SCRATCH_REG_0 + 2*i);
228: vendor_id = AM53C974_PCIREG_READ_WORD(instance, PCI_VENDOR_ID);
229: device_id = AM53C974_PCIREG_READ_WORD(instance, PCI_DEVICE_ID);
230: command = AM53C974_PCIREG_READ_WORD(instance, PCI_COMMAND);
231: status = AM53C974_PCIREG_READ_WORD(instance, PCI_STATUS);
232: class_revision = AM53C974_PCIREG_READ_DWORD(instance, PCI_CLASS_REVISION);
233: cache_line_size = AM53C974_PCIREG_READ_BYTE(instance, PCI_CACHE_LINE_SIZE);
234: latency_timer = AM53C974_PCIREG_READ_BYTE(instance, PCI_LATENCY_TIMER);
235: header_type = AM53C974_PCIREG_READ_BYTE(instance, PCI_HEADER_TYPE);
236: base = AM53C974_PCIREG_READ_DWORD(instance, PCI_BASE_ADDRESS_0);
237: irq = AM53C974_PCIREG_READ_BYTE(instance, PCI_INTERRUPT_LINE);
238:
239: AM53C974_PCIREG_CLOSE();
240:
241:
242: printk("------------- start of PCI register dump -------------\n");
243: printk("PCI_VENDOR_ID: 0x%x\n", vendor_id);
244: printk("PCI_DEVICE_ID: 0x%x\n", device_id);
245: printk("PCI_COMMAND: 0x%x\n", command);
246: printk("PCI_STATUS: 0x%x\n", status);
247: printk("PCI_CLASS_REVISION: 0x%lx\n", class_revision);
248: printk("PCI_CACHE_LINE_SIZE: 0x%x\n", cache_line_size);
249: printk("PCI_LATENCY_TIMER: 0x%x\n", latency_timer);
250: printk("PCI_HEADER_TYPE: 0x%x\n", header_type);
251: printk("PCI_BASE_ADDRESS_0: 0x%lx\n", base);
252: printk("PCI_INTERRUPT_LINE: %d\n", irq);
253: for (i = 0; i < 8; i++) printk("PCI_SCRATCH_%d: 0x%x\n", i, scratch[i]);
254: printk("------------- end of PCI register dump -------------\n\n");
255: }
256:
257: static struct {
258: unsigned char value;
259: char *name;
260: } phases[] = {
261: {PHASE_DATAOUT, "DATAOUT"}, {PHASE_DATAIN, "DATAIN"}, {PHASE_CMDOUT, "CMDOUT"},
262: {PHASE_STATIN, "STATIN"}, {PHASE_MSGOUT, "MSGOUT"}, {PHASE_MSGIN, "MSGIN"},
263: {PHASE_RES_0, "RESERVED 0"}, {PHASE_RES_1, "RESERVED 1"}};
264:
265: /**************************************************************************
266: * Function : void AM53C974_print_phase(struct Scsi_Host *instance)
267: *
268: * Purpose : print the current SCSI phase for debugging purposes
269: *
270: * Input : instance - which AM53C974
271: **************************************************************************/
272: static void AM53C974_print_phase(struct Scsi_Host *instance)
273: {
274: AM53C974_local_declare();
275: unsigned char statreg, latched;
276: int i;
277: AM53C974_setio(instance);
278:
279: latched = (AM53C974_read_8(CNTLREG2)) & CNTLREG2_ENF;
280: statreg = AM53C974_read_8(STATREG);
281: for (i = 0; (phases[i].value != PHASE_RES_1) &&
282: (phases[i].value != (statreg & STATREG_PHASE)); ++i);
283: if (latched)
284: printk("scsi%d : phase %s, latched at end of last command\n", instance->host_no, phases[i].name);
285: else
286: printk("scsi%d : phase %s, real time\n", instance->host_no, phases[i].name);
287: }
288:
289: /**************************************************************************
290: * Function : void AM53C974_print_queues(struct Scsi_Host *instance)
291: *
292: * Purpose : print commands in the various queues
293: *
294: * Inputs : instance - which AM53C974
295: **************************************************************************/
296: static void AM53C974_print_queues(struct Scsi_Host *instance)
297: {
298: struct AM53C974_hostdata *hostdata = (struct AM53C974_hostdata *)instance->hostdata;
299: Scsi_Cmnd *ptr;
300:
301: printk("AM53C974: coroutine is%s running.\n", main_running ? "" : "n't");
302:
303: cli();
304:
305: if (!hostdata->connected) {
306: printk ("scsi%d: no currently connected command\n", instance->host_no); }
307: else {
308: print_Scsi_Cmnd ((Scsi_Cmnd *)hostdata->connected); }
309: if (!hostdata->sel_cmd) {
310: printk ("scsi%d: no currently arbitrating command\n", instance->host_no); }
311: else {
312: print_Scsi_Cmnd ((Scsi_Cmnd *)hostdata->sel_cmd); }
313:
314: printk ("scsi%d: issue_queue ", instance->host_no);
315: if (!hostdata->issue_queue)
316: printk("empty\n");
317: else {
318: printk(":\n");
319: for (ptr = (Scsi_Cmnd *)hostdata->issue_queue; ptr; ptr = (Scsi_Cmnd *)ptr->host_scribble)
320: print_Scsi_Cmnd (ptr); }
321:
322: printk ("scsi%d: disconnected_queue ", instance->host_no);
323: if (!hostdata->disconnected_queue)
324: printk("empty\n");
325: else {
326: printk(":\n");
327: for (ptr = (Scsi_Cmnd *) hostdata->disconnected_queue; ptr; ptr = (Scsi_Cmnd *)ptr->host_scribble)
328: print_Scsi_Cmnd (ptr); }
329:
330: sti();
331: }
332:
333: #endif /* AM53C974_DEBUG */
334:
335: /**************************************************************************
336: * Function : void AM53C974_print(struct Scsi_Host *instance)
337: *
338: * Purpose : dump the chip registers for debugging purposes
339: *
340: * Input : instance - which AM53C974
341: **************************************************************************/
342: static void AM53C974_print(struct Scsi_Host *instance)
343: {
344: AM53C974_local_declare();
345: unsigned long ctcreg, dmastc, dmaspa, dmawbc, dmawac;
346: unsigned char cmdreg, statreg, isreg, cfireg, cntlreg[4], dmacmd, dmastatus;
347: AM53C974_setio(instance);
348:
349: cli();
350: ctcreg = AM53C974_read_8(CTCHREG) << 16;
351: ctcreg |= AM53C974_read_8(CTCMREG) << 8;
352: ctcreg |= AM53C974_read_8(CTCLREG);
353: cmdreg = AM53C974_read_8(CMDREG);
354: statreg = AM53C974_read_8(STATREG);
355: isreg = AM53C974_read_8(ISREG);
356: cfireg = AM53C974_read_8(CFIREG);
357: cntlreg[0] = AM53C974_read_8(CNTLREG1);
358: cntlreg[1] = AM53C974_read_8(CNTLREG2);
359: cntlreg[2] = AM53C974_read_8(CNTLREG3);
360: cntlreg[3] = AM53C974_read_8(CNTLREG4);
361: dmacmd = AM53C974_read_8(DMACMD);
362: dmastc = AM53C974_read_32(DMASTC);
363: dmaspa = AM53C974_read_32(DMASPA);
364: dmawbc = AM53C974_read_32(DMAWBC);
365: dmawac = AM53C974_read_32(DMAWAC);
366: dmastatus = AM53C974_read_8(DMASTATUS);
367: sti();
368:
369: printk("AM53C974 register dump:\n");
370: printk("IO base: 0x%04lx; CTCREG: 0x%04lx; CMDREG: 0x%02x; STATREG: 0x%02x; ISREG: 0x%02x\n",
371: io_port, ctcreg, cmdreg, statreg, isreg);
372: printk("CFIREG: 0x%02x; CNTLREG1-4: 0x%02x; 0x%02x; 0x%02x; 0x%02x\n",
373: cfireg, cntlreg[0], cntlreg[1], cntlreg[2], cntlreg[3]);
374: printk("DMACMD: 0x%02x; DMASTC: 0x%04lx; DMASPA: 0x%04lx\n", dmacmd, dmastc, dmaspa);
375: printk("DMAWBC: 0x%04lx; DMAWAC: 0x%04lx; DMASTATUS: 0x%02x\n", dmawbc, dmawac, dmastatus);
376: printk("---------------------------------------------------------\n");
377: }
378:
379: /**************************************************************************
380: * Function : void AM53C974_keywait(void)
381: *
382: * Purpose : wait until a key is pressed, if it was the 'r' key leave singlestep mode;
383: * this function is used for debugging only
384: *
385: * Input : none
386: **************************************************************************/
387: static void AM53C974_keywait(void)
388: {
389: #ifdef AM53C974_DEBUG
390: int key;
391:
392: if (!deb_stop) return;
393: #endif
394:
395: cli();
396: while ((inb_p(0x64) & 0x01) != 0x01) ;
397: #ifdef AM53C974_DEBUG
398: key = inb(0x60);
399: if (key == 0x93) deb_stop = 0; /* don't stop if 'r' was pressed */
400: #endif
401: sti();
402: }
403:
404: /**************************************************************************
405: * Function : AM53C974_setup(char *str, int *ints)
406: *
407: * Purpose : LILO command line initialization of the overrides array,
408: *
409: * Inputs : str - unused, ints - array of integer parameters with ints[0]
410: * equal to the number of ints.
411: *
412: * NOTE : this function needs to be declared as an external function
413: * in init/main.c and included there in the bootsetups list
414: ***************************************************************************/
415: void AM53C974_setup(char *str, int *ints)
416: {
417: if (ints[0] < 4)
418: printk("AM53C974_setup: wrong number of parameters;\n correct syntax is: AM53C974=host-scsi-id, target-scsi-id, max-rate, max-offset\n");
419: else {
420: if (commandline_current < (sizeof(overrides) / sizeof(override_t))) {
421: if ((ints[1] < 0) || (ints[1] > 7) ||
422: (ints[2] < 0) || (ints[2] > 7) ||
423: (ints[1] == ints[2]) ||
424: (ints[3] < (DEF_CLK / MAX_PERIOD)) || (ints[3] > (DEF_CLK / MIN_PERIOD)) ||
425: (ints[4] < 0) || (ints[4] > MAX_OFFSET))
426: printk("AM53C974_setup: illegal parameter\n");
427: else {
428: overrides[commandline_current].host_scsi_id = ints[1];
429: overrides[commandline_current].target_scsi_id = ints[2];
430: overrides[commandline_current].max_rate = ints[3];
431: overrides[commandline_current].max_offset = ints[4];
432: commandline_current++; }
433: }
434: else
435: printk("AM53C974_setup: too many overrides\n");
436: }
437: }
438:
439: #if defined (CONFIG_PCI)
440: /**************************************************************************
441: * Function : int AM53C974_bios_detect(Scsi_Host_Template *tpnt)
442: *
443: * Purpose : detects and initializes AM53C974 SCSI chips with PCI Bios
444: *
445: * Inputs : tpnt - host template
446: *
447: * Returns : number of host adapters detected
448: **************************************************************************/
449: int AM53C974_bios_detect(Scsi_Host_Template *tpnt)
450: {
451: int count = 0; /* number of boards detected */
452: int pci_index;
453: pci_config_t pci_config;
454:
455: for (pci_index = 0; pci_index <= 16; ++pci_index) {
456: unsigned char pci_bus, pci_device_fn;
457: if (pcibios_find_device(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_SCSI, pci_index, &pci_bus, &pci_device_fn) != 0)
458: break;
459:
460: pcibios_read_config_word(pci_bus, pci_device_fn, PCI_VENDOR_ID, &pci_config._vendor);
461: pcibios_read_config_word(pci_bus, pci_device_fn, PCI_DEVICE_ID, &pci_config._device);
462: pcibios_read_config_word(pci_bus, pci_device_fn, PCI_COMMAND, &pci_config._command);
463: pcibios_read_config_word(pci_bus, pci_device_fn, PCI_STATUS, &pci_config._status);
464: pcibios_read_config_dword(pci_bus, pci_device_fn, PCI_CLASS_REVISION, &pci_config._class_revision);
465: pcibios_read_config_byte(pci_bus, pci_device_fn, PCI_CACHE_LINE_SIZE, &pci_config._cache_line_size);
466: pcibios_read_config_byte(pci_bus, pci_device_fn, PCI_LATENCY_TIMER, &pci_config._latency_timer);
467: pcibios_read_config_byte(pci_bus, pci_device_fn, PCI_HEADER_TYPE, &pci_config._header_type);
468: pcibios_read_config_byte(pci_bus, pci_device_fn, PCI_BIST, &pci_config._bist);
469: pcibios_read_config_dword(pci_bus, pci_device_fn, PCI_BASE_ADDRESS_0, &pci_config._base0);
470: pcibios_read_config_dword(pci_bus, pci_device_fn, PCI_BASE_ADDRESS_1, &pci_config._base1);
471: pcibios_read_config_dword(pci_bus, pci_device_fn, PCI_BASE_ADDRESS_2, &pci_config._base2);
472: pcibios_read_config_dword(pci_bus, pci_device_fn, PCI_BASE_ADDRESS_3, &pci_config._base3);
473: pcibios_read_config_dword(pci_bus, pci_device_fn, PCI_BASE_ADDRESS_4, &pci_config._base4);
474: pcibios_read_config_dword(pci_bus, pci_device_fn, PCI_BASE_ADDRESS_5, &pci_config._base5);
475: pcibios_read_config_dword(pci_bus, pci_device_fn, PCI_ROM_ADDRESS, &pci_config._baserom);
476: pcibios_read_config_byte(pci_bus, pci_device_fn, PCI_INTERRUPT_LINE, &pci_config._int_line);
477: pcibios_read_config_byte(pci_bus, pci_device_fn, PCI_INTERRUPT_PIN, &pci_config._int_pin);
478: pcibios_read_config_byte(pci_bus, pci_device_fn, PCI_MIN_GNT, &pci_config._min_gnt);
479: pcibios_read_config_byte(pci_bus, pci_device_fn, PCI_MAX_LAT, &pci_config._max_lat);
480: pci_config._pcibus = 0xFFFFFFFF;
481: pci_config._cardnum = 0xFFFFFFFF;
482:
483: /* check whether device is I/O mapped -- should be */
484: if (!(pci_config._command & PCI_COMMAND_IO)) continue;
485:
486: /* PCI Spec 2.1 states that it is either the driver's or the PCI card's responsibility
487: to set the PCI Master Enable Bit if needed.
488: (from Mark Stockton <[email protected]>) */
489: if (!(pci_config._command & PCI_COMMAND_MASTER)) {
490: pci_config._command |= PCI_COMMAND_MASTER;
491: printk("PCI Master Bit has not been set. Setting...\n");
492: pcibios_write_config_word(pci_bus, pci_device_fn, PCI_COMMAND, pci_config._command); }
493:
494: /* everything seems OK now, so initialize */
495: if (AM53C974_init(tpnt, pci_config)) count++ ;
496: }
497: return (count);
498: }
499: #endif
500:
501: /**************************************************************************
502: * Function : int AM53C974_nobios_detect(Scsi_Host_Template *tpnt)
503: *
504: * Purpose : detects and initializes AM53C974 SCSI chips using PCI config 2
505: *
506: * Inputs : tpnt - host template
507: *
508: * Returns : number of host adapters detected
509: *
510: * NOTE : This code assumes the controller on PCI bus 0.
511: *
512: * Origin: Robin Cutshaw ([email protected])
513: **************************************************************************/
514: int AM53C974_nobios_detect(Scsi_Host_Template *tpnt)
515: {
516: int count = 0; /* number of boards detected */
517: pci_config_t pci_config;
518:
519: /* first try PCI config method 1 */
520: for (pci_config._pcibus = 0; pci_config._pcibus < 0x10; pci_config._pcibus++) {
521: for (pci_config._cardnum = 0; pci_config._cardnum < 0x20; pci_config._cardnum++) {
522: unsigned long config_cmd;
523: config_cmd = 0x80000000 | (pci_config._pcibus<<16) | (pci_config._cardnum<<11);
524:
525: outl(config_cmd, 0xCF8); /* ioreg 0 */
526: pci_config._device_vendor = inl(0xCFC);
527:
528: if ((pci_config._vendor == PCI_VENDOR_ID_AMD) && (pci_config._device == PCI_DEVICE_ID_AMD_SCSI)) {
529: outl(config_cmd | PCI_COMMAND, 0xCF8); pci_config._status_command = inl(0xCFC);
530: outl(config_cmd | PCI_CLASS_REVISION, 0xCF8); pci_config._class_revision = inl(0xCFC);
531: outl(config_cmd | PCI_CACHE_LINE_SIZE, 0xCF8); pci_config._bist_header_latency_cache = inl(0xCFC);
532: outl(config_cmd | PCI_BASE_ADDRESS_0, 0xCF8); pci_config._base0 = inl(0xCFC);
533: outl(config_cmd | PCI_BASE_ADDRESS_1, 0xCF8); pci_config._base1 = inl(0xCFC);
534: outl(config_cmd | PCI_BASE_ADDRESS_2, 0xCF8); pci_config._base2 = inl(0xCFC);
535: outl(config_cmd | PCI_BASE_ADDRESS_3, 0xCF8); pci_config._base3 = inl(0xCFC);
536: outl(config_cmd | PCI_BASE_ADDRESS_4, 0xCF8); pci_config._base4 = inl(0xCFC);
537: outl(config_cmd | PCI_BASE_ADDRESS_5, 0xCF8); pci_config._base5 = inl(0xCFC);
538: outl(config_cmd | PCI_ROM_ADDRESS, 0xCF8); pci_config._baserom = inl(0xCFC);
539: outl(config_cmd | PCI_INTERRUPT_LINE, 0xCF8); pci_config._max_min_ipin_iline = inl(0xCFC);
540:
541: /* check whether device is I/O mapped -- should be */
542: if (!(pci_config._command & PCI_COMMAND_IO)) continue;
543:
544: /* PCI Spec 2.1 states that it is either the driver's or the PCI card's responsibility
545: to set the PCI Master Enable Bit if needed.
546: From Mark Stockton <[email protected]> */
547: if (!(pci_config._command & PCI_COMMAND_MASTER)) {
548: pci_config._command |= PCI_COMMAND_MASTER;
549: printk("Config 1; PCI Master Bit has not been set. Setting...\n");
550: outl(config_cmd | PCI_COMMAND, 0xCF8); outw(pci_config._command, 0xCFC); }
551:
552: /* everything seems OK now, so initialize */
553: if (AM53C974_init(tpnt, pci_config)) count++ ;
554: }
555: }
556: }
557: outb(0, 0xCF8); /* is this really necessary? */
558:
559: /* try PCI config method 2, if no device was detected by method 1 */
560: if (!count) {
561: AM53C974_PCIREG_OPEN();
562:
563: pci_config._pcibus = 0xFFFFFFFF;
564: pci_config._cardnum = 0xFFFFFFFF;
565:
566: for (pci_config._ioaddr = 0xC000; pci_config._ioaddr < 0xD000; pci_config._ioaddr += 0x0100) {
567: pci_config._device_vendor = inl(pci_config._ioaddr);
568:
569: if ((pci_config._vendor == PCI_VENDOR_ID_AMD) && (pci_config._device == PCI_DEVICE_ID_AMD_SCSI)) {
570: pci_config._status_command = inl(pci_config._ioaddr + PCI_COMMAND);
571: pci_config._class_revision = inl(pci_config._ioaddr + PCI_CLASS_REVISION);
572: pci_config._bist_header_latency_cache = inl(pci_config._ioaddr + PCI_CACHE_LINE_SIZE);
573: pci_config._base0 = inl(pci_config._ioaddr + PCI_BASE_ADDRESS_0);
574: pci_config._base1 = inl(pci_config._ioaddr + PCI_BASE_ADDRESS_1);
575: pci_config._base2 = inl(pci_config._ioaddr + PCI_BASE_ADDRESS_2);
576: pci_config._base3 = inl(pci_config._ioaddr + PCI_BASE_ADDRESS_3);
577: pci_config._base4 = inl(pci_config._ioaddr + PCI_BASE_ADDRESS_4);
578: pci_config._base5 = inl(pci_config._ioaddr + PCI_BASE_ADDRESS_5);
579: pci_config._baserom = inl(pci_config._ioaddr + PCI_ROM_ADDRESS);
580: pci_config._max_min_ipin_iline = inl(pci_config._ioaddr + PCI_INTERRUPT_LINE);
581:
582: /* check whether device is I/O mapped -- should be */
583: if (!(pci_config._command & PCI_COMMAND_IO)) continue;
584:
585: /* PCI Spec 2.1 states that it is either the driver's or the PCI card's responsibility
586: to set the PCI Master Enable Bit if needed.
587: From Mark Stockton <[email protected]> */
588: if (!(pci_config._command & PCI_COMMAND_MASTER)) {
589: pci_config._command |= PCI_COMMAND_MASTER;
590: printk("Config 2; PCI Master Bit has not been set. Setting...\n");
591: outw(pci_config._command, pci_config._ioaddr + PCI_COMMAND); }
592:
593: /* everything seems OK now, so initialize */
594: if (AM53C974_init(tpnt, pci_config)) count++ ;
595: }
596: }
597: AM53C974_PCIREG_CLOSE();
598: }
599:
600: return(count);
601: }
602:
603: /**************************************************************************
604: * Function : int AM53C974_detect(Scsi_Host_Template *tpnt)
605: *
606: * Purpose : detects and initializes AM53C974 SCSI chips
607: *
608: * Inputs : tpnt - host template
609: *
610: * Returns : number of host adapters detected
611: **************************************************************************/
612: int AM53C974_detect(Scsi_Host_Template *tpnt)
613: {
614: int count; /* number of boards detected */
615:
616: tpnt->proc_dir = &proc_scsi_am53c974;
617:
618: #if defined (CONFIG_PCI)
619: if (pcibios_present())
620: count = AM53C974_bios_detect(tpnt);
621: else
622: #endif
623: count = AM53C974_nobios_detect(tpnt);
624: return (count);
625: }
626:
627: /**************************************************************************
628: * Function : int AM53C974_init(Scsi_Host_Template *tpnt, pci_config_t pci_config)
629: *
630: * Purpose : initializes instance and corresponding AM53/79C974 chip,
631: *
632: * Inputs : tpnt - template, pci_config - PCI configuration,
633: *
634: * Returns : 1 on success, 0 on failure.
635: *
636: * NOTE: If no override for the controller's SCSI id is given and AM53C974_SCSI_ID
637: * is not defined we assume that the SCSI address of this controller is correctly
638: * set up by the BIOS (as reflected by contents of register CNTLREG1).
639: * This is the only BIOS assistance we need.
640: **************************************************************************/
641: static int AM53C974_init(Scsi_Host_Template *tpnt, pci_config_t pci_config)
642: {
643: AM53C974_local_declare();
644: int i, j;
645: struct Scsi_Host *instance, *search;
646: struct AM53C974_hostdata *hostdata;
647:
648: #ifdef AM53C974_OPTION_DEBUG_PROBE_ONLY
649: printk ("AM53C974: probe only enabled, aborting initialization\n");
650: return 0;
651: #endif
652:
653: instance = scsi_register(tpnt, sizeof(struct AM53C974_hostdata));
654: hostdata = (struct AM53C974_hostdata *)instance->hostdata;
655: instance->base = NULL;
656: instance->io_port = pci_config._base0 & (pci_config._base0 & 0x1 ?
657: 0xFFFFFFFC : 0xFFFFFFF0);
658: instance->irq = pci_config._int_line;
659: instance->dma_channel = -1;
660: AM53C974_setio(instance);
661:
662: #ifdef AM53C974_SCSI_ID
663: instance->this_id = AM53C974_SCSI_ID;
664: AM53C974_write_8(CNTLREG1, instance->this_id & CNTLREG1_SID);
665: #else
666: instance->this_id = AM53C974_read_8(CNTLREG1) & CNTLREG1_SID;
667: if (instance->this_id != 7)
668: printk("scsi%d: WARNING: unusual hostadapter SCSI id %d; please verify!\n",
669: instance->host_no, instance->this_id);
670: #endif
671:
672: for (i = 0; i < sizeof(hostdata->msgout); i++) {
673: hostdata->msgout[i] = NOP;
674: hostdata->last_message[i] = NOP; }
675: for (i = 0; i < 8; i++) {
676: hostdata->busy[i] = 0;
677: hostdata->sync_per[i] = DEF_STP;
678: hostdata->sync_off[i] = 0;
679: hostdata->sync_neg[i] = 0;
680: hostdata->sync_en[i] = DEFAULT_SYNC_NEGOTIATION_ENABLED;
681: hostdata->max_rate[i] = DEFAULT_RATE;
682: hostdata->max_offset[i] = DEFAULT_SYNC_OFFSET; }
683:
684: /* overwrite defaults by LILO overrides */
685: for (i = 0; i < commandline_current; i++) {
686: if (overrides[i].host_scsi_id == instance->this_id) {
687: j = overrides[i].target_scsi_id;
688: hostdata->sync_en[j] = 1;
689: hostdata->max_rate[j] = overrides[i].max_rate;
690: hostdata->max_offset[j] = overrides[i].max_offset;
691: }
692: }
693:
694: hostdata->sel_cmd = NULL;
695: hostdata->connected = NULL;
696: hostdata->issue_queue = NULL;
697: hostdata->disconnected_queue = NULL;
698: hostdata->in_reset = 0;
699: hostdata->aborted = 0;
700: hostdata->selecting = 0;
701: hostdata->disconnecting = 0;
702: hostdata->dma_busy = 0;
703:
704: /* Set up an interrupt handler if we aren't already sharing an IRQ with another board */
705: for (search = first_host;
706: search && ( ((the_template != NULL) && (search->hostt != the_template)) ||
707: (search->irq != instance->irq) || (search == instance) );
708: search = search->next);
709: if (!search) {
710: if (request_irq(instance->irq, AM53C974_intr, SA_INTERRUPT, "AM53C974", NULL)) {
711: printk("scsi%d: IRQ%d not free, detaching\n", instance->host_no, instance->irq);
712: scsi_unregister(instance);
713: return 0; }
714: }
715: else {
716: printk("scsi%d: using interrupt handler previously installed for scsi%d\n",
717: instance->host_no, search->host_no); }
718:
719: if (!the_template) {
720: the_template = instance->hostt;
721: first_instance = instance; }
722:
723: /* do hard reset */
724: AM53C974_write_8(CMDREG, CMDREG_RDEV); /* reset device */
725: udelay(5);
726: AM53C974_write_8(CMDREG, CMDREG_NOP);
727: AM53C974_write_8(CNTLREG1, CNTLREG1_DISR | instance->this_id);
728: AM53C974_write_8(CMDREG, CMDREG_RBUS); /* reset SCSI bus */
729: udelay(10);
730: AM53C974_config_after_reset(instance);
731: udelay(500000);
732: return(1);
733: }
734:
735: /*********************************************************************
736: * Function : AM53C974_config_after_reset(struct Scsi_Host *instance) *
737: * *
738: * Purpose : initializes chip registers after reset *
739: * *
740: * Inputs : instance - which AM53C974 *
741: * *
742: * Returns : nothing *
743: **********************************************************************/
744: static void AM53C974_config_after_reset(struct Scsi_Host *instance)
745: {
746: AM53C974_local_declare();
747: AM53C974_setio(instance);
748:
749: /* clear SCSI FIFO */
750: AM53C974_write_8(CMDREG, CMDREG_CFIFO);
751:
752: /* configure device */
753: AM53C974_write_8(STIMREG, DEF_SCSI_TIMEOUT);
754: AM53C974_write_8(STPREG, DEF_STP & STPREG_STP);
755: AM53C974_write_8(SOFREG, (DEF_SOF_RAD<<6) | (DEF_SOF_RAA<<4));
756: AM53C974_write_8(CLKFREG, DEF_CLKF & CLKFREG_MASK);
757: AM53C974_write_8(CNTLREG1, (DEF_ETM<<7) | CNTLREG1_DISR | (DEF_PERE<<4) | instance->this_id);
758: AM53C974_write_8(CNTLREG2, (DEF_ENF<<6));
759: AM53C974_write_8(CNTLREG3, (DEF_ADIDCHK<<7) | (DEF_FASTSCSI<<4) | (DEF_FASTCLK<<3));
760: AM53C974_write_8(CNTLREG4, (DEF_GLITCH<<6) | (DEF_PWD<<5) | (DEF_RAE<<3) | (DEF_RADE<<2) | CNTLREG4_RES);
761: }
762:
763: /***********************************************************************
764: * Function : const char *AM53C974_info(struct Scsi_Host *instance) *
765: * *
766: * Purpose : return device driver information *
767: * *
768: * Inputs : instance - which AM53C974 *
769: * *
770: * Returns : info string *
771: ************************************************************************/
772: const char *AM53C974_info(struct Scsi_Host *instance)
773: {
774: static char info[100];
775:
776: sprintf(info, "AM53/79C974 PCscsi driver rev. %d.%d; host I/O address: 0x%x; irq: %d\n",
777: AM53C974_DRIVER_REVISION_MAJOR, AM53C974_DRIVER_REVISION_MINOR,
778: instance->io_port, instance->irq);
779: return (info);
780: }
781:
782: /**************************************************************************
783: * Function : int AM53C974_command (Scsi_Cmnd *SCpnt) *
784: * *
785: * Purpose : the unqueued SCSI command function, replaced by the *
786: * AM53C974_queue_command function *
787: * *
788: * Inputs : SCpnt - pointer to command structure *
789: * *
790: * Returns :status, see hosts.h for details *
791: ***************************************************************************/
792: int AM53C974_command(Scsi_Cmnd *SCpnt)
793: {
794: DEB(printk("AM53C974_command called\n"));
795: return 0;
796: }
797:
798: /**************************************************************************
799: * Function : void initialize_SCp(Scsi_Cmnd *cmd) *
800: * *
801: * Purpose : initialize the saved data pointers for cmd to point to the *
802: * start of the buffer. *
803: * *
804: * Inputs : cmd - Scsi_Cmnd structure to have pointers reset. *
805: * *
806: * Returns : nothing *
807: **************************************************************************/
808: static __inline__ void initialize_SCp(Scsi_Cmnd *cmd)
809: {
810: if (cmd->use_sg) {
811: cmd->SCp.buffer = (struct scatterlist *)cmd->buffer;
812: cmd->SCp.buffers_residual = cmd->use_sg - 1;
813: cmd->SCp.ptr = (char *)cmd->SCp.buffer->address;
814: cmd->SCp.this_residual = cmd->SCp.buffer->length; }
815: else {
816: cmd->SCp.buffer = NULL;
817: cmd->SCp.buffers_residual = 0;
818: cmd->SCp.ptr = (char *)cmd->request_buffer;
819: cmd->SCp.this_residual = cmd->request_bufflen; }
820: }
821:
822: /**************************************************************************
823: * Function : run_main(void) *
824: * *
825: * Purpose : insure that the coroutine is running and will process our *
826: * request. main_running is checked/set here (in an inline *
827: * function rather than in AM53C974_main itself to reduce the *
828: * chances of stack overflow. *
829: * *
830: * *
831: * Inputs : none *
832: * *
833: * Returns : nothing *
834: **************************************************************************/
835: static __inline__ void run_main(void)
836: {
837: cli();
838: if (!main_running) {
839: /* main_running is cleared in AM53C974_main once it can't do
840: more work, and AM53C974_main exits with interrupts disabled. */
841: main_running = 1;
842: AM53C974_main();
843: sti(); }
844: else
845: sti();
846: }
847:
848: /**************************************************************************
849: * Function : int AM53C974_queue_command(Scsi_Cmnd *cmd, void (*done)(Scsi_Cmnd *))
850: *
851: * Purpose : writes SCSI command into AM53C974 FIFO
852: *
853: * Inputs : cmd - SCSI command, done - function called on completion, with
854: * a pointer to the command descriptor.
855: *
856: * Returns : status, see hosts.h for details
857: *
858: * Side effects :
859: * cmd is added to the per instance issue_queue, with minor
860: * twiddling done to the host specific fields of cmd. If the
861: * main coroutine is not running, it is restarted.
862: **************************************************************************/
863: int AM53C974_queue_command(Scsi_Cmnd *cmd, void (*done)(Scsi_Cmnd *))
864: {
865: struct Scsi_Host *instance = cmd->host;
866: struct AM53C974_hostdata *hostdata = (struct AM53C974_hostdata *)instance->hostdata;
867: Scsi_Cmnd *tmp;
868:
869: cli();
870: DEB_QUEUE(printk(SEPARATOR_LINE));
871: DEB_QUEUE(printk("scsi%d: AM53C974_queue_command called\n", instance->host_no));
872: DEB_QUEUE(printk("cmd=%02x target=%02x lun=%02x bufflen=%d use_sg = %02x\n",
873: cmd->cmnd[0], cmd->target, cmd->lun, cmd->request_bufflen, cmd->use_sg));
874:
875: /* We use the host_scribble field as a pointer to the next command in a queue */
876: cmd->host_scribble = NULL;
877: cmd->scsi_done = done;
878: cmd->result = 0;
879: cmd->device->disconnect = 0;
880:
881: /* Insert the cmd into the issue queue. Note that REQUEST SENSE
882: * commands are added to the head of the queue since any command will
883: * clear the contingent allegiance condition that exists and the
884: * sense data is only guaranteed to be valid while the condition exists. */
885: if (!(hostdata->issue_queue) || (cmd->cmnd[0] == REQUEST_SENSE)) {
886: LIST(cmd, hostdata->issue_queue);
887: cmd->host_scribble = (unsigned char *)hostdata->issue_queue;
888: hostdata->issue_queue = cmd; }
889: else {
890: for (tmp = (Scsi_Cmnd *)hostdata->issue_queue; tmp->host_scribble;
891: tmp = (Scsi_Cmnd *)tmp->host_scribble);
892: LIST(cmd, tmp);
893: tmp->host_scribble = (unsigned char *)cmd; }
894:
895: DEB_QUEUE(printk("scsi%d : command added to %s of queue\n", instance->host_no,
896: (cmd->cmnd[0] == REQUEST_SENSE) ? "head" : "tail"));
897:
898: /* Run the coroutine if it isn't already running. */
899: run_main();
900: return 0;
901: }
902:
903: /**************************************************************************
904: * Function : AM53C974_main (void)
905: *
906: * Purpose : AM53C974_main is a coroutine that runs as long as more work can
907: * be done on the AM53C974 host adapters in a system. Both
908: * AM53C974_queue_command() and AM53C974_intr() will try to start it
909: * in case it is not running.
910: *
911: * NOTE : AM53C974_main exits with interrupts *disabled*, the caller should
912: * reenable them. This prevents reentrancy and kernel stack overflow.
913: **************************************************************************/
914: static void AM53C974_main(void)
915: {
916: AM53C974_local_declare();
917: Scsi_Cmnd *tmp, *prev;
918: struct Scsi_Host *instance;
919: struct AM53C974_hostdata *hostdata;
920: int done;
921:
922: /* We run (with interrupts disabled) until we're sure that none of
923: * the host adapters have anything that can be done, at which point
924: * we set main_running to 0 and exit. */
925:
926: do {
927: cli(); /* Freeze request queues */
928: done = 1;
929: for (instance = first_instance; instance && instance->hostt == the_template;
930: instance = instance->next) {
931: hostdata = (struct AM53C974_hostdata *)instance->hostdata;
932: AM53C974_setio(instance);
933: /* start to select target if we are not connected and not in the
934: selection process */
935: if (!hostdata->connected && !hostdata->sel_cmd) {
936: /* Search through the issue_queue for a command destined for a target
937: that is not busy. */
938: for (tmp = (Scsi_Cmnd *)hostdata->issue_queue, prev = NULL; tmp;
939: prev = tmp, tmp = (Scsi_Cmnd *)tmp->host_scribble) {
940: /* When we find one, remove it from the issue queue. */
941: if (!(hostdata->busy[tmp->target] & (1 << tmp->lun))) {
942: if (prev) {
943: REMOVE(prev, (Scsi_Cmnd *)(prev->host_scribble), tmp,
944: (Scsi_Cmnd *)(tmp->host_scribble));
945: prev->host_scribble = tmp->host_scribble; }
946: else {
947: REMOVE(-1, hostdata->issue_queue, tmp, tmp->host_scribble);
948: hostdata->issue_queue = (Scsi_Cmnd *)tmp->host_scribble; }
949: tmp->host_scribble = NULL;
950:
951: /* go into selection mode, disable reselection and wait for
952: SO interrupt which will continue with the selection process */
953: hostdata->selecting = 1;
954: hostdata->sel_cmd = tmp;
955: AM53C974_write_8(CMDREG, CMDREG_DSR);
956: break;
957: } /* if target/lun is not busy */
958:
959: } /* for */
960: } /* if (!hostdata->connected) */
961: else {
962: DEB(printk("main: connected; cmd = 0x%lx, sel_cmd = 0x%lx\n",
963: (long)hostdata->connected, (long)hostdata->sel_cmd));
964: }
965: } /* for instance */
966: } while (!done);
967: main_running = 0;
968: }
969:
970: /************************************************************************
971: * Function : AM53C974_intr(int irq, void *dev_id, struct pt_regs *regs) *
972: * *
973: * Purpose : interrupt handler *
974: * *
975: * Inputs : irq - interrupt line, regs - ? *
976: * *
977: * Returns : nothing *
978: ************************************************************************/
979: static void AM53C974_intr(int irq, void *dev_id, struct pt_regs *regs)
980: {
981: AM53C974_local_declare();
982: struct Scsi_Host *instance;
983: struct AM53C974_hostdata *hostdata;
984: unsigned char cmdreg, dmastatus, statreg, isreg, instreg, cfifo;
985:
986: /* find AM53C974 hostadapter responsible for this interrupt */
987: for (instance = first_instance; instance; instance = instance->next)
988: if ((instance->irq == irq) && (instance->hostt == the_template)) goto FOUND;
989: sti();
990: return;
991:
992: /* found; now decode and process */
993: FOUND:
994: hostdata = (struct AM53C974_hostdata *)instance->hostdata;
995: AM53C974_setio(instance);
996: dmastatus = AM53C974_read_8(DMASTATUS);
997:
998: DEB_INTR(printk(SEPARATOR_LINE));
999: DEB_INTR(printk("AM53C974 interrupt; dmastatus=0x%02x\n", dmastatus));
1000: KEYWAIT();
1001:
1002: /*** DMA related interrupts ***/
1003: if (hostdata->connected && (dmastatus & (DMASTATUS_ERROR | DMASTATUS_PWDN |
1004: DMASTATUS_ABORT))) {
1005: /* DMA error or POWERDOWN */
1006: printk("scsi%d: DMA error or powerdown; dmastatus: 0x%02x\n",
1007: instance->host_no, dmastatus);
1008: #ifdef AM53C974_DEBUG
1009: deb_stop = 1;
1010: #endif
1011: panic("scsi%d: cannot recover\n", instance->host_no); }
1012:
1013: if (hostdata->connected && (dmastatus & DMASTATUS_DONE)) {
1014: /* DMA transfer done */
1015: unsigned long residual;
1016: cli();
1017: if (!(AM53C974_read_8(DMACMD) & DMACMD_DIR)) {
1018: do {
1019: dmastatus = AM53C974_read_8(DMASTATUS);
1020: residual = AM53C974_read_8(CTCLREG) | (AM53C974_read_8(CTCMREG) << 8) |
1021: (AM53C974_read_8(CTCHREG) << 16);
1022: residual += AM53C974_read_8(CFIREG) & CFIREG_CF;
1023: } while (!(dmastatus & DMASTATUS_SCSIINT) && residual);
1024: residual = AM53C974_read_8(CTCLREG) | (AM53C974_read_8(CTCMREG) << 8) |
1025: (AM53C974_read_8(CTCHREG) << 16);
1026: residual += AM53C974_read_8(CFIREG) & CFIREG_CF;
1027: }
1028: else
1029: residual = 0;
1030: hostdata->connected->SCp.ptr += hostdata->connected->SCp.this_residual - residual;
1031: hostdata->connected->SCp.this_residual = residual;
1032:
1033: AM53C974_write_8(DMACMD, DMACMD_IDLE);
1034:
1035: /* if service request missed before, process it now (ugly) */
1036: if (hostdata->dma_busy) {
1037: hostdata->dma_busy = 0;
1038: cmdreg = AM53C974_read_8(CMDREG);
1039: statreg = AM53C974_read_8(STATREG);
1040: isreg = AM53C974_read_8(ISREG);
1041: instreg = AM53C974_read_8(INSTREG);
1042: cfifo = AM53C974_cfifo();
1043: AM53C974_information_transfer(instance, statreg, isreg, instreg, cfifo,
1044: dmastatus); }
1045: sti();
1046: }
1047:
1048: if (!(dmastatus & DMASTATUS_SCSIINT)) {
1049: sti();
1050: return; }
1051:
1052: /*** SCSI related interrupts ***/
1053: cmdreg = AM53C974_read_8(CMDREG);
1054: statreg = AM53C974_read_8(STATREG);
1055: isreg = AM53C974_read_8(ISREG);
1056: instreg = AM53C974_read_8(INSTREG);
1057: cfifo = AM53C974_cfifo();
1058:
1059: DEB_INTR(printk("scsi%d: statreg: 0x%02x; isreg: 0x%02x; instreg: 0x%02x; cfifo: 0x%02x\n",
1060: instance->host_no, statreg, isreg, instreg, cfifo));
1061:
1062: if (statreg & STATREG_PE) {
1063: /* parity error */
1064: #ifdef AM53C974_DEBUG
1065: deb_stop = 1;
1066: #endif
1067: printk("scsi%d : PARITY error\n", instance->host_no);
1068: if (hostdata->connected) hostdata->sync_off[hostdata->connected->target] = 0; /* setup asynchronous transfer */
1069: hostdata->aborted = 1; }
1070:
1071: if (statreg & STATREG_IOE) {
1072: /* illegal operation error */
1073: #ifdef AM53C974_DEBUG
1074: deb_stop = 1;
1075: #endif
1076: printk("scsi%d : ILLEGAL OPERATION error\n", instance->host_no);
1077: printk("cmdreg: 0x%02x; dmacmd: 0x%02x; statreg: 0x%02x; \n"
1078: "isreg: 0x%02x; instreg: 0x%02x; cfifo: 0x%02x\n",
1079: cmdreg, AM53C974_read_8(DMACMD), statreg, isreg, instreg, cfifo); }
1080: if (hostdata->in_reset && (instreg & INSTREG_SRST)) {
1081: /* RESET INTERRUPT */
1082: #ifdef AM53C974_DEBUG
1083: deb_stop = 1;
1084: #endif
1085: DEB(printk("Bus reset interrupt received\n"));
1086: AM53C974_intr_bus_reset(instance);
1087: cli();
1088: if (hostdata->connected) {
1089: hostdata->connected->result = DID_RESET << 16;
1090: hostdata->connected->scsi_done((Scsi_Cmnd *)hostdata->connected);
1091: hostdata->connected = NULL; }
1092: else {
1093: if (hostdata->sel_cmd) {
1094: hostdata->sel_cmd->result = DID_RESET << 16;
1095: hostdata->sel_cmd->scsi_done((Scsi_Cmnd *)hostdata->sel_cmd);
1096: hostdata->sel_cmd = NULL; }
1097: }
1098: sti();
1099: if (hostdata->in_reset == 1) goto EXIT;
1100: else return;
1101: }
1102:
1103: if (instreg & INSTREG_ICMD) {
1104: /* INVALID COMMAND INTERRUPT */
1105: #ifdef AM53C974_DEBUG
1106: deb_stop = 1;
1107: #endif
1108: printk("scsi%d: Invalid command interrupt\n", instance->host_no);
1109: printk("cmdreg: 0x%02x; dmacmd: 0x%02x; statreg: 0x%02x; dmastatus: 0x%02x; \n"
1110: "isreg: 0x%02x; instreg: 0x%02x; cfifo: 0x%02x\n",
1111: cmdreg, AM53C974_read_8(DMACMD), statreg, dmastatus, isreg, instreg, cfifo);
1112: panic("scsi%d: cannot recover\n", instance->host_no); }
1113:
1114: if (instreg & INSTREG_DIS) {
1115: /* DISCONNECT INTERRUPT */
1116: DEB_INTR(printk("Disconnect interrupt received; "));
1117: cli();
1118: AM53C974_intr_disconnect(instance);
1119: sti();
1120: goto EXIT; }
1121:
1122: if (instreg & INSTREG_RESEL) {
1123: /* RESELECTION INTERRUPT */
1124: DEB_INTR(printk("Reselection interrupt received\n"));
1125: cli();
1126: AM53C974_intr_reselect(instance, statreg);
1127: sti();
1128: goto EXIT; }
1129:
1130: if (instreg & INSTREG_SO) {
1131: DEB_INTR(printk("Successful operation interrupt received\n"));
1132: if (hostdata->selecting) {
1133: DEB_INTR(printk("DSR completed, starting select\n"));
1134: cli();
1135: AM53C974_select(instance, (Scsi_Cmnd *)hostdata->sel_cmd,
1136: (hostdata->sel_cmd->cmnd[0] == REQUEST_SENSE) ?
1137: TAG_NONE : TAG_NEXT);
1138: hostdata->selecting = 0;
1139: AM53C974_set_sync(instance, hostdata->sel_cmd->target);
1140: sti();
1141: return; }
1142:
1143: if (hostdata->sel_cmd != NULL) {
1144: if ( ((isreg & ISREG_IS) != ISREG_OK_NO_STOP) &&
1145: ((isreg & ISREG_IS) != ISREG_OK_STOP) ) {
1146: /* UNSUCCESSFUL SELECTION */
1147: DEB_INTR(printk("unsuccessful selection\n"));
1148: cli();
1149: hostdata->dma_busy = 0;
1150: LIST(hostdata->sel_cmd, hostdata->issue_queue);
1151: hostdata->sel_cmd->host_scribble = (unsigned char *)hostdata->issue_queue;
1152: hostdata->issue_queue = hostdata->sel_cmd;
1153: hostdata->sel_cmd = NULL;
1154: hostdata->selecting = 0;
1155: sti();
1156: goto EXIT; }
1157: else {
1158: /* SUCCESSFUL SELECTION */
1159: DEB(printk("successful selection; cmd=0x%02lx\n", (long)hostdata->sel_cmd));
1160: cli();
1161: hostdata->dma_busy = 0;
1162: hostdata->disconnecting = 0;
1163: hostdata->connected = hostdata->sel_cmd;
1164: hostdata->sel_cmd = NULL;
1165: hostdata->selecting = 0;
1166: #ifdef SCSI2
1167: if (!hostdata->connected->device->tagged_queue)
1168: #endif
1169: hostdata->busy[hostdata->connected->target] |= (1 << hostdata->connected->lun);
1170: /* very strange -- use_sg is sometimes nonzero for request sense commands !! */
1171: if ((hostdata->connected->cmnd[0] == REQUEST_SENSE) && hostdata->connected->use_sg) {
1172: DEB(printk("scsi%d: REQUEST_SENSE command with nonzero use_sg\n", instance->host_no));
1173: KEYWAIT();
1174: hostdata->connected->use_sg = 0; }
1175: initialize_SCp((Scsi_Cmnd *)hostdata->connected);
1176: hostdata->connected->SCp.phase = PHASE_CMDOUT;
1177: AM53C974_information_transfer(instance, statreg, isreg, instreg, cfifo, dmastatus);
1178: sti();
1179: return; }
1180: }
1181: else {
1182: cli();
1183: AM53C974_information_transfer(instance, statreg, isreg, instreg, cfifo, dmastatus);
1184: sti();
1185: return; }
1186: }
1187:
1188: if (instreg & INSTREG_SR) {
1189: DEB_INTR(printk("Service request interrupt received, "));
1190: if (hostdata->connected) {
1191: DEB_INTR(printk("calling information_transfer\n"));
1192: cli();
1193: AM53C974_information_transfer(instance, statreg, isreg, instreg, cfifo, dmastatus);
1194: sti(); }
1195: else {
1196: printk("scsi%d: weird: service request when no command connected\n", instance->host_no);
1197: AM53C974_write_8(CMDREG, CMDREG_CFIFO); } /* clear FIFO */
1198: return;
1199: }
1200:
1201: EXIT:
1202: DEB_INTR(printk("intr: starting main\n"));
1203: run_main();
1204: DEB_INTR(printk("end of intr\n"));
1205: }
1206:
1207: /**************************************************************************
1208: * Function : AM53C974_intr_disconnect(struct Scsi_Host *instance)
1209: *
1210: * Purpose : manage target disconnection
1211: *
1212: * Inputs : instance -- which AM53C974
1213: *
1214: * Returns : nothing
1215: **************************************************************************/
1216: static void AM53C974_intr_disconnect(struct Scsi_Host *instance)
1217: {
1218: AM53C974_local_declare();
1219: struct AM53C974_hostdata *hostdata = (struct AM53C974_hostdata *)instance->hostdata;
1220: Scsi_Cmnd *cmd;
1221: AM53C974_setio(instance);
1222:
1223: if (hostdata->sel_cmd != NULL) {
1224: /* normal selection timeout, typical for nonexisting targets */
1225: cmd = (Scsi_Cmnd *)hostdata->sel_cmd;
1226: DEB_INTR(printk("bad target\n"));
1227: cmd->result = DID_BAD_TARGET << 16;
1228: goto EXIT_FINISHED; }
1229:
1230: if (!hostdata->connected) {
1231: /* can happen if controller was reset, a device tried to reconnect,
1232: failed and disconnects now */
1233: AM53C974_write_8(CMDREG, CMDREG_CFIFO);
1234: return; }
1235:
1236: if (hostdata->disconnecting) {
1237: /* target sent disconnect message, so we are prepared */
1238: cmd = (Scsi_Cmnd *)hostdata->connected;
1239: AM53C974_set_async(instance, cmd->target);
1240: DEB_INTR(printk("scsi%d : disc. from cmnd %d for ta %d, lun %d\n",
1241: instance->host_no, cmd->cmnd[0], cmd->target, cmd->lun));
1242: if (cmd->device->disconnect) {
1243: /* target wants to reselect later */
1244: DEB_INTR(printk("ok, re-enabling selection\n"));
1245: LIST(cmd,hostdata->disconnected_queue);
1246: cmd->host_scribble = (unsigned char *)hostdata->disconnected_queue;
1247: hostdata->disconnected_queue = cmd;
1248: DEB_QUEUE(printk("scsi%d : command for target %d lun %d this %d was moved from connected to"
1249: " the disconnected_queue\n", instance->host_no, cmd->target,
1250: cmd->lun, hostdata->disconnected_queue->SCp.this_residual));
1251: DEB_QUEUE(AM53C974_print_queues(instance));
1252: goto EXIT_UNFINISHED; }
1253: else {
1254: /* target does not want to reselect later, we are really finished */
1255: #ifdef AM53C974_DEBUG
1256: if (cmd->cmnd[0] == REQUEST_SENSE) {
1257: int i;
1258: printk("Request sense data dump:\n");
1259: for (i = 0; i < cmd->request_bufflen; i++) {
1260: printk("%02x ", *((char *)(cmd->request_buffer) + i));
1261: if (i && !(i % 16)) printk("\n"); }
1262: printk("\n"); }
1263: #endif
1264: goto EXIT_FINISHED; } /* !cmd->device->disconnect */
1265: } /* if (hostdata->disconnecting) */
1266:
1267: /* no disconnect message received; unexpected disconnection */
1268: cmd = (Scsi_Cmnd *)hostdata->connected;
1269: if (cmd) {
1270: #ifdef AM53C974_DEBUG
1271: deb_stop = 1;
1272: #endif
1273: AM53C974_set_async(instance, cmd->target);
1274: printk("scsi%d: Unexpected disconnect; phase: %d; target: %d; this_residual: %d; buffers_residual: %d; message: %d\n",
1275: instance->host_no, cmd->SCp.phase, cmd->target, cmd->SCp.this_residual, cmd->SCp.buffers_residual,
1276: cmd->SCp.Message);
1277: printk("cmdreg: 0x%02x; statreg: 0x%02x; isreg: 0x%02x; cfifo: 0x%02x\n",
1278: AM53C974_read_8(CMDREG), AM53C974_read_8(STATREG), AM53C974_read_8(ISREG),
1279: AM53C974_read_8(CFIREG) & CFIREG_CF);
1280:
1281: if ((hostdata->last_message[0] == EXTENDED_MESSAGE) &&
1282: (hostdata->last_message[2] == EXTENDED_SDTR)) {
1283: /* sync. negotiation was aborted, setup asynchronous transfer with target */
1284: hostdata->sync_off[cmd->target] = 0; }
1285: if (hostdata->aborted || hostdata->msgout[0] == ABORT)
1286: cmd->result = DID_ABORT << 16;
1287: else
1288: cmd->result = DID_ERROR << 16;
1289: goto EXIT_FINISHED; }
1290:
1291: EXIT_FINISHED:
1292: hostdata->aborted = 0;
1293: hostdata->msgout[0] = NOP;
1294: hostdata->sel_cmd = NULL;
1295: hostdata->connected = NULL;
1296: hostdata->selecting = 0;
1297: hostdata->disconnecting = 0;
1298: hostdata->dma_busy = 0;
1299: hostdata->busy[cmd->target] &= ~(1 << cmd->lun);
1300: AM53C974_write_8(CMDREG, CMDREG_CFIFO);
1301: DEB(printk("disconnect; issue_queue: 0x%lx, disconnected_queue: 0x%lx\n",
1302: (long)hostdata->issue_queue, (long)hostdata->disconnected_queue));
1303: cmd->scsi_done(cmd);
1304:
1305: if (!hostdata->selecting) {
1306: AM53C974_set_async(instance, cmd->target);
1307: AM53C974_write_8(CMDREG, CMDREG_ESR); } /* allow reselect */
1308: return;
1309:
1310: EXIT_UNFINISHED:
1311: hostdata->msgout[0] = NOP;
1312: hostdata->sel_cmd = NULL;
1313: hostdata->connected = NULL;
1314: hostdata->aborted = 0;
1315: hostdata->selecting = 0;
1316: hostdata->disconnecting = 0;
1317: hostdata->dma_busy = 0;
1318: DEB(printk("disconnect; issue_queue: 0x%lx, disconnected_queue: 0x%lx\n",
1319: (long)hostdata->issue_queue, (long)hostdata->disconnected_queue));
1320: if (!hostdata->selecting) {
1321: AM53C974_set_async(instance, cmd->target);
1322: AM53C974_write_8(CMDREG, CMDREG_ESR); } /* allow reselect */
1323: return;
1324: }
1325:
1326: /**************************************************************************
1327: * Function : int AM53C974_sync_neg(struct Scsi_Host *instance, int target, unsigned char *msg)
1328: *
1329: * Purpose : setup message string for sync. negotiation
1330: *
1331: * Inputs : instance -- which AM53C974
1332: * target -- which SCSI target to deal with
1333: * msg -- input message string
1334: *
1335: * Returns : 0 if parameters accepted or 1 if not accepted
1336: *
1337: * Side effects: hostdata is changed
1338: *
1339: * Note: we assume here that fastclk is enabled
1340: **************************************************************************/
1341: static int AM53C974_sync_neg(struct Scsi_Host *instance, int target, unsigned char *msg)
1342: {
1343: AM53C974_local_declare();
1344: struct AM53C974_hostdata *hostdata = (struct AM53C974_hostdata *)instance->hostdata;
1345: int period, offset, i, rate, rate_rem;
1346: AM53C974_setio(instance);
1347:
1348: period = (DEF_CLK * msg[3] * 8 + 1000) / 2000;
1349: if (period < MIN_PERIOD) {
1350: period = MIN_PERIOD;
1351: hostdata->msgout[3] = period / 4; }
1352: else
1353: if (period > MAX_PERIOD) {
1354: period = MAX_PERIOD;
1355: hostdata->msgout[3] = period / 4; }
1356: else
1357: hostdata->msgout[3] = msg[3];
1358: offset = msg[4];
1359: if (offset > MAX_OFFSET) offset = MAX_OFFSET;
1360: hostdata->msgout[4] = offset;
1361: hostdata->sync_per[target] = period;
1362: hostdata->sync_off[target] = offset;
1363: for (i = 0; i < 3; i++) hostdata->msgout[i] = msg[i];
1364: if ((hostdata->msgout[3] != msg[3]) || (msg[4] != offset)) return(1);
1365:
1366: rate = DEF_CLK / period;
1367: rate_rem = 10 * (DEF_CLK - period * rate) / period;
1368:
1369: if (offset)
1370: printk("\ntarget %d: rate=%d.%d Mhz, synchronous, sync offset=%d bytes\n",
1371: target, rate, rate_rem, offset);
1372: else
1373: printk("\ntarget %d: rate=%d.%d Mhz, asynchronous\n", target, rate, rate_rem);
1374:
1375: return(0);
1376: }
1377:
1378: /**************************************************************************
1379: * Function : AM53C974_set_async(struct Scsi_Host *instance, int target)
1380: *
1381: * Purpose : put controller into async. mode
1382: *
1383: * Inputs : instance -- which AM53C974
1384: * target -- which SCSI target to deal with
1385: *
1386: * Returns : nothing
1387: **************************************************************************/
1388: static __inline__ void AM53C974_set_async(struct Scsi_Host *instance, int target)
1389: {
1390: AM53C974_local_declare();
1391: struct AM53C974_hostdata *hostdata = (struct AM53C974_hostdata *)instance->hostdata;
1392: AM53C974_setio(instance);
1393:
1394: AM53C974_write_8(STPREG, hostdata->sync_per[target]);
1395: AM53C974_write_8(SOFREG, (DEF_SOF_RAD<<6) | (DEF_SOF_RAA<<4));
1396: }
1397:
1398: /**************************************************************************
1399: * Function : AM53C974_set_sync(struct Scsi_Host *instance, int target)
1400: *
1401: * Purpose : put controller into sync. mode
1402: *
1403: * Inputs : instance -- which AM53C974
1404: * target -- which SCSI target to deal with
1405: *
1406: * Returns : nothing
1407: **************************************************************************/
1408: static __inline__ void AM53C974_set_sync(struct Scsi_Host *instance, int target)
1409: {
1410: AM53C974_local_declare();
1411: struct AM53C974_hostdata *hostdata = (struct AM53C974_hostdata *)instance->hostdata;
1412: AM53C974_setio(instance);
1413:
1414: AM53C974_write_8(STPREG, hostdata->sync_per[target]);
1415: AM53C974_write_8(SOFREG, (SOFREG_SO & hostdata->sync_off[target]) |
1416: (DEF_SOF_RAD<<6) | (DEF_SOF_RAA<<4));
1417: }
1418:
1419: /***********************************************************************
1420: * Function : AM53C974_information_transfer(struct Scsi_Host *instance, *
1421: * unsigned char statreg, unsigned char isreg, *
1422: * unsigned char instreg, unsigned char cfifo, *
1423: * unsigned char dmastatus) *
1424: * *
1425: * Purpose : handle phase changes *
1426: * *
1427: * Inputs : instance - which AM53C974 *
1428: * statreg - status register *
1429: * isreg - internal state register *
1430: * instreg - interrupt status register *
1431: * cfifo - number of bytes in FIFO *
1432: * dmastatus - dma status register *
1433: * *
1434: * Returns : nothing *
1435: ************************************************************************/
1436: static void AM53C974_information_transfer(struct Scsi_Host *instance,
1437: unsigned char statreg, unsigned char isreg,
1438: unsigned char instreg, unsigned char cfifo,
1439: unsigned char dmastatus)
1440: {
1441: AM53C974_local_declare();
1442: struct AM53C974_hostdata *hostdata = (struct AM53C974_hostdata *)instance->hostdata;
1443: Scsi_Cmnd *cmd = (Scsi_Cmnd *)hostdata->connected;
1444: int ret, i, len, residual=-1;
1445: AM53C974_setio(instance);
1446:
1447: DEB_INFO(printk(SEPARATOR_LINE));
1448: switch (statreg & STATREG_PHASE) { /* scsi phase */
1449: case PHASE_DATAOUT:
1450: DEB_INFO(printk("Dataout phase; cmd=0x%lx, sel_cmd=0x%lx, this_residual=%d, buffers_residual=%d\n",
1451: (long)hostdata->connected, (long)hostdata->sel_cmd, cmd->SCp.this_residual, cmd->SCp.buffers_residual));
1452: cmd->SCp.phase = PHASE_DATAOUT;
1453: goto PHASE_DATA_IO;
1454:
1455: case PHASE_DATAIN:
1456: DEB_INFO(printk("Datain phase; cmd=0x%lx, sel_cmd=0x%lx, this_residual=%d, buffers_residual=%d\n",
1457: (long)hostdata->connected, (long)hostdata->sel_cmd, cmd->SCp.this_residual, cmd->SCp.buffers_residual));
1458: cmd->SCp.phase = PHASE_DATAIN;
1459: PHASE_DATA_IO:
1460: if (hostdata->aborted) {
1461: AM53C974_write_8(DMACMD, DMACMD_IDLE);
1462: AM53C974_write_8(CMDREG, CMDREG_CFIFO);
1463: AM53C974_write_8(CMDREG, CMDREG_SATN);
1464: return; }
1465: if ((!cmd->SCp.this_residual) && cmd->SCp.buffers_residual) {
1466: cmd->SCp.buffer++;
1467: cmd->SCp.buffers_residual--;
1468: cmd->SCp.ptr = (unsigned char *)cmd->SCp.buffer->address;
1469: cmd->SCp.this_residual = cmd->SCp.buffer->length; }
1470: if (cmd->SCp.this_residual) {
1471: if (!(AM53C974_read_8(DMACMD) & DMACMD_START)) {
1472: hostdata->dma_busy = 0;
1473: AM53C974_transfer_dma(instance, statreg & STATREG_IO,
1474: (unsigned long)cmd->SCp.this_residual,
1475: cmd->SCp.ptr); }
1476: else
1477: hostdata->dma_busy = 1;
1478: }
1479: return;
1480:
1481: case PHASE_MSGIN:
1482: DEB_INFO(printk("Message-In phase; cmd=0x%lx, sel_cmd=0x%lx\n",
1483: (long)hostdata->connected, (long)hostdata->sel_cmd));
1484: AM53C974_set_async(instance, cmd->target);
1485: if (cmd->SCp.phase == PHASE_DATAIN)
1486: AM53C974_dma_blast(instance, dmastatus, statreg);
1487: if ((cmd->SCp.phase == PHASE_DATAOUT) && (AM53C974_read_8(DMACMD) & DMACMD_START)) {
1488: AM53C974_write_8(DMACMD, DMACMD_IDLE);
1489: residual = cfifo + (AM53C974_read_8(CTCLREG) | (AM53C974_read_8(CTCMREG) << 8) |
1490: (AM53C974_read_8(CTCHREG) << 16));
1491: cmd->SCp.ptr += cmd->SCp.this_residual - residual;
1492: cmd->SCp.this_residual = residual;
1493: if (cfifo) { AM53C974_write_8(CMDREG, CMDREG_CFIFO); cfifo = 0; }
1494: }
1495: if (cmd->SCp.phase == PHASE_STATIN) {
1496: while ((AM53C974_read_8(CFIREG) & CFIREG_CF) < 2) ;
1497: cmd->SCp.Status = AM53C974_read_8(FFREG);
1498: cmd->SCp.Message = AM53C974_read_8(FFREG);
1499: DEB_INFO(printk("Message-In phase; status=0x%02x, message=0x%02x\n",
1500: cmd->SCp.Status, cmd->SCp.Message));
1501: ret = AM53C974_message(instance, cmd, cmd->SCp.Message); }
1502: else {
1503: if (!cfifo) {
1504: AM53C974_write_8(CMDREG, CMDREG_IT);
1505: AM53C974_poll_int();
1506: cmd->SCp.Message = AM53C974_read_8(FFREG);
1507: }
1508: ret = AM53C974_message(instance, cmd, cmd->SCp.Message);
1509: }
1510: cmd->SCp.phase = PHASE_MSGIN;
1511: AM53C974_set_sync(instance, cmd->target);
1512: break;
1513: case PHASE_MSGOUT:
1514: DEB_INFO(printk("Message-Out phase; cfifo=%d; msgout[0]=0x%02x\n",
1515: AM53C974_read_8(CFIREG) & CFIREG_CF, hostdata->msgout[0]));
1516: AM53C974_write_8(DMACMD, DMACMD_IDLE);
1517: AM53C974_set_async(instance, cmd->target);
1518: for (i = 0; i < sizeof(hostdata->last_message); i++)
1519: hostdata->last_message[i] = hostdata->msgout[i];
1520: if ((hostdata->msgout[0] == 0) || INSIDE(hostdata->msgout[0], 0x02, 0x1F) ||
1521: INSIDE(hostdata->msgout[0], 0x80, 0xFF))
1522: len = 1;
1523: else {
1524: if (hostdata->msgout[0] == EXTENDED_MESSAGE) {
1525: #ifdef AM53C974_DEBUG_INFO
1526: printk("Extended message dump:\n");
1527: for (i = 0; i < hostdata->msgout[1] + 2; i++) {
1528: printk("%02x ", hostdata->msgout[i]);
1529: if (i && !(i % 16)) printk("\n"); }
1530: printk("\n");
1531: #endif
1532: len = hostdata->msgout[1] + 2; }
1533: else
1534: len = 2;
1535: }
1536: for (i = 0; i < len; i++) AM53C974_write_8(FFREG, hostdata->msgout[i]);
1537: AM53C974_write_8(CMDREG, CMDREG_IT);
1538: cmd->SCp.phase = PHASE_MSGOUT;
1539: hostdata->msgout[0] = NOP;
1540: AM53C974_set_sync(instance, cmd->target);
1541: break;
1542:
1543: case PHASE_CMDOUT:
1544: DEB_INFO(printk("Command-Out phase\n"));
1545: AM53C974_set_async(instance, cmd->target);
1546: for (i = 0; i < cmd->cmd_len; i++) AM53C974_write_8(FFREG, cmd->cmnd[i]);
1547: AM53C974_write_8(CMDREG, CMDREG_IT);
1548: cmd->SCp.phase = PHASE_CMDOUT;
1549: AM53C974_set_sync(instance, cmd->target);
1550: break;
1551:
1552: case PHASE_STATIN:
1553: DEB_INFO(printk("Status phase\n"));
1554: if (cmd->SCp.phase == PHASE_DATAIN)
1555: AM53C974_dma_blast(instance, dmastatus, statreg);
1556: AM53C974_set_async(instance, cmd->target);
1557: if (cmd->SCp.phase == PHASE_DATAOUT) {
1558: unsigned long residual;
1559:
1560: if (AM53C974_read_8(DMACMD) & DMACMD_START) {
1561: AM53C974_write_8(DMACMD, DMACMD_IDLE);
1562: residual = cfifo + (AM53C974_read_8(CTCLREG) | (AM53C974_read_8(CTCMREG) << 8) |
1563: (AM53C974_read_8(CTCHREG) << 16));
1564: cmd->SCp.ptr += cmd->SCp.this_residual - residual;
1565: cmd->SCp.this_residual = residual; }
1566: if (cfifo) { AM53C974_write_8(CMDREG, CMDREG_CFIFO); cfifo = 0; }
1567: }
1568: cmd->SCp.phase = PHASE_STATIN;
1569: AM53C974_write_8(CMDREG, CMDREG_ICCS); /* command complete */
1570: break;
1571:
1572: case PHASE_RES_0:
1573: case PHASE_RES_1:
1574: #ifdef AM53C974_DEBUG
1575: deb_stop = 1;
1576: #endif
1577: DEB_INFO(printk("Reserved phase\n"));
1578: break;
1579: }
1580: KEYWAIT();
1581: }
1582:
1583: /******************************************************************************
1584: * Function : int AM53C974_message(struct Scsi_Host *instance, Scsi_Cmnd *cmd,
1585: * unsigned char msg)
1586: *
1587: * Purpose : handle SCSI messages
1588: *
1589: * Inputs : instance -- which AM53C974
1590: * cmd -- SCSI command the message belongs to
1591: * msg -- message id byte
1592: *
1593: * Returns : 1 on success, 0 on failure.
1594: **************************************************************************/
1595: static int AM53C974_message(struct Scsi_Host *instance, Scsi_Cmnd *cmd,
1596: unsigned char msg)
1597: {
1598: AM53C974_local_declare();
1599: static unsigned char extended_msg[10];
1600: unsigned char statreg;
1601: int len, ret = 0;
1602: unsigned char *p;
1603: #ifdef AM53C974_DEBUG_MSG
1604: int j;
1605: #endif
1606: struct AM53C974_hostdata *hostdata = (struct AM53C974_hostdata *)instance->hostdata;
1607: AM53C974_setio(instance);
1608:
1609: DEB_MSG(printk(SEPARATOR_LINE));
1610:
1611: /* Linking lets us reduce the time required to get the
1612: * next command out to the device, hopefully this will
1613: * mean we don't waste another revolution due to the delays
1614: * required by ARBITRATION and another SELECTION.
1615: * In the current implementation proposal, low level drivers
1616: * merely have to start the next command, pointed to by
1617: * next_link, done() is called as with unlinked commands. */
1618: switch (msg) {
1619: #ifdef LINKED
1620: case LINKED_CMD_COMPLETE:
1621: case LINKED_FLG_CMD_COMPLETE:
1622: /* Accept message by releasing ACK */
1623: DEB_LINKED(printk("scsi%d : target %d lun %d linked command complete.\n",
1624: instance->host_no, cmd->target, cmd->lun));
1625: /* Sanity check : A linked command should only terminate with
1626: * one of these messages if there are more linked commands available. */
1627: if (!cmd->next_link) {
1628: printk("scsi%d : target %d lun %d linked command complete, no next_link\n"
1629: instance->host_no, cmd->target, cmd->lun);
1630: hostdata->aborted = 1;
1631: AM53C974_write_8(CMDREG, CMDREG_SATN);
1632: AM53C974_write_8(CMDREG, CMDREG_MA);
1633: break; }
1634: if (hostdata->aborted) {
1635: DEB_ABORT(printk("ATN set for cmnd %d upon reception of LINKED_CMD_COMPLETE or"
1636: "LINKED_FLG_CMD_COMPLETE message\n", cmd->cmnd[0]));
1637: AM53C974_write_8(CMDREG, CMDREG_SATN); }
1638: AM53C974_write_8(CMDREG, CMDREG_MA);
1639:
1640: initialize_SCp(cmd->next_link);
1641: /* The next command is still part of this process */
1642: cmd->next_link->tag = cmd->tag;
1643: cmd->result = cmd->SCp.Status | (cmd->SCp.Message << 8);
1644: DEB_LINKED(printk("scsi%d : target %d lun %d linked request done, calling scsi_done().\n",
1645: instance->host_no, cmd->target, cmd->lun));
1646: cmd->scsi_done(cmd);
1647: cmd = hostdata->connected;
1648: break;
1649:
1650: #endif /* def LINKED */
1651:
1652: case ABORT:
1653: case COMMAND_COMPLETE:
1654: DEB_MSG(printk("scsi%d: command complete message received; cmd %d for target %d, lun %d\n",
1655: instance->host_no, cmd->cmnd[0], cmd->target, cmd->lun));
1656: hostdata->disconnecting = 1;
1657: cmd->device->disconnect = 0;
1658:
1659: /* I'm not sure what the correct thing to do here is :
1660: *
1661: * If the command that just executed is NOT a request
1662: * sense, the obvious thing to do is to set the result
1663: * code to the values of the stored parameters.
1664: * If it was a REQUEST SENSE command, we need some way
1665: * to differentiate between the failure code of the original
1666: * and the failure code of the REQUEST sense - the obvious
1667: * case is success, where we fall through and leave the result
1668: * code unchanged.
1669: *
1670: * The non-obvious place is where the REQUEST SENSE failed */
1671: if (cmd->cmnd[0] != REQUEST_SENSE)
1672: cmd->result = cmd->SCp.Status | (cmd->SCp.Message << 8);
1673: else if (cmd->SCp.Status != GOOD)
1674: cmd->result = (cmd->result & 0x00ffff) | (DID_ERROR << 16);
1675: if (hostdata->aborted) {
1676: AM53C974_write_8(CMDREG, CMDREG_SATN);
1677: AM53C974_write_8(CMDREG, CMDREG_MA);
1678: DEB_ABORT(printk("ATN set for cmnd %d upon reception of ABORT or"
1679: "COMMAND_COMPLETE message\n", cmd->cmnd[0]));
1680: break; }
1681: if ((cmd->cmnd[0] != REQUEST_SENSE) && (cmd->SCp.Status == CHECK_CONDITION)) {
1682: DEB_MSG(printk("scsi%d : performing request sense\n", instance->host_no));
1683: cmd->cmnd[0] = REQUEST_SENSE;
1684: cmd->cmnd[1] &= 0xe0;
1685: cmd->cmnd[2] = 0;
1686: cmd->cmnd[3] = 0;
1687: cmd->cmnd[4] = sizeof(cmd->sense_buffer);
1688: cmd->cmnd[5] = 0;
1689: cmd->SCp.buffer = NULL;
1690: cmd->SCp.buffers_residual = 0;
1691: cmd->SCp.ptr = (char *)cmd->sense_buffer;
1692: cmd->SCp.this_residual = sizeof(cmd->sense_buffer);
1693: LIST(cmd,hostdata->issue_queue);
1694: cmd->host_scribble = (unsigned char *)hostdata->issue_queue;
1695: hostdata->issue_queue = (Scsi_Cmnd *)cmd;
1696: DEB_MSG(printk("scsi%d : REQUEST SENSE added to head of issue queue\n",instance->host_no));
1697: }
1698:
1699: /* Accept message by clearing ACK */
1700: AM53C974_write_8(CMDREG, CMDREG_MA);
1701: break;
1702:
1703: case MESSAGE_REJECT:
1704: DEB_MSG(printk("scsi%d: reject message received; cmd %d for target %d, lun %d\n",
1705: instance->host_no, cmd->cmnd[0], cmd->target, cmd->lun));
1706: switch (hostdata->last_message[0]) {
1707: case EXTENDED_MESSAGE:
1708: if (hostdata->last_message[2] == EXTENDED_SDTR) {
1709: /* sync. negotiation was rejected, setup asynchronous transfer with target */
1710: printk("\ntarget %d: rate=%d Mhz, asynchronous (sync. negotiation rejected)\n",
1711: cmd->target, DEF_CLK / DEF_STP);
1712: hostdata->sync_off[cmd->target] = 0;
1713: hostdata->sync_per[cmd->target] = DEF_STP; }
1714: break;
1715: case HEAD_OF_QUEUE_TAG:
1716: case ORDERED_QUEUE_TAG:
1717: case SIMPLE_QUEUE_TAG:
1718: cmd->device->tagged_queue = 0;
1719: hostdata->busy[cmd->target] |= (1 << cmd->lun);
1720: break;
1721: default:
1722: break;
1723: }
1724: if (hostdata->aborted) AM53C974_write_8(CMDREG, CMDREG_SATN);
1725: AM53C974_write_8(CMDREG, CMDREG_MA);
1726: break;
1727:
1728: case DISCONNECT:
1729: DEB_MSG(printk("scsi%d: disconnect message received; cmd %d for target %d, lun %d\n",
1730: instance->host_no, cmd->cmnd[0], cmd->target, cmd->lun));
1731: cmd->device->disconnect = 1;
1732: hostdata->disconnecting = 1;
1733: AM53C974_write_8(CMDREG, CMDREG_MA); /* Accept message by clearing ACK */
1734: break;
1735:
1736: case SAVE_POINTERS:
1737: case RESTORE_POINTERS:
1738: DEB_MSG(printk("scsi%d: save/restore pointers message received; cmd %d for target %d, lun %d\n",
1739: instance->host_no, cmd->cmnd[0], cmd->target, cmd->lun));
1740: /* The SCSI data pointer is *IMPLICITLY* saved on a disconnect
1741: * operation, in violation of the SCSI spec so we can safely
1742: * ignore SAVE/RESTORE pointers calls.
1743: *
1744: * Unfortunately, some disks violate the SCSI spec and
1745: * don't issue the required SAVE_POINTERS message before
1746: * disconnecting, and we have to break spec to remain
1747: * compatible. */
1748: if (hostdata->aborted) {
1749: DEB_ABORT(printk("ATN set for cmnd %d upon reception of SAVE/REST. POINTERS message\n",
1750: cmd->cmnd[0]));
1751: AM53C974_write_8(CMDREG, CMDREG_SATN); }
1752: AM53C974_write_8(CMDREG, CMDREG_MA);
1753: break;
1754:
1755: case EXTENDED_MESSAGE:
1756: DEB_MSG(printk("scsi%d: extended message received; cmd %d for target %d, lun %d\n",
1757: instance->host_no, cmd->cmnd[0], cmd->target, cmd->lun));
1758: /* Extended messages are sent in the following format :
1759: * Byte
1760: * 0 EXTENDED_MESSAGE == 1
1761: * 1 length (includes one byte for code, doesn't include first two bytes)
1762: * 2 code
1763: * 3..length+1 arguments
1764: */
1765: /* BEWARE!! THIS CODE IS EXTREMELY UGLY */
1766: extended_msg[0] = EXTENDED_MESSAGE;
1767: AM53C974_read_8(INSTREG) ; /* clear int */
1768: AM53C974_write_8(CMDREG, CMDREG_MA); /* ack. msg byte, then wait for SO */
1769: AM53C974_poll_int();
1770: /* get length */
1771: AM53C974_write_8(CMDREG, CMDREG_IT);
1772: AM53C974_poll_int();
1773: AM53C974_write_8(CMDREG, CMDREG_MA); /* ack. msg byte, then wait for SO */
1774: AM53C974_poll_int();
1775: extended_msg[1] = len = AM53C974_read_8(FFREG); /* get length */
1776: p = extended_msg+2;
1777: /* read the remaining (len) bytes */
1778: while (len) {
1779: AM53C974_write_8(CMDREG, CMDREG_IT);
1780: AM53C974_poll_int();
1781: if (len > 1) {
1782: AM53C974_write_8(CMDREG, CMDREG_MA); /* ack. msg byte, then wait for SO */
1783: AM53C974_poll_int(); }
1784: *p = AM53C974_read_8(FFREG);
1785: p++; len--; }
1786:
1787: #ifdef AM53C974_DEBUG_MSG
1788: printk("scsi%d: received extended message: ", instance->host_no);
1789: for (j = 0; j < extended_msg[1] + 2; j++) {
1790: printk("0x%02x ", extended_msg[j]);
1791: if (j && !(j % 16)) printk("\n"); }
1792: printk("\n");
1793: #endif
1794:
1795: /* check message */
1796: if (extended_msg[2] == EXTENDED_SDTR)
1797: ret = AM53C974_sync_neg(instance, cmd->target, extended_msg);
1798: if (ret || hostdata->aborted) AM53C974_write_8(CMDREG, CMDREG_SATN);
1799:
1800: AM53C974_write_8(CMDREG, CMDREG_MA);
1801: break;
1802:
1803: default:
1804: printk("scsi%d: unknown message 0x%02x received\n",instance->host_no, msg);
1805: #ifdef AM53C974_DEBUG
1806: deb_stop = 1;
1807: #endif
1808: /* reject message */
1809: hostdata->msgout[0] = MESSAGE_REJECT;
1810: AM53C974_write_8(CMDREG, CMDREG_SATN);
1811: AM53C974_write_8(CMDREG, CMDREG_MA);
1812: return(0);
1813: break;
1814:
1815: } /* switch (msg) */
1816: KEYWAIT();
1817: return(1);
1818: }
1819:
1820: /**************************************************************************
1821: * Function : AM53C974_select(struct Scsi_Host *instance, Scsi_Cmnd *cmd, int tag)
1822: *
1823: * Purpose : try to establish nexus for the command;
1824: * start sync negotiation via start stop and transfer the command in
1825: * cmdout phase in case of an inquiry or req. sense command with no
1826: * sync. neg. performed yet
1827: *
1828: * Inputs : instance -- which AM53C974
1829: * cmd -- command which requires the selection
1830: * tag -- tagged queueing
1831: *
1832: * Returns : nothing
1833: *
1834: * Note: this function initializes the selection process, which is continued
1835: * in the interrupt handler
1836: **************************************************************************/
1837: static void AM53C974_select(struct Scsi_Host *instance, Scsi_Cmnd *cmd, int tag)
1838: {
1839: AM53C974_local_declare();
1840: struct AM53C974_hostdata *hostdata = (struct AM53C974_hostdata *)instance->hostdata;
1841: unsigned char cfifo, tmp[3];
1842: unsigned int i, len, cmd_size = COMMAND_SIZE(cmd->cmnd[0]);
1843: AM53C974_setio(instance);
1844:
1845: cfifo = AM53C974_cfifo();
1846: if (cfifo) {
1847: printk("scsi%d: select error; %d residual bytes in FIFO\n", instance->host_no, cfifo);
1848: AM53C974_write_8(CMDREG, CMDREG_CFIFO); /* clear FIFO */
1849: }
1850:
1851: tmp[0] = IDENTIFY(1, cmd->lun);
1852:
1853: #ifdef SCSI2
1854: if (cmd->device->tagged_queue && (tag != TAG_NONE)) {
1855: tmp[1] = SIMPLE_QUEUE_TAG;
1856: if (tag == TAG_NEXT) {
1857: /* 0 is TAG_NONE, used to imply no tag for this command */
1858: if (cmd->device->current_tag == 0) cmd->device->current_tag = 1;
1859: cmd->tag = cmd->device->current_tag;
1860: cmd->device->current_tag++; }
1861: else
1862: cmd->tag = (unsigned char)tag;
1863: tmp[2] = cmd->tag;
1864: hostdata->last_message[0] = SIMPLE_QUEUE_TAG;
1865: len = 3;
1866: AM53C974_write_8(FFREG, tmp[0]);
1867: AM53C974_write_8(FFREG, tmp[1]);
1868: AM53C974_write_8(FFREG, tmp[2]);
1869: }
1870: else
1871: #endif /* def SCSI2 */
1872: {
1873: len = 1;
1874: AM53C974_write_8(FFREG, tmp[0]);
1875: cmd->tag = 0; }
1876:
1877: /* in case of an inquiry or req. sense command with no sync. neg performed yet, we start
1878: sync negotiation via start stops and transfer the command in cmdout phase */
1879: if (((cmd->cmnd[0] == INQUIRY) || (cmd->cmnd[0] == REQUEST_SENSE)) &&
1880: !(hostdata->sync_neg[cmd->target]) && hostdata->sync_en[cmd->target]) {
1881: hostdata->sync_neg[cmd->target] = 1;
1882: hostdata->msgout[0] = EXTENDED_MESSAGE;
1883: hostdata->msgout[1] = 3;
1884: hostdata->msgout[2] = EXTENDED_SDTR;
1885: hostdata->msgout[3] = 250 / (int)hostdata->max_rate[cmd->target];
1886: hostdata->msgout[4] = hostdata->max_offset[cmd->target];
1887: len += 5; }
1888:
1889: AM53C974_write_8(SDIDREG, SDIREG_MASK & cmd->target); /* setup dest. id */
1890: AM53C974_write_8(STIMREG, DEF_SCSI_TIMEOUT); /* setup timeout reg */
1891: switch (len) {
1892: case 1:
1893: for (i = 0; i < cmd_size; i++) AM53C974_write_8(FFREG, cmd->cmnd[i]);
1894: AM53C974_write_8(CMDREG, CMDREG_SAS); /* select with ATN, 1 msg byte */
1895: hostdata->msgout[0] = NOP;
1896: break;
1897: case 3:
1898: for (i = 0; i < cmd_size; i++) AM53C974_write_8(FFREG, cmd->cmnd[i]);
1899: AM53C974_write_8(CMDREG, CMDREG_SA3S); /* select with ATN, 3 msg bytes */
1900: hostdata->msgout[0] = NOP;
1901: break;
1902: default:
1903: AM53C974_write_8(CMDREG, CMDREG_SASS); /* select with ATN, stop steps; continue in message out phase */
1904: break;
1905: }
1906: }
1907:
1908: /**************************************************************************
1909: * Function : AM53C974_intr_select(struct Scsi_Host *instance, unsigned char statreg)
1910: *
1911: * Purpose : handle reselection
1912: *
1913: * Inputs : instance -- which AM53C974
1914: * statreg -- status register
1915: *
1916: * Returns : nothing
1917: *
1918: * side effects: manipulates hostdata
1919: **************************************************************************/
1920: static void AM53C974_intr_reselect(struct Scsi_Host *instance, unsigned char statreg)
1921: {
1922: AM53C974_local_declare();
1923: struct AM53C974_hostdata *hostdata = (struct AM53C974_hostdata *)instance->hostdata;
1924: unsigned char cfifo, msg[3], lun, t, target = 0;
1925: #ifdef SCSI2
1926: unsigned char tag;
1927: #endif
1928: Scsi_Cmnd *tmp = NULL, *prev;
1929: AM53C974_setio(instance);
1930:
1931: cfifo = AM53C974_cfifo();
1932:
1933: if (hostdata->selecting) {
1934: /* caught reselect interrupt in selection process;
1935: put selecting command back into the issue queue and continue with the
1936: reselecting command */
1937: DEB_RESEL(printk("AM53C974_intr_reselect: in selection process\n"));
1938: LIST(hostdata->sel_cmd, hostdata->issue_queue);
1939: hostdata->sel_cmd->host_scribble = (unsigned char *)hostdata->issue_queue;
1940: hostdata->issue_queue = hostdata->sel_cmd;
1941: hostdata->sel_cmd = NULL;
1942: hostdata->selecting = 0; }
1943:
1944: /* 2 bytes must be in the FIFO now */
1945: if (cfifo != 2) {
1946: printk("scsi %d: error: %d bytes in fifo, 2 expected\n", instance->host_no, cfifo);
1947: hostdata->aborted = 1;
1948: goto EXIT_ABORT; }
1949:
1950: /* determine target which reselected */
1951: t = AM53C974_read_8(FFREG);
1952: if (!(t & (1 << instance->this_id))) {
1953: printk("scsi %d: error: invalid host id\n", instance->host_no);
1954: hostdata->aborted = 1;
1955: goto EXIT_ABORT; }
1956: t ^= (1 << instance->this_id);
1957: target = 0; while (t != 1) { t >>= 1; target++; }
1958: DEB_RESEL(printk("scsi %d: reselect; target: %d\n", instance->host_no, target));
1959:
1960: if (hostdata->aborted) goto EXIT_ABORT;
1961:
1962: if ((statreg & STATREG_PHASE) != PHASE_MSGIN) {
1963: printk("scsi %d: error: upon reselection interrupt not in MSGIN\n", instance->host_no);
1964: hostdata->aborted = 1;
1965: goto EXIT_ABORT; }
1966:
1967: msg[0] = AM53C974_read_8(FFREG);
1968: if (!msg[0] & 0x80) {
1969: printk("scsi%d: error: expecting IDENTIFY message, got ", instance->host_no);
1970: print_msg(msg);
1971: hostdata->aborted = 1;
1972: goto EXIT_ABORT; }
1973:
1974: lun = (msg[0] & 0x07);
1975:
1976: /* We need to add code for SCSI-II to track which devices have
1977: * I_T_L_Q nexuses established, and which have simple I_T_L
1978: * nexuses so we can chose to do additional data transfer. */
1979: #ifdef SCSI2
1980: #error "SCSI-II tagged queueing is not supported yet"
1981: #endif
1982:
1983: /* Find the command corresponding to the I_T_L or I_T_L_Q nexus we
1984: * just reestablished, and remove it from the disconnected queue. */
1985: for (tmp = (Scsi_Cmnd *)hostdata->disconnected_queue, prev = NULL;
1986: tmp; prev = tmp, tmp = (Scsi_Cmnd *)tmp->host_scribble)
1987: if ((target == tmp->target) && (lun == tmp->lun)
1988: #ifdef SCSI2
1989: && (tag == tmp->tag)
1990: #endif
1991: ) {
1992: if (prev) {
1993: REMOVE(prev, (Scsi_Cmnd *)(prev->host_scribble), tmp,
1994: (Scsi_Cmnd *)(tmp->host_scribble));
1995: prev->host_scribble = tmp->host_scribble; }
1996: else {
1997: REMOVE(-1, hostdata->disconnected_queue, tmp, tmp->host_scribble);
1998: hostdata->disconnected_queue = (Scsi_Cmnd *)tmp->host_scribble; }
1999: tmp->host_scribble = NULL;
2000: hostdata->connected = tmp;
2001: break; }
2002:
2003: if (!tmp) {
2004: #ifdef SCSI2
2005: printk("scsi%d: warning : target %d lun %d tag %d not in disconnect_queue.\n",
2006: instance->host_no, target, lun, tag);
2007: #else
2008: printk("scsi%d: warning : target %d lun %d not in disconnect_queue.\n",
2009: instance->host_no, target, lun);
2010: #endif
2011: /* Since we have an established nexus that we can't do anything with, we must abort it. */
2012: hostdata->aborted = 1;
2013: DEB(AM53C974_keywait());
2014: goto EXIT_ABORT; }
2015: else
2016: goto EXIT_OK;
2017:
2018: EXIT_ABORT:
2019: AM53C974_write_8(CMDREG, CMDREG_SATN);
2020: AM53C974_write_8(CMDREG, CMDREG_MA);
2021: return;
2022:
2023: EXIT_OK:
2024: DEB_RESEL(printk("scsi%d: nexus established, target = %d, lun = %d, tag = %d\n",
2025: instance->host_no, target, tmp->lun, tmp->tag));
2026: AM53C974_set_sync(instance, target);
2027: AM53C974_write_8(SDIDREG, SDIREG_MASK & target); /* setup dest. id */
2028: AM53C974_write_8(CMDREG, CMDREG_MA);
2029: hostdata->dma_busy = 0;
2030: hostdata->connected->SCp.phase = PHASE_CMDOUT;
2031: }
2032:
2033: /**************************************************************************
2034: * Function : AM53C974_transfer_dma(struct Scsi_Host *instance, short dir,
2035: * unsigned long length, char *data)
2036: *
2037: * Purpose : setup DMA transfer
2038: *
2039: * Inputs : instance -- which AM53C974
2040: * dir -- direction flag, 0: write to device, read from memory;
2041: * 1: read from device, write to memory
2042: * length -- number of bytes to transfer to from buffer
2043: * data -- pointer to data buffer
2044: *
2045: * Returns : nothing
2046: **************************************************************************/
2047: static __inline__ void AM53C974_transfer_dma(struct Scsi_Host *instance, short dir,
2048: unsigned long length, char *data)
2049: {
2050: AM53C974_local_declare();
2051: AM53C974_setio(instance);
2052:
2053: AM53C974_write_8(CMDREG, CMDREG_NOP);
2054: AM53C974_write_8(DMACMD, (dir << 7) | DMACMD_INTE_D); /* idle command */
2055: AM53C974_write_8(STCLREG, (unsigned char)(length & 0xff));
2056: AM53C974_write_8(STCMREG, (unsigned char)((length & 0xff00) >> 8));
2057: AM53C974_write_8(STCHREG, (unsigned char)((length & 0xff0000) >> 16));
2058: AM53C974_write_32(DMASTC, length & 0xffffff);
2059: AM53C974_write_32(DMASPA, virt_to_bus(data));
2060: AM53C974_write_8(CMDREG, CMDREG_IT | CMDREG_DMA);
2061: AM53C974_write_8(DMACMD, (dir << 7) | DMACMD_INTE_D | DMACMD_START);
2062: }
2063:
2064: /**************************************************************************
2065: * Function : AM53C974_dma_blast(struct Scsi_Host *instance, unsigned char dmastatus,
2066: * unsigned char statreg)
2067: *
2068: * Purpose : cleanup DMA transfer
2069: *
2070: * Inputs : instance -- which AM53C974
2071: * dmastatus -- dma status register
2072: * statreg -- status register
2073: *
2074: * Returns : nothing
2075: **************************************************************************/
2076: static void AM53C974_dma_blast(struct Scsi_Host *instance, unsigned char dmastatus,
2077: unsigned char statreg)
2078: {
2079: AM53C974_local_declare();
2080: struct AM53C974_hostdata *hostdata = (struct AM53C974_hostdata *)instance->hostdata;
2081: unsigned long ctcreg;
2082: int dir = statreg & STATREG_IO;
2083: int cfifo, pio, i = 0;
2084: AM53C974_setio(instance);
2085:
2086: do {
2087: cfifo = AM53C974_cfifo();
2088: i++;
2089: } while (cfifo && (i < 50000));
2090: pio = (i == 50000) ? 1: 0;
2091:
2092: if (statreg & STATREG_CTZ) { AM53C974_write_8(DMACMD, DMACMD_IDLE); return; }
2093:
2094: if (dmastatus & DMASTATUS_DONE) { AM53C974_write_8(DMACMD, DMACMD_IDLE); return; }
2095:
2096: AM53C974_write_8(DMACMD, ((dir << 7) & DMACMD_DIR) | DMACMD_BLAST);
2097: while(!(AM53C974_read_8(DMASTATUS) & DMASTATUS_BCMPLT)) ;
2098: AM53C974_write_8(DMACMD, DMACMD_IDLE);
2099:
2100: if (pio) {
2101: /* transfer residual bytes via PIO */
2102: unsigned char *wac = (unsigned char *)AM53C974_read_32(DMAWAC);
2103: printk("pio mode, residual=%d\n", AM53C974_read_8(CFIREG) & CFIREG_CF);
2104: while (AM53C974_read_8(CFIREG) & CFIREG_CF) *(wac++) = AM53C974_read_8(FFREG);
2105: }
2106:
2107: ctcreg = AM53C974_read_8(CTCLREG) | (AM53C974_read_8(CTCMREG) << 8) |
2108: (AM53C974_read_8(CTCHREG) << 16);
2109:
2110: hostdata->connected->SCp.ptr += hostdata->connected->SCp.this_residual - ctcreg;
2111: hostdata->connected->SCp.this_residual = ctcreg;
2112: }
2113:
2114: /**************************************************************************
2115: * Function : AM53C974_intr_bus_reset(struct Scsi_Host *instance)
2116: *
2117: * Purpose : handle bus reset interrupt
2118: *
2119: * Inputs : instance -- which AM53C974
2120: *
2121: * Returns : nothing
2122: **************************************************************************/
2123: static void AM53C974_intr_bus_reset(struct Scsi_Host *instance)
2124: {
2125: AM53C974_local_declare();
2126: unsigned char cntlreg1;
2127: AM53C974_setio(instance);
2128:
2129: AM53C974_write_8(CMDREG, CMDREG_CFIFO);
2130: AM53C974_write_8(CMDREG, CMDREG_NOP);
2131:
2132: cntlreg1 = AM53C974_read_8(CNTLREG1);
2133: AM53C974_write_8(CNTLREG1, cntlreg1 | CNTLREG1_DISR);
2134: }
2135:
2136: /**************************************************************************
2137: * Function : int AM53C974_abort(Scsi_Cmnd *cmd)
2138: *
2139: * Purpose : abort a command
2140: *
2141: * Inputs : cmd - the Scsi_Cmnd to abort, code - code to set the
2142: * host byte of the result field to, if zero DID_ABORTED is
2143: * used.
2144: *
2145: * Returns : 0 - success, -1 on failure.
2146: **************************************************************************/
2147: int AM53C974_abort(Scsi_Cmnd *cmd)
2148: {
2149: AM53C974_local_declare();
2150: struct Scsi_Host *instance = cmd->host;
2151: struct AM53C974_hostdata *hostdata = (struct AM53C974_hostdata *)instance->hostdata;
2152: Scsi_Cmnd *tmp, **prev;
2153:
2154: #ifdef AM53C974_DEBUG
2155: deb_stop = 1;
2156: #endif
2157: cli();
2158: AM53C974_setio(instance);
2159:
2160: DEB_ABORT(printk(SEPARATOR_LINE));
2161: DEB_ABORT(printk("scsi%d : AM53C974_abort called -- trouble starts!!\n", instance->host_no));
2162: DEB_ABORT(AM53C974_print(instance));
2163: DEB_ABORT(AM53C974_keywait());
2164:
2165: /* Case 1 : If the command is the currently executing command,
2166: we'll set the aborted flag and return control so that the
2167: information transfer routine can exit cleanly. */
2168: if ((hostdata->connected == cmd) || (hostdata->sel_cmd == cmd)) {
2169: DEB_ABORT(printk("scsi%d: aborting connected command\n", instance->host_no));
2170: hostdata->aborted = 1;
2171: hostdata->msgout[0] = ABORT;
2172: sti();
2173: return(SCSI_ABORT_PENDING); }
2174:
2175: /* Case 2 : If the command hasn't been issued yet,
2176: we simply remove it from the issue queue. */
2177: for (prev = (Scsi_Cmnd **)&(hostdata->issue_queue),
2178: tmp = (Scsi_Cmnd *)hostdata->issue_queue; tmp;
2179: prev = (Scsi_Cmnd **)&(tmp->host_scribble),
2180: tmp = (Scsi_Cmnd *)tmp->host_scribble) {
2181: if (cmd == tmp) {
2182: DEB_ABORT(printk("scsi%d : abort removed command from issue queue.\n", instance->host_no));
2183: REMOVE(5, *prev, tmp, tmp->host_scribble);
2184: (*prev) = (Scsi_Cmnd *)tmp->host_scribble;
2185: tmp->host_scribble = NULL;
2186: tmp->result = DID_ABORT << 16;
2187: sti();
2188: tmp->done(tmp);
2189: return(SCSI_ABORT_SUCCESS); }
2190: #ifdef AM53C974_DEBUG_ABORT
2191: else {
2192: if (prev == (Scsi_Cmnd **)tmp)
2193: printk("scsi%d : LOOP\n", instance->host_no);
2194: }
2195: #endif
2196: }
2197:
2198: /* Case 3 : If any commands are connected, we're going to fail the abort
2199: * and let the high level SCSI driver retry at a later time or
2200: * issue a reset.
2201: *
2202: * Timeouts, and therefore aborted commands, will be highly unlikely
2203: * and handling them cleanly in this situation would make the common
2204: * case of noresets less efficient, and would pollute our code. So,
2205: * we fail. */
2206: if (hostdata->connected || hostdata->sel_cmd) {
2207: DEB_ABORT(printk("scsi%d : abort failed, other command connected.\n", instance->host_no));
2208: sti();
2209: return(SCSI_ABORT_NOT_RUNNING); }
2210:
2211: /* Case 4: If the command is currently disconnected from the bus, and
2212: * there are no connected commands, we reconnect the I_T_L or
2213: * I_T_L_Q nexus associated with it, go into message out, and send
2214: * an abort message. */
2215: for (tmp = (Scsi_Cmnd *)hostdata->disconnected_queue; tmp;
2216: tmp = (Scsi_Cmnd *)tmp->host_scribble) {
2217: if (cmd == tmp) {
2218: DEB_ABORT(printk("scsi%d: aborting disconnected command\n", instance->host_no));
2219: hostdata->aborted = 1;
2220: hostdata->msgout[0] = ABORT;
2221: hostdata->selecting = 1;
2222: hostdata->sel_cmd = tmp;
2223: AM53C974_write_8(CMDREG, CMDREG_DSR);
2224: sti();
2225: return(SCSI_ABORT_PENDING); }
2226: }
2227:
2228: /* Case 5 : If we reached this point, the command was not found in any of
2229: * the queues.
2230: *
2231: * We probably reached this point because of an unlikely race condition
2232: * between the command completing successfully and the abortion code,
2233: * so we won't panic, but we will notify the user in case something really
2234: * broke. */
2235: DEB_ABORT(printk("scsi%d : abort failed, command not found.\n", instance->host_no));
2236: sti();
2237: return(SCSI_ABORT_NOT_RUNNING);
2238: }
2239:
2240: /**************************************************************************
2241: * Function : int AM53C974_reset(Scsi_Cmnd *cmd)
2242: *
2243: * Purpose : reset the SCSI controller and bus
2244: *
2245: * Inputs : cmd -- which command within the command block was responsible for the reset
2246: *
2247: * Returns : status (SCSI_ABORT_SUCCESS)
2248: **************************************************************************/
2249: int AM53C974_reset(Scsi_Cmnd *cmd, unsigned int flags)
2250: {
2251: AM53C974_local_declare();
2252: int i;
2253: struct Scsi_Host *instance = cmd->host;
2254: struct AM53C974_hostdata *hostdata = (struct AM53C974_hostdata *)instance->hostdata;
2255: AM53C974_setio(instance);
2256:
2257: cli();
2258: DEB(printk("AM53C974_reset called; "));
2259:
2260: printk("AM53C974_reset called\n");
2261: AM53C974_print(instance);
2262: AM53C974_keywait();
2263:
2264: /* do hard reset */
2265: AM53C974_write_8(CMDREG, CMDREG_RDEV);
2266: AM53C974_write_8(CMDREG, CMDREG_NOP);
2267: hostdata->msgout[0] = NOP;
2268: for (i = 0; i < 8; i++) {
2269: hostdata->busy[i] = 0;
2270: hostdata->sync_per[i] = DEF_STP;
2271: hostdata->sync_off[i] = 0;
2272: hostdata->sync_neg[i] = 0; }
2273: hostdata->last_message[0] = NOP;
2274: hostdata->sel_cmd = NULL;
2275: hostdata->connected = NULL;
2276: hostdata->issue_queue = NULL;
2277: hostdata->disconnected_queue = NULL;
2278: hostdata->in_reset = 0;
2279: hostdata->aborted = 0;
2280: hostdata->selecting = 0;
2281: hostdata->disconnecting = 0;
2282: hostdata->dma_busy = 0;
2283:
2284: /* reset bus */
2285: AM53C974_write_8(CNTLREG1, CNTLREG1_DISR | instance->this_id); /* disable interrupt upon SCSI RESET */
2286: AM53C974_write_8(CMDREG, CMDREG_RBUS); /* reset SCSI bus */
2287: udelay(40);
2288: AM53C974_config_after_reset(instance);
2289:
2290: sti();
2291: cmd->result = DID_RESET << 16;
2292: cmd->scsi_done(cmd);
2293: return SCSI_ABORT_SUCCESS;
2294: }
2295:
2296:
2297: /*
2298: * AM53C974_release()
2299: *
2300: * Release resources allocated for a single AM53C974 adapter.
2301: */
2302: int
2303: AM53C974_release(struct Scsi_Host *shp)
2304: {
2305: free_irq(shp->irq, NULL);
2306: scsi_unregister(shp);
2307: return 0;
2308: }
2309:
2310:
2311: #ifdef MODULE
2312: /* Eventually this will go into an include file, but this will be later */
2313: Scsi_Host_Template driver_template = AM53C974;
2314:
2315: #include "scsi_module.c"
2316: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.