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