![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to aha1542.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Net/2] / Net2 / arch / i386 / isa|
Return to aha1542.c CVS log | Up to [Net/2] / Net2 / arch / i386 / isa |
1.1 root 1: /*
2: * (Mostly) Written by Julian Elischer ([email protected])
3: * for TRW Financial Systems for use under the MACH(2.5) operating system.
4: *
5: * TRW Financial Systems, in accordance with their agreement with Carnegie
6: * Mellon University, makes this software available to CMU to distribute
7: * or use in any manner that they see fit as long as this message is kept with
8: * the software. For this reason TFS also grants any other persons or
9: * organisations permission to use or modify this software.
10: *
11: * TFS supplies this software to be publicly redistributed
12: * on the understanding that TFS is not responsible for the correct
13: * functioning of this software in any circumstances.
14: *
15: *
16: * PATCHES MAGIC LEVEL PATCH THAT GOT US HERE
17: * -------------------- ----- ----------------------
18: * CURRENT PATCH LEVEL: 1 00098
19: * -------------------- ----- ----------------------
20: *
21: * 16 Feb 93 Julian Elischer ADDED for SCSI system
22: */
23:
24: /*
25: * Ported to run under 386BSD by Julian Elischer ([email protected]) Sept 1992
26: */
27:
28: /*
29: * HISTORY
30: * $Log: aha1542.c,v $
31: * Revision 1.3 1993/04/10 12:05:04 glass
32: * fixed to be compliant, subservient, and to take advantage of the newly
33: * hacked config(8)
34: *
35: * Revision 1.2 1993/04/08 08:26:46 deraadt
36: * dmesg output at boottime now tries to print out information as
37: * soon as it is available. The output looks much more like Sunos.
38: *
39: * Revision 1.1 1993/03/21 18:09:54 cgd
40: * after 0.2.2 "stable" patches applied
41: *
42: * Revision 1.6 1992/08/24 21:01:58 jason
43: * many changes and bugfixes for osf1
44: *
45: * Revision 1.5 1992/07/31 01:22:03 julian
46: * support improved scsi.h layout
47: *
48: * Revision 1.4 1992/07/25 03:11:26 julian
49: * check each request fro sane flags.
50: *
51: * Revision 1.3 1992/07/24 00:52:45 julian
52: * improved timeout handling.
53: * added support for two arguments to the sd_done (or equiv) call so that
54: * they can pre-queue several arguments.
55: * slightly clean up error handling
56: *
57: * Revision 1.2 1992/07/17 22:03:54 julian
58: * upgraded the timeout code.
59: * added support for UIO-based i/o (as used for pmem operations)
60: *
61: * Revision 1.1 1992/05/27 00:51:12 balsup
62: * machkern/cor merge
63: */
64:
65: /*
66: * a FEW lines in this driver come from a MACH adaptec-disk driver
67: * so the copyright below is included:
68: *
69: * Copyright 1990 by Open Software Foundation,
70: * Grenoble, FRANCE
71: *
72: * All Rights Reserved
73: *
74: * Permission to use, copy, modify, and distribute this software and
75: * its documentation for any purpose and without fee is hereby granted,
76: * provided that the above copyright notice appears in all copies and
77: * that both the copyright notice and this permission notice appear in
78: * supporting documentation, and that the name of OSF or Open Software
79: * Foundation not be used in advertising or publicity pertaining to
80: * distribution of the software without specific, written prior
81: * permission.
82: *
83: * OSF DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE
84: * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS,
85: * IN NO EVENT SHALL OSF BE LIABLE FOR ANY SPECIAL, INDIRECT, OR
86: * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
87: * LOSS OF USE, DATA OR PROFITS, WHETHER IN ACTION OF CONTRACT,
88: * NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
89: * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
90: */
91:
92:
93: #include <sys/types.h>
94: #include <aha.h>
95:
96: #include <sys/param.h>
97: #include <sys/systm.h>
98: #include <sys/errno.h>
99: #include <sys/ioctl.h>
100: #include <sys/buf.h>
101: #include <sys/proc.h>
102: #include <sys/user.h>
103:
104: #ifdef MACH /* EITHER CMU OR OSF */
105: #include <i386/ipl.h>
106: #include <i386at/scsi.h>
107: #include <i386at/scsiconf.h>
108:
109: #ifdef OSF /* OSF ONLY */
110: #include <sys/table.h>
111: #include <i386/handler.h>
112: #include <i386/dispatcher.h>
113: #include <i386/AT386/atbus.h>
114:
115: #else OSF /* CMU ONLY */
116: #include <i386at/atbus.h>
117: #include <i386/pio.h>
118: #endif OSF
119: #endif MACH /* end of MACH specific */
120:
121: #ifdef __386BSD__ /* 386BSD specific */
122: #define isa_dev isa_device
123: #define dev_unit id_unit
124: #define dev_addr id_iobase
125:
126: #include <i386/isa/isa_device.h>
127: #include <scsi/scsi_all.h>
128: #include <scsi/scsiconf.h>
129:
130: #ifdef DDB
131: int Debugger();
132: #else
133: #define Debugger() panic("should call debugger here (adaptec.c)")
134: #endif /*!DDB*/
135:
136: #endif /*__386BSD__*/
137: extern int delaycount; /* from clock setup code */
138:
139: /************************** board definitions *******************************/
140: /*
141: * I/O Port Interface
142: */
143:
144: #define AHA_BASE aha_base[unit]
145: #define AHA_CTRL_STAT_PORT (AHA_BASE + 0x0) /* control & status */
146: #define AHA_CMD_DATA_PORT (AHA_BASE + 0x1) /* cmds and datas */
147: #define AHA_INTR_PORT (AHA_BASE + 0x2) /* Intr. stat */
148:
149: /*
150: * AHA_CTRL_STAT bits (write)
151: */
152:
153: #define AHA_HRST 0x80 /* Hardware reset */
154: #define AHA_SRST 0x40 /* Software reset */
155: #define AHA_IRST 0x20 /* Interrupt reset */
156: #define AHA_SCRST 0x10 /* SCSI bus reset */
157:
158: /*
159: * AHA_CTRL_STAT bits (read)
160: */
161:
162: #define AHA_STST 0x80 /* Self test in Progress */
163: #define AHA_DIAGF 0x40 /* Diagnostic Failure */
164: #define AHA_INIT 0x20 /* Mbx Init required */
165: #define AHA_IDLE 0x10 /* Host Adapter Idle */
166: #define AHA_CDF 0x08 /* cmd/data out port full */
167: #define AHA_DF 0x04 /* Data in port full */
168: #define AHA_INVDCMD 0x01 /* Invalid command */
169:
170: /*
171: * AHA_CMD_DATA bits (write)
172: */
173:
174: #define AHA_NOP 0x00 /* No operation */
175: #define AHA_MBX_INIT 0x01 /* Mbx initialization */
176: #define AHA_START_SCSI 0x02 /* start scsi command */
177: #define AHA_START_BIOS 0x03 /* start bios command */
178: #define AHA_INQUIRE 0x04 /* Adapter Inquiry */
179: #define AHA_MBO_INTR_EN 0x05 /* Enable MBO available interrupt */
180: #define AHA_SEL_TIMEOUT_SET 0x06 /* set selection time-out */
181: #define AHA_BUS_ON_TIME_SET 0x07 /* set bus-on time */
182: #define AHA_BUS_OFF_TIME_SET 0x08 /* set bus-off time */
183: #define AHA_SPEED_SET 0x09 /* set transfer speed */
184: #define AHA_DEV_GET 0x0a /* return installed devices */
185: #define AHA_CONF_GET 0x0b /* return configuration data */
186: #define AHA_TARGET_EN 0x0c /* enable target mode */
187: #define AHA_SETUP_GET 0x0d /* return setup data */
188: #define AHA_WRITE_CH2 0x1a /* write channel 2 buffer */
189: #define AHA_READ_CH2 0x1b /* read channel 2 buffer */
190: #define AHA_WRITE_FIFO 0x1c /* write fifo buffer */
191: #define AHA_READ_FIFO 0x1d /* read fifo buffer */
192: #define AHA_ECHO 0x1e /* Echo command data */
193:
194: struct aha_cmd_buf {
195: u_char byte[16];
196: };
197:
198: /*
199: * AHA_INTR_PORT bits (read)
200: */
201:
202: #define AHA_ANY_INTR 0x80 /* Any interrupt */
203: #define AHA_SCRD 0x08 /* SCSI reset detected */
204: #define AHA_HACC 0x04 /* Command complete */
205: #define AHA_MBOA 0x02 /* MBX out empty */
206: #define AHA_MBIF 0x01 /* MBX in full */
207:
208: /*
209: * Mail box defs
210: */
211:
212: #define AHA_MBX_SIZE 16 /* mail box size */
213:
214: struct aha_mbx {
215: struct aha_mbx_out {
216: unsigned char cmd;
217: unsigned char ccb_addr[3];
218: } mbo [AHA_MBX_SIZE];
219: struct aha_mbx_in{
220: unsigned char stat;
221: unsigned char ccb_addr[3];
222: } mbi[AHA_MBX_SIZE];
223: };
224:
225: /*
226: * mbo.cmd values
227: */
228:
229: #define AHA_MBO_FREE 0x0 /* MBO entry is free */
230: #define AHA_MBO_START 0x1 /* MBO activate entry */
231: #define AHA_MBO_ABORT 0x2 /* MBO abort entry */
232:
233: #define AHA_MBI_FREE 0x0 /* MBI entry is free */
234: #define AHA_MBI_OK 0x1 /* completed without error */
235: #define AHA_MBI_ABORT 0x2 /* aborted ccb */
236: #define AHA_MBI_UNKNOWN 0x3 /* Tried to abort invalid CCB */
237: #define AHA_MBI_ERROR 0x4 /* Completed with error */
238:
239: extern struct aha_mbx aha_mbx[];
240:
241: /* FOR OLD VERSIONS OF THE !%$@ this may have to be 16 (yuk) */
242: #define AHA_NSEG 17 /* Number of scatter gather segments <= 16 */
243: /* allow 64 K i/o (min) */
244:
245: struct aha_ccb {
246: unsigned char opcode;
247: unsigned char lun:3;
248: unsigned char data_in:1; /* must be 0 */
249: unsigned char data_out:1; /* must be 0 */
250: unsigned char target:3;
251: unsigned char scsi_cmd_length;
252: unsigned char req_sense_length;
253: unsigned char data_length[3];
254: unsigned char data_addr[3];
255: unsigned char link_addr[3];
256: unsigned char link_id;
257: unsigned char host_stat;
258: unsigned char target_stat;
259: unsigned char reserved[2];
260: struct scsi_generic scsi_cmd;
261: struct scsi_sense_data scsi_sense;
262: struct aha_scat_gath {
263: unsigned char seg_len[3];
264: unsigned char seg_addr[3];
265: } scat_gath[AHA_NSEG];
266: struct aha_ccb *next;
267: struct scsi_xfer *xfer; /* the scsi_xfer for this cmd */
268: struct aha_mbx_out *mbx; /* pointer to mail box */
269: long int delta; /* difference from previous*/
270: struct aha_ccb *later,*sooner;
271: int flags;
272: #define CCB_FREE 0
273: #define CCB_ACTIVE 1
274: #define CCB_ABORTED 2
275:
276: };
277:
278: struct aha_ccb *aha_soonest = (struct aha_ccb *)0;
279: struct aha_ccb *aha_latest = (struct aha_ccb *)0;
280: long int aha_furtherest = 0; /* longest time in the timeout queue */
281:
282: /*
283: * opcode fields
284: */
285:
286: #define AHA_INITIATOR_CCB 0x00 /* SCSI Initiator CCB */
287: #define AHA_TARGET_CCB 0x01 /* SCSI Target CCB */
288: #define AHA_INIT_SCAT_GATH_CCB 0x02 /* SCSI Initiator with scattter gather*/
289: #define AHA_RESET_CCB 0x81 /* SCSI Bus reset */
290:
291:
292: /*
293: * aha_ccb.host_stat values
294: */
295:
296: #define AHA_OK 0x00 /* cmd ok */
297: #define AHA_LINK_OK 0x0a /* Link cmd ok */
298: #define AHA_LINK_IT 0x0b /* Link cmd ok + int */
299: #define AHA_SEL_TIMEOUT 0x11 /* Selection time out */
300: #define AHA_OVER_UNDER 0x12 /* Data over/under run */
301: #define AHA_BUS_FREE 0x13 /* Bus dropped at unexpected time */
302: #define AHA_INV_BUS 0x14 /* Invalid bus phase/sequence */
303: #define AHA_BAD_MBO 0x15 /* Incorrect MBO cmd */
304: #define AHA_BAD_CCB 0x16 /* Incorrect ccb opcode */
305: #define AHA_BAD_LINK 0x17 /* Not same values of LUN for links */
306: #define AHA_INV_TARGET 0x18 /* Invalid target direction */
307: #define AHA_CCB_DUP 0x19 /* Duplicate CCB received */
308: #define AHA_INV_CCB 0x1a /* Invalid CCB or segment list */
309: #define AHA_ABORTED 42
310:
311:
312:
313:
314: struct aha_setup
315: {
316: u_char sync_neg:1;
317: u_char parity:1;
318: u_char :6;
319: u_char speed;
320: u_char bus_on;
321: u_char bus_off;
322: u_char num_mbx;
323: u_char mbx[3];
324: struct
325: {
326: u_char offset:4;
327: u_char period:3;
328: u_char valid:1;
329: }sync[8];
330: u_char disc_sts;
331: };
332:
333: struct aha_config
334: {
335: u_char chan;
336: u_char intr;
337: u_char scsi_dev:3;
338: u_char :5;
339: };
340:
341: #define INT9 0x01
342: #define INT10 0x02
343: #define INT11 0x04
344: #define INT12 0x08
345: #define INT14 0x20
346: #define INT15 0x40
347:
348: #define CHAN0 0x01
349: #define CHAN5 0x20
350: #define CHAN6 0x40
351: #define CHAN7 0x80
352:
353:
354: /*********************************** end of board definitions***************/
355:
356:
357: #ifdef MACH
358: #define PHYSTOKV(x) phystokv(x)
359: #define KVTOPHYS(x) kvtophys(x)
360: #else MACH
361: #ifdef __386BSD__
362: #define PHYSTOKV(x) (x | 0xFE000000)
363: #define KVTOPHYS(x) vtophys(x)
364: #else __386BSD__
365: #endif __386BSD__
366: #endif MACH
367: #define AHA_DMA_PAGES AHA_NSEG
368:
369: #define PAGESIZ 4096
370: #define INVALIDATE_CACHE {asm volatile( ".byte 0x0F ;.byte 0x08" ); }
371:
372:
373: u_char aha_scratch_buf[256];
374: #ifdef MACH
375: caddr_t aha_base[NAHA]; /* base port for each board */
376: #else
377: short aha_base[NAHA]; /* base port for each board */
378: #endif
379: struct aha_mbx aha_mbx[NAHA];
380: struct aha_ccb *aha_ccb_free[NAHA];
381: struct aha_ccb aha_ccb[NAHA][AHA_MBX_SIZE];
382: struct scsi_xfer aha_scsi_xfer[NAHA];
383: struct isa_dev *ahainfo[NAHA];
384: struct aha_ccb *aha_get_ccb();
385: int aha_int[NAHA];
386: int aha_dma[NAHA];
387: int aha_scsi_dev[NAHA];
388: int aha_initialized[NAHA];
389: #ifdef OSF
390: int aha_attached[NAHA];
391: #endif OSF
392: int aha_debug = 0;
393:
394: int ahaprobe(), ahaattach(), ahaintr();
395: #ifdef MACH
396: struct isa_driver ahadriver = { ahaprobe, 0, ahaattach, "aha", 0, 0, 0};
397: int (*ahaintrs[])() = {ahaintr, 0};
398: #endif
399: #ifdef __386BSD__
400: struct isa_driver ahadriver = { ahaprobe, ahaattach, "aha",};
401: #endif __386BSD__
402: static int ahaunit = 0;
403:
404:
405: #define aha_abortmbx(mbx) \
406: (mbx)->cmd = AHA_MBO_ABORT; \
407: outb(AHA_CMD_DATA_PORT, AHA_START_SCSI);
408: #define aha_startmbx(mbx) \
409: (mbx)->cmd = AHA_MBO_START; \
410: outb(AHA_CMD_DATA_PORT, AHA_START_SCSI);
411:
412:
413:
414: int aha_scsi_cmd();
415: int aha_timeout();
416: void ahaminphys();
417: long int aha_adapter_info();
418:
419: struct scsi_switch aha_switch =
420: {
421: aha_scsi_cmd,
422: ahaminphys,
423: 0,
424: 0,
425: aha_adapter_info,
426: 0,0,0
427: };
428: #define AHA_CMD_TIMEOUT_FUDGE 200 /* multiplied to get Secs */
429: #define AHA_RESET_TIMEOUT 1000000 /* time to wait for reset */
430: #define AHA_SCSI_TIMEOUT_FUDGE 20 /* divided by for mSecs */
431:
432:
433: /***********************************************************************\
434: * aha_cmd(unit,icnt, ocnt,wait, retval, opcode, args) *
435: * Activate Adapter command *
436: * icnt: number of args (outbound bytes written after opcode) *
437: * ocnt: number of expected returned bytes *
438: * wait: number of seconds to wait for response *
439: * retval: buffer where to place returned bytes *
440: * opcode: opcode AHA_NOP, AHA_MBX_INIT, AHA_START_SCSI ... *
441: * args: parameters *
442: * *
443: * Performs an adapter command through the ports. Not to be confused *
444: * with a scsi command, which is read in via the dma *
445: * One of the adapter commands tells it to read in a scsi command *
446: \***********************************************************************/
447:
448:
449: aha_cmd(unit,icnt, ocnt, wait,retval, opcode, args)
450:
451: u_char *retval;
452: unsigned opcode;
453: u_char args;
454: {
455: unsigned *ic = &opcode;
456: u_char oc;
457: register i;
458: int sts;
459:
460: /*******************************************************\
461: * multiply the wait argument by a big constant *
462: * zero defaults to 1 *
463: \*******************************************************/
464: if(!wait)
465: wait = AHA_CMD_TIMEOUT_FUDGE * delaycount;
466: else
467: wait *= AHA_CMD_TIMEOUT_FUDGE * delaycount;
468: /*******************************************************\
469: * Wait for the adapter to go idle, unless it's one of *
470: * the commands which don't need this *
471: \*******************************************************/
472: if (opcode != AHA_MBX_INIT && opcode != AHA_START_SCSI)
473: {
474: i = AHA_CMD_TIMEOUT_FUDGE * delaycount; /* 1 sec?*/
475: while (--i)
476: {
477: sts = inb(AHA_CTRL_STAT_PORT);
478: if (sts & AHA_IDLE)
479: {
480: break;
481: }
482: }
483: if (!i)
484: {
485: printf("aha_cmd: aha1542 host not idle(0x%x)\n",sts);
486: return(ENXIO);
487: }
488: }
489: /*******************************************************\
490: * Now that it is idle, if we expect output, preflush the*
491: * queue feeding to us. *
492: \*******************************************************/
493: if (ocnt)
494: {
495: while((inb(AHA_CTRL_STAT_PORT)) & AHA_DF)
496: inb(AHA_CMD_DATA_PORT);
497: }
498:
499: /*******************************************************\
500: * Output the command and the number of arguments given *
501: * for each byte, first check the port is empty. *
502: \*******************************************************/
503: icnt++; /* include the command */
504: while (icnt--)
505: {
506: sts = inb(AHA_CTRL_STAT_PORT);
507: for (i=0; i< wait; i++)
508: {
509: sts = inb(AHA_CTRL_STAT_PORT);
510: if (!(sts & AHA_CDF))
511: break;
512: }
513: if (i >= wait)
514: {
515: printf("aha_cmd: aha1542 cmd/data port full\n");
516: outb(AHA_CTRL_STAT_PORT, AHA_SRST);
517: return(ENXIO);
518: }
519: outb(AHA_CMD_DATA_PORT, (u_char)(*ic++));
520: }
521: /*******************************************************\
522: * If we expect input, loop that many times, each time, *
523: * looking for the data register to have valid data *
524: \*******************************************************/
525: while (ocnt--)
526: {
527: sts = inb(AHA_CTRL_STAT_PORT);
528: for (i=0; i< wait; i++)
529: {
530: sts = inb(AHA_CTRL_STAT_PORT);
531: if (sts & AHA_DF)
532: break;
533: }
534: if (i >= wait)
535: {
536: printf("aha_cmd: aha1542 cmd/data port empty %d\n",ocnt);
537: return(ENXIO);
538: }
539: oc = inb(AHA_CMD_DATA_PORT);
540: if (retval)
541: *retval++ = oc;
542: }
543: /*******************************************************\
544: * Wait for the board to report a finised instruction *
545: \*******************************************************/
546: i=AHA_CMD_TIMEOUT_FUDGE * delaycount; /* 1 sec? */
547: while (--i)
548: {
549: sts = inb(AHA_INTR_PORT);
550: if (sts & AHA_HACC)
551: {
552: break;
553: }
554: }
555: if (!i)
556: {
557: printf("aha_cmd: aha1542 host not finished(0x%x)\n",sts);
558: return(ENXIO);
559: }
560: outb(AHA_CTRL_STAT_PORT, AHA_IRST);
561: return(0);
562: }
563:
564: /*******************************************************\
565: * Check if the device can be found at the port given *
566: * and if so, set it up ready for further work *
567: * as an argument, takes the isa_dev structure from *
568: * autoconf.c *
569: \*******************************************************/
570: ahaprobe(dev)
571: struct isa_dev *dev;
572: {
573: int unit = ahaunit;
574: #if defined(OSF)
575: static ihandler_t aha_handler[NAHA];
576: static ihandler_id_t *aha_handler_id[NAHA];
577: register ihandler_t *chp = &aha_handler[unit];;
578: #endif /* defined(OSF) */
579:
580: /***********************************************\
581: /***********************************************\
582: * find unit and check we have that many defined *
583: \***********************************************/
584: dev->dev_unit = unit;
585: aha_base[unit] = dev->dev_addr;
586: if(unit >= NAHA)
587: {
588: printf("aha: unit number (%d) too high\n",unit);
589: return(0);
590: }
591: /***********************************************\
592: * Try initialise a unit at this location *
593: * sets up dma and bus speed, loads aha_int[unit]*
594: \***********************************************/
595: if (aha_init(unit) != 0)
596: {
597: return(0);
598: }
599:
600: /***********************************************\
601: * If it's there, put in it's interrupt vectors *
602: \***********************************************/
603: #if !defined(OSF)
604: #if defined MACH
605: iunit[aha_int[unit]] =unit;
606: ivect[aha_int[unit]] = ahaintr;
607: intpri[aha_int[unit]] = dev->dev_spl;
608: form_pic_mask();
609: /*take_dev_irq(dev);*/
610: #else
611: #ifdef __386BSD__
612: dev->id_irq = (1 << aha_int[unit]);
613: dev->id_drq = aha_dma[unit];
614: #endif __386BSD__
615: #endif
616: #else /* !defined(OSF) */
617:
618: chp->ih_level = dev->dev_pic;
619: chp->ih_handler = dev->dev_intr[0];
620: chp->ih_resolver = i386_resolver;
621: chp->ih_rdev = dev;
622: chp->ih_stats.intr_type = INTR_DEVICE;
623: chp->ih_stats.intr_cnt = 0;
624: chp->ih_hparam[0].intparam = unit;
625: if ((aha_handler_id[unit] = handler_add(chp)) != NULL)
626: handler_enable(aha_handler_id[unit]);
627: else
628: panic("Unable to add aha interrupt handler");
629: #endif /* !defined(OSF) */
630: #ifdef __386BSD__
631: printf("\n **");
632: #else __386BSD__
633: printf("port=%x spl=%d\n",
634: dev->dev_addr, dev->dev_spl);
635: #endif __386BSD__
636: ahaunit ++;
637: return(1);
638: }
639:
640: /***********************************************\
641: * Attach all the sub-devices we can find *
642: \***********************************************/
643: ahaattach(dev)
644: struct isa_dev *dev;
645: {
646: int unit = dev->dev_unit;
647:
648: #ifdef __386BSD__
649: printf("aha%d: probing for scsi devices..\n", unit);
650: #endif __386BSD__
651: /***********************************************\
652: * ask the adapter what subunits are present *
653: \***********************************************/
654: scsi_attachdevs( unit, aha_scsi_dev[unit], &aha_switch);
655: #if defined(OSF)
656: aha_attached[unit]=1;
657: #endif /* defined(OSF) */
658: if(!unit) /* only one for all boards */
659: {
660: aha_timeout(0);
661: }
662: return;
663: }
664:
665:
666: /***********************************************\
667: * Return some information to the caller about *
668: * the adapter and it's capabilities *
669: \***********************************************/
670: long int aha_adapter_info(unit)
671: int unit;
672: {
673: return(2); /* 2 outstanding requests at a time per device */
674: }
675:
676: /***********************************************\
677: * Catch an interrupt from the adaptor *
678: \***********************************************/
679: ahaintr(unit)
680: {
681: struct aha_ccb *ccb;
682: unsigned char stat;
683: register i;
684:
685: if(scsi_debug & PRINTROUTINES)
686: printf("ahaintr ");
687: /***********************************************\
688: * First acknowlege the interrupt, Then if it's *
689: * not telling about a completed operation *
690: * just return. *
691: \***********************************************/
692: stat = inb(AHA_INTR_PORT);
693: outb(AHA_CTRL_STAT_PORT, AHA_IRST);
694: if(scsi_debug & TRACEINTERRUPTS)
695: printf("int ");
696: if (! (stat & AHA_MBIF))
697: return(1);
698: if(scsi_debug & TRACEINTERRUPTS)
699: printf("b ");
700: #if defined(OSF)
701: if (!aha_attached[unit])
702: {
703: return(1);
704: }
705: #endif /* defined(OSF) */
706: /***********************************************\
707: * If it IS then process the competed operation *
708: \***********************************************/
709: for (i = 0; i < AHA_MBX_SIZE; i++)
710: {
711: if (aha_mbx[unit].mbi[i].stat != AHA_MBI_FREE)
712: {
713: ccb = (struct aha_ccb *)PHYSTOKV(
714: (_3btol(aha_mbx[unit].mbi[i].ccb_addr)));
715:
716: if((stat = aha_mbx[unit].mbi[i].stat) != AHA_MBI_OK)
717: {
718: switch(stat)
719: {
720: case AHA_MBI_ABORT:
721: if(aha_debug)
722: printf("abort");
723: ccb->host_stat = AHA_ABORTED;
724: break;
725:
726: case AHA_MBI_UNKNOWN:
727: ccb = (struct aha_ccb *)0;
728: if(aha_debug)
729: printf("unknown ccb for abort ");
730: /* may have missed it */
731: /* no such ccb known for abort */
732:
733: case AHA_MBI_ERROR:
734: break;
735:
736: default:
737: panic("Impossible mbxi status");
738:
739: }
740: if( aha_debug && ccb )
741: {
742: u_char *cp;
743: cp = (u_char *)(&(ccb->scsi_cmd));
744: printf("op=%x %x %x %x %x %x\n",
745: cp[0], cp[1], cp[2],
746: cp[3], cp[4], cp[5]);
747: printf("stat %x for mbi[%d]\n"
748: , aha_mbx[unit].mbi[i].stat, i);
749: printf("addr = 0x%x\n", ccb);
750: }
751: }
752: if(ccb)
753: {
754: aha_remove_timeout(ccb);
755: aha_done(unit,ccb);
756: }
757: aha_mbx[unit].mbi[i].stat = AHA_MBI_FREE;
758: }
759: }
760: return(1);
761: }
762:
763: /***********************************************\
764: * A ccb (and hence a mbx-out is put onto the *
765: * free list. *
766: \***********************************************/
767: aha_free_ccb(unit,ccb, flags)
768: struct aha_ccb *ccb;
769: {
770: unsigned int opri;
771:
772: if(scsi_debug & PRINTROUTINES)
773: printf("ccb%d(0x%x)> ",unit,flags);
774: if (!(flags & SCSI_NOMASK))
775: opri = splbio();
776:
777: ccb->next = aha_ccb_free[unit];
778: aha_ccb_free[unit] = ccb;
779: ccb->flags = CCB_FREE;
780: if(ccb->sooner || ccb->later)
781: {
782: printf("yikes, still in timeout queue\n");
783: aha_remove_timeout(ccb);
784: }
785: /***********************************************\
786: * If there were none, wake abybody waiting for *
787: * one to come free, starting with queued entries*
788: \***********************************************/
789: if (!ccb->next) {
790: wakeup(&aha_ccb_free[unit]);
791: }
792: if (!(flags & SCSI_NOMASK))
793: splx(opri);
794: }
795:
796: /***********************************************\
797: * Get a free ccb (and hence mbox-out entry) *
798: \***********************************************/
799: struct aha_ccb *
800: aha_get_ccb(unit,flags)
801: {
802: unsigned opri;
803: struct aha_ccb *rc;
804:
805: if(scsi_debug & PRINTROUTINES)
806: printf("<ccb%d(0x%x) ",unit,flags);
807: if (!(flags & SCSI_NOMASK))
808: opri = splbio();
809: /***********************************************\
810: * If we can and have to, sleep waiting for one *
811: * to come free *
812: \***********************************************/
813: while ((!(rc = aha_ccb_free[unit])) && (!(flags & SCSI_NOSLEEP)))
814: {
815: sleep(&aha_ccb_free[unit], PRIBIO);
816: }
817: if (rc)
818: {
819: aha_ccb_free[unit] = aha_ccb_free[unit]->next;
820: rc->flags = CCB_ACTIVE;
821: }
822: if (!(flags & SCSI_NOMASK))
823: splx(opri);
824: return(rc);
825: }
826:
827:
828: /***********************************************\
829: * We have a ccb which has been processed by the *
830: * adaptor, now we look to see how the operation *
831: * went. Wake up the owner if waiting *
832: \***********************************************/
833: aha_done(unit,ccb)
834: struct aha_ccb *ccb;
835: {
836: struct scsi_sense_data *s1,*s2;
837: struct scsi_xfer *xs = ccb->xfer;
838:
839: if(scsi_debug & PRINTROUTINES )
840: printf("aha_done ");
841: /***********************************************\
842: * Otherwise, put the results of the operation *
843: * into the xfer and call whoever started it *
844: \***********************************************/
845: if(!(xs->flags & INUSE))
846: {
847: printf("exiting but not in use! ");
848: Debugger();
849: }
850: if ( ( ccb->host_stat != AHA_OK
851: || ccb->target_stat != SCSI_OK)
852: && (!(xs->flags & SCSI_ERR_OK)))
853: {
854: s1 = (struct scsi_sense_data *)(((char *)(&ccb->scsi_cmd))
855: + ccb->scsi_cmd_length);
856: s2 = &(xs->sense);
857:
858: if(ccb->host_stat)
859: {
860: switch(ccb->host_stat)
861: {
862: case AHA_ABORTED:
863: case AHA_SEL_TIMEOUT: /* No response */
864: xs->error = XS_TIMEOUT;
865: break;
866: default: /* Other scsi protocol messes */
867: xs->error = XS_DRIVER_STUFFUP;
868: if (aha_debug > 1)
869: {
870: printf("host_stat%x\n",
871: ccb->host_stat);
872: }
873: }
874:
875: }
876: else
877: {
878: switch(ccb->target_stat)
879: {
880: case 0x02:
881: /* structure copy!!!!!*/
882: *s2=*s1;
883: xs->error = XS_SENSE;
884: break;
885: case 0x08:
886: xs->error = XS_BUSY;
887: break;
888: default:
889: if (aha_debug > 1)
890: {
891: printf("target_stat%x\n",
892: ccb->target_stat);
893: }
894: xs->error = XS_DRIVER_STUFFUP;
895: }
896: }
897: }
898: else /* All went correctly OR errors expected */
899: {
900: xs->resid = 0;
901: }
902: xs->flags |= ITSDONE;
903: aha_free_ccb(unit,ccb, xs->flags);
904: if(xs->when_done)
905: (*(xs->when_done))(xs->done_arg,xs->done_arg2);
906: }
907:
908:
909: /***********************************************\
910: * Start the board, ready for normal operation *
911: \***********************************************/
912: aha_init(unit)
913: int unit;
914: {
915: unsigned char ad[3];
916: volatile int i,sts;
917: struct aha_config conf;
918:
919: /***********************************************\
920: * reset board, If it doesn't respond, assume *
921: * that it's not there.. good for the probe *
922: \***********************************************/
923:
924: outb(AHA_CTRL_STAT_PORT, AHA_HRST|AHA_SRST);
925:
926: for (i=0; i < AHA_RESET_TIMEOUT; i++)
927: {
928: sts = inb(AHA_CTRL_STAT_PORT) ;
929: if ( sts == (AHA_IDLE | AHA_INIT))
930: break;
931: }
932: if (i >= AHA_RESET_TIMEOUT)
933: {
934: if (aha_debug)
935: printf("aha_init: No answer from adaptec board\n");
936: return(ENXIO);
937: }
938:
939: /***********************************************\
940: * Assume we have a board at this stage *
941: * setup dma channel from jumpers and save int *
942: * level *
943: \***********************************************/
944: #ifdef __386BSD__
945: printf("aha%d reading board settings, ",unit);
946: #define PRNT(x)
947: #else __386BSD__
948: printf("aha%d:",unit);
949: #define PRNT(x) printf(x)
950: #endif __386BSD__
951: aha_cmd(unit,0, sizeof(conf), 0 ,&conf, AHA_CONF_GET);
952: switch(conf.chan)
953: {
954: case CHAN0:
955: outb(0x0b, 0x0c);
956: outb(0x0a, 0x00);
957: aha_dma[unit] = 0;
958: PRNT("dma=0 ");
959: break;
960: case CHAN5:
961: outb(0xd6, 0xc1);
962: outb(0xd4, 0x01);
963: aha_dma[unit] = 5;
964: PRNT("dma=5 ");
965: break;
966: case CHAN6:
967: outb(0xd6, 0xc2);
968: outb(0xd4, 0x02);
969: aha_dma[unit] = 6;
970: PRNT("dma=6 ");
971: break;
972: case CHAN7:
973: outb(0xd6, 0xc3);
974: outb(0xd4, 0x03);
975: aha_dma[unit] = 7;
976: PRNT("dma=7 ");
977: break;
978: default:
979: printf("illegal dma jumper setting\n");
980: return(EIO);
981: }
982: switch(conf.intr)
983: {
984: case INT9:
985: aha_int[unit] = 9;
986: PRNT("int=9 ");
987: break;
988: case INT10:
989: aha_int[unit] = 10;
990: PRNT("int=10 ");
991: break;
992: case INT11:
993: aha_int[unit] = 11;
994: PRNT("int=11 ");
995: break;
996: case INT12:
997: aha_int[unit] = 12;
998: PRNT("int=12 ");
999: break;
1000: case INT14:
1001: aha_int[unit] = 14;
1002: PRNT("int=14 ");
1003: break;
1004: case INT15:
1005: aha_int[unit] = 15;
1006: PRNT("int=15 ");
1007: break;
1008: default:
1009: printf("illegal int jumper setting\n");
1010: return(EIO);
1011: }
1012: /* who are we on the scsi bus */
1013: aha_scsi_dev[unit] = conf.scsi_dev;
1014:
1015:
1016: /***********************************************\
1017: * Initialize memory transfer speed *
1018: \***********************************************/
1019: if(!(aha_set_bus_speed(unit)))
1020: {
1021: return(EIO);
1022: }
1023:
1024:
1025: /***********************************************\
1026: * Initialize mail box *
1027: \***********************************************/
1028:
1029: lto3b(KVTOPHYS(&aha_mbx[unit]), ad);
1030:
1031: aha_cmd(unit,4, 0, 0, 0, AHA_MBX_INIT,
1032: AHA_MBX_SIZE,
1033: ad[0],
1034: ad[1],
1035: ad[2]);
1036:
1037:
1038: /***********************************************\
1039: * link the ccb's with the mbox-out entries and *
1040: * into a free-list *
1041: \***********************************************/
1042: for (i=0; i < AHA_MBX_SIZE; i++) {
1043: aha_ccb[unit][i].next = aha_ccb_free[unit];
1044: aha_ccb_free[unit] = &aha_ccb[unit][i];
1045: aha_ccb_free[unit]->flags = CCB_FREE;
1046: aha_ccb_free[unit]->mbx = &aha_mbx[unit].mbo[i];
1047: lto3b(KVTOPHYS(aha_ccb_free[unit]), aha_mbx[unit].mbo[i].ccb_addr);
1048: }
1049:
1050: /***********************************************\
1051: * Note that we are going and return (to probe) *
1052: \***********************************************/
1053: aha_initialized[unit]++;
1054: return(0);
1055: }
1056:
1057:
1058:
1059:
1060:
1061: void ahaminphys(bp)
1062: struct buf *bp;
1063: {
1064: #ifdef MACH
1065: #if !defined(OSF)
1066: bp->b_flags |= B_NPAGES; /* can support scat/gather */
1067: #endif /* !defined(OSF) */
1068: #endif MACH
1069: /* aha seems to explode with 17 segs (64k may require 17 segs) */
1070: /* on old boards so use a max of 16 segs if you have problems here*/
1071: if(bp->b_bcount > ((AHA_NSEG - 1) * PAGESIZ))
1072: {
1073: bp->b_bcount = ((AHA_NSEG - 1) * PAGESIZ);
1074: }
1075: }
1076:
1077: /***********************************************\
1078: * start a scsi operation given the command and *
1079: * the data address. Also needs the unit, target *
1080: * and lu *
1081: \***********************************************/
1082: int aha_scsi_cmd(xs)
1083: struct scsi_xfer *xs;
1084: {
1085: struct scsi_sense_data *s1,*s2;
1086: struct aha_ccb *ccb;
1087: struct aha_scat_gath *sg;
1088: int seg; /* scatter gather seg being worked on */
1089: int i = 0;
1090: int rc = 0;
1091: int thiskv;
1092: int thisphys,nextphys;
1093: int unit =xs->adapter;
1094: int bytes_this_seg,bytes_this_page,datalen,flags;
1095: struct iovec *iovp;
1096: int s;
1097:
1098: if(scsi_debug & PRINTROUTINES)
1099: printf("aha_scsi_cmd ");
1100: /***********************************************\
1101: * get a ccb (mbox-out) to use. If the transfer *
1102: * is from a buf (possibly from interrupt time) *
1103: * then we can't allow it to sleep *
1104: \***********************************************/
1105: flags = xs->flags;
1106: if(!(flags & INUSE))
1107: {
1108: printf("not in use!");
1109: Debugger();
1110: xs->flags |= INUSE;
1111: }
1112: if(flags & ITSDONE)
1113: {
1114: printf("Already done! check device retry code ");
1115: Debugger();
1116: xs->flags &= ~ITSDONE;
1117: }
1118: if(xs->bp) flags |= (SCSI_NOSLEEP); /* just to be sure */
1119: if (!(ccb = aha_get_ccb(unit,flags)))
1120: {
1121: xs->error = XS_DRIVER_STUFFUP;
1122: return(TRY_AGAIN_LATER);
1123: }
1124:
1125: if (ccb->mbx->cmd != AHA_MBO_FREE)
1126: printf("MBO not free\n");
1127:
1128: /***********************************************\
1129: * Put all the arguments for the xfer in the ccb *
1130: \***********************************************/
1131: ccb->xfer = xs;
1132: if(flags & SCSI_RESET)
1133: {
1134: ccb->opcode = AHA_RESET_CCB;
1135: }
1136: else
1137: {
1138: /* can't use S/G if zero length */
1139: ccb->opcode = (xs->datalen?
1140: AHA_INIT_SCAT_GATH_CCB
1141: :AHA_INITIATOR_CCB);
1142: }
1143: ccb->target = xs->targ;;
1144: ccb->data_out = 0;
1145: ccb->data_in = 0;
1146: ccb->lun = xs->lu;
1147: ccb->scsi_cmd_length = xs->cmdlen;
1148: ccb->req_sense_length = sizeof(ccb->scsi_sense);
1149:
1150: if((xs->datalen) && (!(flags & SCSI_RESET)))
1151: { /* can use S/G only if not zero length */
1152: lto3b(KVTOPHYS(ccb->scat_gath), ccb->data_addr );
1153: sg = ccb->scat_gath ;
1154: seg = 0;
1155: if(flags & SCSI_DATA_UIO)
1156: {
1157: iovp = ((struct uio *)xs->data)->uio_iov;
1158: datalen = ((struct uio *)xs->data)->uio_iovcnt;
1159: while ((datalen) && (seg < AHA_NSEG))
1160: {
1161: lto3b(iovp->iov_base,&(sg->seg_addr));
1162: lto3b(iovp->iov_len,&(sg->seg_len));
1163: if(scsi_debug & SHOWSCATGATH)
1164: printf("(0x%x@0x%x)"
1165: ,iovp->iov_len
1166: ,iovp->iov_base);
1167: sg++;
1168: iovp++;
1169: seg++;
1170: datalen--;
1171: }
1172: }
1173: else
1174: {
1175: /***********************************************\
1176: * Set up the scatter gather block *
1177: \***********************************************/
1178:
1179: if(scsi_debug & SHOWSCATGATH)
1180: printf("%d @0x%x:- ",xs->datalen,xs->data);
1181: datalen = xs->datalen;
1182: thiskv = (int)xs->data;
1183: thisphys = KVTOPHYS(thiskv);
1184:
1185: while ((datalen) && (seg < AHA_NSEG))
1186: {
1187: bytes_this_seg = 0;
1188:
1189: /* put in the base address */
1190: lto3b(thisphys,&(sg->seg_addr));
1191:
1192: if(scsi_debug & SHOWSCATGATH)
1193: printf("0x%x",thisphys);
1194:
1195: /* do it at least once */
1196: nextphys = thisphys;
1197: while ((datalen) && (thisphys == nextphys))
1198: /***************************************\
1199: * This page is contiguous (physically) *
1200: * with the the last, just extend the *
1201: * length *
1202: \***************************************/
1203: {
1204: /** how far to the end of the page ***/
1205: nextphys = (thisphys & (~(PAGESIZ - 1)))
1206: + PAGESIZ;
1207: bytes_this_page = nextphys - thisphys;
1208: /**** or the data ****/
1209: bytes_this_page = min(bytes_this_page
1210: ,datalen);
1211: bytes_this_seg += bytes_this_page;
1212: datalen -= bytes_this_page;
1213:
1214: /**** get more ready for the next page ****/
1215: thiskv = (thiskv & (~(PAGESIZ - 1)))
1216: + PAGESIZ;
1217: if(datalen)
1218: thisphys = KVTOPHYS(thiskv);
1219: }
1220: /***************************************\
1221: * next page isn't contiguous, finish the seg*
1222: \***************************************/
1223: if(scsi_debug & SHOWSCATGATH)
1224: printf("(0x%x)",bytes_this_seg);
1225: lto3b(bytes_this_seg,&(sg->seg_len));
1226: sg++;
1227: seg++;
1228: }
1229: }
1230: lto3b(seg * sizeof(struct aha_scat_gath),ccb->data_length);
1231: if(scsi_debug & SHOWSCATGATH)
1232: printf("\n");
1233: if (datalen)
1234: { /* there's still data, must have run out of segs! */
1235: printf("aha_scsi_cmd%d: more than %d DMA segs\n",
1236: unit,AHA_NSEG);
1237: xs->error = XS_DRIVER_STUFFUP;
1238: aha_free_ccb(unit,ccb,flags);
1239: return(HAD_ERROR);
1240: }
1241:
1242: }
1243: else
1244: { /* No data xfer, use non S/G values */
1245: lto3b(0, ccb->data_addr );
1246: lto3b(0,ccb->data_length);
1247: }
1248: lto3b(0, ccb->link_addr );
1249: /***********************************************\
1250: * Put the scsi command in the ccb and start it *
1251: \***********************************************/
1252: if(!(flags & SCSI_RESET))
1253: bcopy(xs->cmd, &ccb->scsi_cmd, ccb->scsi_cmd_length);
1254: if(scsi_debug & SHOWCOMMANDS)
1255: {
1256: u_char *b = (u_char *)&ccb->scsi_cmd;
1257: if(!(flags & SCSI_RESET))
1258: {
1259: int i = 0;
1260: printf("aha%d:%d:%d-"
1261: ,unit
1262: ,ccb->target
1263: ,ccb->lun );
1264: while(i < ccb->scsi_cmd_length )
1265: {
1266: if(i) printf(",");
1267: printf("%x",b[i++]);
1268: }
1269: }
1270: else
1271: {
1272: printf("aha%d:%d:%d-RESET- "
1273: ,unit
1274: ,ccb->target
1275: ,ccb->lun
1276: );
1277: }
1278: }
1279: if (!(flags & SCSI_NOMASK))
1280: {
1281: s= splbio(); /* stop instant timeouts */
1282: aha_add_timeout(ccb,xs->timeout);
1283: aha_startmbx(ccb->mbx);
1284: /***********************************************\
1285: * Usually return SUCCESSFULLY QUEUED *
1286: \***********************************************/
1287: splx(s);
1288: if(scsi_debug & TRACEINTERRUPTS)
1289: printf("sent ");
1290: return(SUCCESSFULLY_QUEUED);
1291: }
1292: aha_startmbx(ccb->mbx);
1293: if(scsi_debug & TRACEINTERRUPTS)
1294: printf("cmd_sent, waiting ");
1295: /***********************************************\
1296: * If we can't use interrupts, poll on completion*
1297: \***********************************************/
1298: {
1299: int done = 0;
1300: int count = delaycount * xs->timeout / AHA_SCSI_TIMEOUT_FUDGE;
1301: while((!done) && count)
1302: {
1303: i=0;
1304: while ( (!done) && i<AHA_MBX_SIZE)
1305: {
1306: if ((aha_mbx[unit].mbi[i].stat != AHA_MBI_FREE )
1307: && (PHYSTOKV(_3btol(aha_mbx[unit].mbi[i].ccb_addr)
1308: == (int)ccb)))
1309: {
1310: aha_mbx[unit].mbi[i].stat = AHA_MBI_FREE;
1311: aha_done(unit,ccb);
1312: done++;
1313: }
1314: i++;
1315: }
1316: count--;
1317: }
1318: if (!count)
1319: {
1320: if (!(xs->flags & SCSI_SILENT))
1321: printf("cmd fail\n");
1322: aha_abortmbx(ccb->mbx);
1323: count = delaycount * 2000 / AHA_SCSI_TIMEOUT_FUDGE;
1324: while((!done) && count)
1325: {
1326: i=0;
1327: while ( (!done) && i<AHA_MBX_SIZE)
1328: {
1329: if ((aha_mbx[unit].mbi[i].stat != AHA_MBI_FREE )
1330: && (PHYSTOKV(_3btol(aha_mbx[unit].mbi[i].ccb_addr)
1331: == (int)ccb)))
1332: {
1333: aha_mbx[unit].mbi[i].stat = AHA_MBI_FREE;
1334: aha_done(unit,ccb);
1335: done++;
1336: }
1337: i++;
1338: }
1339: count--;
1340: }
1341: if(!count)
1342: {
1343: printf("abort failed in wait\n");
1344: ccb->mbx->cmd = AHA_MBO_FREE;
1345: }
1346: aha_free_ccb(unit,ccb,flags);
1347: ahaintr(unit);
1348: xs->error = XS_DRIVER_STUFFUP;
1349: return(HAD_ERROR);
1350: }
1351: ahaintr(unit);
1352: if(xs->error) return(HAD_ERROR);
1353: return(COMPLETE);
1354:
1355: }
1356: }
1357: /***************************************************************\
1358: * try each speed in turn, when we find one that works, use *
1359: * the NEXT one for a safety margin, unless that doesn't exist *
1360: * or doesn't work. returns the nSEC value of the time used *
1361: * or 0 if it could get a working speed ( or the NEXT speed *
1362: * failed) *
1363: \***************************************************************/
1364:
1365: int aha_set_bus_speed(unit)
1366: int unit;
1367: {
1368: int speed;
1369: int retval,retval2;
1370:
1371: #ifdef EISA
1372: speed = 0; /* start at the fastest */
1373: #else EISA
1374: speed = 1; /* 100 ns can crash some ISA busses (!?!) */
1375: #endif EISA
1376: while (1)
1377: {
1378: retval = aha_bus_speed_check(unit,speed);
1379: if(retval == HAD_ERROR)
1380: {
1381: printf("no working bus speed!!!\n");
1382: return(0);
1383: }
1384: if(retval == 0)
1385: {
1386: speed++;
1387: }
1388: else /* Go one slower to be safe */
1389: { /* unless eisa at 100 ns.. trust it */
1390: if(speed != 0)
1391: {
1392: speed++;
1393: }
1394: printf("%d nSEC ok, use ",retval);
1395: retval2 = aha_bus_speed_check(unit,speed);
1396: if(retval2 == HAD_ERROR) /* retval is slowest already */
1397: {
1398: printf("marginal ");
1399: retval2 = retval;
1400: }
1401: if(retval2)
1402: {
1403: printf("%d nSEC ",retval2);
1404: return(retval2);
1405: }
1406: else
1407: {
1408: printf(".. slower failed, abort.\n",retval);
1409: return(0);
1410: }
1411:
1412: }
1413: }
1414: }
1415:
1416: /***************************************************************\
1417: * Set the DMA speed to the Nth speed and try an xfer. If it *
1418: * fails return 0, if it succeeds return the nSec value selected *
1419: * If there is no such speed return HAD_ERROR. *
1420: \***************************************************************/
1421: static struct bus_speed
1422: {
1423: char arg;
1424: int nsecs;
1425: }aha_bus_speeds[] =
1426: {
1427: {0x88,100},
1428: {0x99,150},
1429: {0xaa,200},
1430: {0xbb,250},
1431: {0xcc,300},
1432: {0xdd,350},
1433: {0xee,400},
1434: {0xff,450}
1435: };
1436: static char aha_test_string[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890abcdefghijklmnopqrstuvwxyz!@";
1437:
1438: int aha_bus_speed_check(unit,speed)
1439: int unit,speed;
1440: {
1441: int numspeeds = sizeof(aha_bus_speeds)/sizeof(struct bus_speed);
1442: u_char ad[3];
1443:
1444: /*******************************************************\
1445: * Check we have such an entry *
1446: \*******************************************************/
1447: if(speed >= numspeeds) return(HAD_ERROR); /* illegal speed */
1448:
1449: /*******************************************************\
1450: * Set the dma-speed *
1451: \*******************************************************/
1452: aha_cmd(unit,1, 0, 0, 0, AHA_SPEED_SET,aha_bus_speeds[speed].arg);
1453:
1454: /*******************************************************\
1455: * put the test data into the buffer and calculate *
1456: * it's address. Read it onto the board *
1457: \*******************************************************/
1458: strcpy(aha_scratch_buf,aha_test_string);
1459: lto3b(KVTOPHYS(aha_scratch_buf),ad);
1460:
1461: aha_cmd(unit,3, 0, 0, 0, AHA_WRITE_FIFO, ad[0], ad[1], ad[2]);
1462:
1463: /*******************************************************\
1464: * clear the buffer then copy the contents back from the *
1465: * board. *
1466: \*******************************************************/
1467: bzero(aha_scratch_buf,54); /* 54 bytes transfered by test */
1468:
1469: aha_cmd(unit,3, 0, 0, 0, AHA_READ_FIFO, ad[0], ad[1], ad[2]);
1470:
1471: /*******************************************************\
1472: * Compare the original data and the final data and *
1473: * return the correct value depending upon the result *
1474: \*******************************************************/
1475: if(strcmp(aha_test_string,aha_scratch_buf))
1476: { /* copy failed.. assume too fast */
1477: return(0);
1478: }
1479: else
1480: { /* copy succeded assume speed ok */
1481: return(aha_bus_speeds[speed].nsecs);
1482: }
1483: }
1484:
1485:
1486: /*
1487: * +----------+ +----------+ +----------+
1488: * aha_soonest--->| later |--->| later|--->| later|-->0
1489: * | [Delta] | | [Delta] | | [Delta] |
1490: * 0<---|sooner |<---|sooner |<---|sooner |<---aha_latest
1491: * +----------+ +----------+ +----------+
1492: *
1493: * aha_furtherest = sum(Delta[1..n])
1494: */
1495: aha_add_timeout(ccb,time)
1496: struct aha_ccb *ccb;
1497: int time;
1498: {
1499: int timeprev;
1500: struct aha_ccb *prev;
1501: int s = splbio();
1502:
1503: if(prev = aha_latest) /* yes, an assign */
1504: {
1505: timeprev = aha_furtherest;
1506: }
1507: else
1508: {
1509: timeprev = 0;
1510: }
1511: while(prev && (timeprev > time))
1512: {
1513: timeprev -= prev->delta;
1514: prev = prev->sooner;
1515: }
1516: if(prev)
1517: {
1518: ccb->delta = time - timeprev;
1519: if( ccb->later = prev->later) /* yes an assign */
1520: {
1521: ccb->later->sooner = ccb;
1522: ccb->later->delta -= ccb->delta;
1523: }
1524: else
1525: {
1526: aha_furtherest = time;
1527: aha_latest = ccb;
1528: }
1529: ccb->sooner = prev;
1530: prev->later = ccb;
1531: }
1532: else
1533: {
1534: if( ccb->later = aha_soonest) /* yes, an assign*/
1535: {
1536: ccb->later->sooner = ccb;
1537: ccb->later->delta -= time;
1538: }
1539: else
1540: {
1541: aha_furtherest = time;
1542: aha_latest = ccb;
1543: }
1544: ccb->delta = time;
1545: ccb->sooner = (struct aha_ccb *)0;
1546: aha_soonest = ccb;
1547: }
1548: splx(s);
1549: }
1550:
1551: aha_remove_timeout(ccb)
1552: struct aha_ccb *ccb;
1553: {
1554: int s = splbio();
1555:
1556: if(ccb->sooner)
1557: {
1558: ccb->sooner->later = ccb->later;
1559: }
1560: else
1561: {
1562: aha_soonest = ccb->later;
1563: }
1564: if(ccb->later)
1565: {
1566: ccb->later->sooner = ccb->sooner;
1567: ccb->later->delta += ccb->delta;
1568: }
1569: else
1570: {
1571: aha_latest = ccb->sooner;
1572: aha_furtherest -= ccb->delta;
1573: }
1574: ccb->sooner = ccb->later = (struct aha_ccb *)0;
1575: splx(s);
1576: }
1577:
1578:
1579: extern int hz;
1580: #define ONETICK 500 /* milliseconds */
1581: #define SLEEPTIME ((hz * 1000) / ONETICK)
1582: aha_timeout(arg)
1583: int arg;
1584: {
1585: struct aha_ccb *ccb;
1586: int unit;
1587: int s = splbio();
1588:
1589: while( ccb = aha_soonest )
1590: {
1591: if(ccb->delta <= ONETICK)
1592: /***********************************************\
1593: * It has timed out, we need to do some work *
1594: \***********************************************/
1595: {
1596: unit = ccb->xfer->adapter;
1597: printf("aha%d: device %d timed out ",unit
1598: ,ccb->xfer->targ);
1599:
1600: /***************************************\
1601: * Unlink it from the queue *
1602: \***************************************/
1603: aha_remove_timeout(ccb);
1604:
1605: /***************************************\
1606: * If The ccb's mbx is not free, then *
1607: * the board has gone south *
1608: \***************************************/
1609: if(ccb->mbx->cmd != AHA_MBO_FREE)
1610: {
1611: printf("aha%d not taking commands!\n"
1612: ,unit);
1613: Debugger();
1614: }
1615: /***************************************\
1616: * If it has been through before, then *
1617: * a previous abort has failed, don't *
1618: * try abort again *
1619: \***************************************/
1620: if(ccb->flags == CCB_ABORTED) /* abort timed out */
1621: {
1622: printf(" AGAIN\n");
1623: ccb->xfer->retries = 0; /* I MEAN IT ! */
1624: ccb->host_stat = AHA_ABORTED;
1625: aha_done(unit,ccb);
1626: }
1627: else /* abort the operation that has timed out */
1628: {
1629: printf("\n");
1630: aha_abortmbx(ccb->mbx);
1631: /* 2 secs for the abort */
1632: aha_add_timeout(ccb,2000 + ONETICK);
1633: ccb->flags = CCB_ABORTED;
1634: }
1635: }
1636: else
1637: /***********************************************\
1638: * It has not timed out, adjust and leave *
1639: \***********************************************/
1640: {
1641: ccb->delta -= ONETICK;
1642: aha_furtherest -= ONETICK;
1643: break;
1644: }
1645: }
1646: splx(s);
1647: timeout(aha_timeout,arg,SLEEPTIME);
1648: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.