![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to hai154x.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / b / STREAMS / io.386|
Return to hai154x.c CVS log | Up to [MW Coherent from dump] / coherent / b / STREAMS / io.386 |
1.1 root 1: /***********************************************************************
2: * Module: hai154x.c
3: *
4: * Host Adapter Interface routines for the Adaptec AHA154XX series
5: * of host adapters.
6: *
7: * Much of the information used to create this driver was obtained
8: * from the AHA1540B/1542B Technical Reference Manual available from
9: * Adaptec by phone or snail mail at:
10: *
11: * Adaptec - Literature Department
12: * 691 South Milpitas Blvd.
13: * Milpitas, CA 95035
14: * (408) 945-8600
15: *
16: * Copyright (c), 1993 Christopher Sean Hilton, All Rights Reserved.
17: *
18: * Last Modified: Sat Jul 24 08:44:54 1993 by [chris]
19: *
20: */
21:
22: #define HA_MODULE /* Host Adaptor Module */
23: #define LOUIS_HACK 1 /* defined for Louis' hacks */
24:
25: #include <stddef.h>
26: #include <sys/coherent.h>
27: #include <sys/con.h>
28: #include <sys/devices.h>
29: #include <sys/types.h>
30: #include <sys/hdioctl.h>
31:
32: #include <sys/haiscsi.h>
33:
34: /*
35: * Configurable variables - see /etc/conf/hai/Space.c
36: */
37: extern unsigned short AHABASE;
38: extern unsigned short AHAINTR;
39: extern unsigned short AHADMACHAN;
40:
41: extern int HAI_SD_HDS;
42: extern int HAI_SD_SPT;
43:
44: #define CTRLREG (AHABASE + 0) /* Control Register (Write) */
45: #define HRST bit(7) /* Hard Reset */
46: #define SRST bit(6) /* Soft Reset */
47: #define IRST bit(5) /* Interrupt Reset */
48: #define SCRST bit(4) /* SCSI Bus Reset */
49:
50: #define STSREG (AHABASE + 0) /* Status Register (Read) */
51: #define STST bit(7) /* Self Test in progress */
52: #define DIAGF bit(6) /* Internal Diagnostic Failure */
53: #define INIT bit(5) /* Mailbox Initialization Required */
54: #define IDLE bit(4) /* SCSI Host Adapter Idle */
55: #define CDF bit(3) /* Command/Data Out Port Full */
56: #define DF bit(2) /* Data In Port Full */
57: #define INVDCMD bit(0) /* Invalid HA Command */
58:
59: #define CMDDATAOUT (AHABASE + 1) /* Command/Data Out (Write) */
60: #define NOP 0x00 /* No Operation (really?) */
61: #define MBINIT 0x01 /* Mail Box Initialization */
62: #define STARTSCSI 0x02 /* Start a SCSI Command */
63: #define STARTBIOS 0x03 /* Start a BIOS Command */
64: #define HAINQUIRY 0x04 /* HA Inquiry */
65: #define ENBLMBOA 0x05 /* Enable Mailbox Out Available Interrupt */
66: #define STSELTO 0x06 /* Set Selection Timeout */
67: #define SETBUSON 0x07 /* Set Bus on time */
68: #define SETBUSOFF 0x08 /* Set Bus off time */
69: #define SETXFER 0x09 /* Set transfer speed */
70: #define RETINSTDEV 0x0a /* Return Installed Devices */
71: #define RETCFGDATA 0x0b /* Return Configuration Data */
72: #define ENBLTRGTMD 0x0c /* Enable Target Mode */
73: #define RETSUDATA 0x0d /* Return Setup Data */
74:
75: #define DATAIN (AHABASE + 1)
76:
77: #define INTRFLGS (AHABASE + 2)
78: #define ANYINTR bit(7) /* Any Interrupt */
79: #define SCRD bit(3) /* SCSI Reset Detected */
80: #define HACC bit(2) /* HA Command Complete */
81: #define MBOA bit(1) /* MBO Empty */
82: #define MBIF bit(0) /* MBI Full */
83:
84: #define MBOFREE 0x00 /* Mailbox out is free */
85: #define MBOSTART 0x01 /* Start CCB in this Mailbox */
86: #define MBOABORT 0x02 /* Abort CCB in this Mailbox */
87:
88: #define MBIFREE 0x00 /* Mailbox in is free */
89: #define MBISUCCESS 0x01 /* Mailbox's CCB Completed Successfully */
90: #define MBIABORTED 0x02 /* Mailbox's CCB Aborted */
91: #define MBIABRTFLD 0x03 /* CCB to Abort not found */
92: #define MBIERROR 0x04 /* CCB Completed with error */
93:
94: #define TIMEOUT -1 /* Timeout from pollxxx() functions. */
95:
96: #define ST_HAINIT 0x0001 /* Host Adapter being initialized */
97: #define ST_HAIDLE 0x0002 /* Host Adapter is idle */
98:
99: /***********************************************************************
100: * Types
101: */
102:
103: #pragma align 1
104:
105: typedef union addr3_u { /* addr3_u for big/little endian conversions */
106: unsigned long value;
107: unsigned char byteval[sizeof(unsigned long)];
108: } addr3_t;
109:
110: typedef union mbo_u *mbo_p; /* Out Box to host adapter */
111:
112: typedef union mbo_u {
113: unsigned char cmd;
114: paddr_t ccbaddr;
115: } mbo_t;
116:
117: typedef union mbi_u *mbi_p; /* In Box from host adapter */
118:
119: typedef union mbi_u {
120: unsigned char sts;
121: paddr_t ccbaddr;
122: } mbi_t;
123:
124: typedef struct mb_s { /* Host adapter mailbox type */
125: mbo_t o[MAXDEVS]; /* One out box for each device */
126: mbi_t i[MAXDEVS]; /* One in box for each possible reply */
127: } mb_t;
128:
129: typedef struct haccb_s *haccb_p; /* Host Adapter Command/Control Block */
130:
131: typedef struct haccb_s {
132: unsigned char opcode;
133: unsigned char addrctrl;
134: unsigned char cdblen;
135: unsigned char senselen;
136: unsigned char datalen[3];
137: unsigned char bufaddr[3];
138: unsigned char linkaddr[3];
139: unsigned char linkid;
140: unsigned char hoststs;
141: unsigned char trgtsts;
142: unsigned char pad[2];
143: cdb_t cdb;
144: } haccb_t;
145:
146: typedef struct dsentry_s *dsentry_p;
147:
148: typedef struct dsentry_s {
149: unsigned char size[3];
150: unsigned char addr[3];
151: } dsentry_t;
152:
153: typedef struct dslist_s *dslist_p;
154:
155: typedef struct dslist_s {
156: dsentry_t entries[16];
157: } dslist_t;
158:
159: #pragma align
160:
161: /***********************************************************************
162: * Variables
163: */
164:
165: static int hastate; /* Host Adapter State */
166: static mb_t mb; /* Mailboxes for host adapter */
167: static haccb_t ccb[MAXDEVS]; /* CCB's for mailboxes */
168: static paddr_t ccbbase; /* ccbbase address for quick checkmail */
169: static srb_p actv[MAXDEVS]; /* Active srb's for each target */
170: static dslist_t ds[MAXDEVS]; /* Data segment lists one for each target */
171: static unsigned chkport = 0, /* Port for chkset/ckhclr */
172: chkstop = 0, /* Target value for chkset/chkclr */
173: chkval = 0; /* Value in port chkset/chkclr */
174: int hapresent; /* Host adapter present flag */
175:
176: /***********************************************************************
177: * Support Functions
178: */
179:
180: #define min(a, b) (((a) <= (b)) ? (a) : (b))
181:
182: /***********************************************************************
183: * chkclr() -- Check port (chkport) for bits (chkstop) to be clear.
184: * If clear return 1 else return 0. Leave value of
185: * port in chkval;
186: */
187:
188: static int chkclr()
189:
190: {
191: return ((chkval = inb(chkport)) & chkstop) == 0;
192: } /* chkclr() */
193:
194: /***********************************************************************
195: * chkset() -- Check port (chkport) for bits (chkstop) to be set.
196: * If all bits are set return 1 else return 0. Leave
197: * value of port in chkval.
198: */
199:
200: static int chkset()
201:
202: {
203: return ((chkval = inb(chkport)) & chkstop) == chkstop;
204: } /* chkset() */
205:
206: /***********************************************************************
207: * pollclr() -- Wait usec milliseconds for bit(s) to clear in a
208: * port.
209: */
210:
211: static int pollclr(port, bits, usec)
212: register unsigned port; /* port to watch */
213: register unsigned bits; /* bits to watch for */
214: unsigned usec; /* number of milliseconds to wait for */
215: {
216: register s;
217:
218: s = sphi();
219: chkport = port;
220: chkstop = bits;
221: busyWait(chkclr, usec);
222: spl(s);
223:
224: #if 1 /* DEBUG */
225: if ((chkval & bits) == 0)
226: return chkval;
227: else {
228: printf("pollclr: <Timeout Reg: 0x%x mask 0x%x value 0x%x>\n", port, bits, chkval);
229: return TIMEOUT;
230: }
231: #else
232: return ((chkval & bits) == 0) ? chkval : TIMEOUT;
233: #endif
234: } /* pollclr() */
235:
236: /***********************************************************************
237: * pollset() -- Wait usec milliseconds for bit(s) set in a port.
238: */
239:
240: static int pollset(port, bits, usec)
241: register unsigned port; /* port to watch */
242: register unsigned bits; /* bits to watch for */
243: unsigned usec; /* number of milliseconds to wait for */
244: {
245: register s;
246:
247: s = sphi();
248: chkport = port;
249: chkstop = bits;
250: busyWait(chkset, usec);
251: spl(s);
252:
253: #if 1 /* DEBUG */
254: if ((chkval & bits) == bits)
255: return chkval;
256: else {
257: printf("pollset: <Timeout Reg: 0x%x mask 0x%x value 0x%x>\n", port, bits, chkval);
258: return TIMEOUT;
259: }
260: #else
261: return ((chkval & bits) == bits) ? chkval : TIMEOUT;
262: #endif
263: } /* pollset() */
264:
265: /***********************************************************************
266: * hacc()
267: *
268: * Host Adapter Command Completed - Returns 1 if last host adapter
269: * command completed without error.
270: */
271:
272: static int hacc()
273:
274: {
275: register unsigned stsreg;
276:
277: #ifdef LOUIS_HACK
278: register unsigned louis_stsreg;
279: if((louis_stsreg = pollset(INTRFLGS, HACC, 350)) == TIMEOUT)
280: return 0;
281: printf("HACC - louis_stsreg: 0x%x\n", louis_stsreg);
282: #else
283: if (pollset(INTRFLGS, HACC, 350) == TIMEOUT)
284: return 0;
285: #endif
286:
287: stsreg = pollset(STSREG, IDLE, 350) & (IDLE | INIT | CDF | INVDCMD);
288: if (stsreg != IDLE) {
289: printf("Aha154x stuck - STSREG: 0x%x\n", stsreg);
290: return 0;
291: }
292: return 1;
293: } /* hacc() */
294:
295: /***********************************************************************
296: * haidle()
297: *
298: * Returns 1 if the Idle Bit is on in the adapter status register
299: */
300:
301: #define haidle() (pollset(STSREG, IDLE, 350) != TIMEOUT)
302:
303: /***********************************************************************
304: * gethabyte()
305: *
306: * Get a byte from the host adapter Data In register.
307: */
308:
309: static int gethabyte()
310:
311: {
312: if (pollset(STSREG, DF, 350) == TIMEOUT) {
313: printf("haiscsi: <gethabyte timeout (0x%x) 0x%x 0x%x>\n", STSREG, DF, chkval);
314: return TIMEOUT;
315: }
316: else
317: return (inb(DATAIN) & 0xff);
318: } /* gethabyte() */
319:
320: /***********************************************************************
321: * puthabyte()
322: *
323: * Write a byte to the host adapter Command/Data Out Register.
324: */
325:
326: static int puthabyte(b)
327: unsigned char b;
328:
329: {
330: if (pollclr(STSREG, CDF, 350) == TIMEOUT)
331: return 0;
332: else {
333: outb(CMDDATAOUT, b);
334: return 1;
335: }
336: } /* puthabyte() */
337:
338: /***********************************************************************
339: * is_154x()
340: *
341: * Returns a string indicating the type and revision of the AHA154x
342: * host adapter on the bus if it is out there. Caveat: if something
343: * else is out there that can respond to this message I don't know
344: * what will happen.
345: */
346:
347: static int is_154x(haport)
348: unsigned haport;
349: {
350: char buf[4],
351: *p;
352: int ch,
353: oldhaport,
354: s,
355: r = 0;
356:
357: oldhaport = AHABASE;
358: s = sphi();
359: AHABASE = haport;
360: if (haidle() && puthabyte(HAINQUIRY)) {
361: for (p = buf; p < buf + sizeof(buf); ++p) {
362: ch = gethabyte();
363: if (ch == TIMEOUT)
364: break;
365: else
366: *p = ch;
367: }
368: if (p >= buf + sizeof(buf)) {
369: outb(CTRLREG, IRST);
370: if ((pollset(STSREG, IDLE, 350) & IDLE) == IDLE) {
371: if (buf[0] == '\0') {
372: printf("AHA-1540 with 16 Head BIOS Detected\n");
373: /* SDS_HDS = 16; Should we? */
374: }
375: r = 1;
376: }
377: }
378: }
379: AHABASE = oldhaport;
380: spl(s);
381: return r;
382: } /* is_154x() */
383:
384: /***********************************************************************
385: * hareset()
386: *
387: * Reset the host adapter and leave it ready for operation.
388: */
389:
390: static int hareset()
391:
392: {
393: paddr_t mbaddr; /* Mail box array's paddr. */
394: int mbiok, /* Mail box initialization proceding ok */
395: stsreg, /* local copy of STSREG */
396: retval, /* return value */
397: s;
398:
399: retval = 0;
400: s = sphi();
401: outb(CTRLREG, SRST);
402: if ((stsreg = pollclr(STSREG, STST, 350)) == TIMEOUT)
403: printf("AHA-154x: Reset failed, host adapter stuck.\n");
404: else
405: #ifdef LOUIS_HACK
406: printf("Resetting - stsreg: 0x%x\n", stsreg);
407: #endif
408: if ((stsreg & DIAGF) || (stsreg & (INIT | IDLE)) != (INIT | IDLE))
409: printf("AHA-154x: Reset/diagnostics failed.\n");
410: else {
411:
412: mbaddr = vtop(&mb);
413: #ifdef LOUIS_HACK
414: printf("init commands bytes will be:\n");
415: printf(" MBINIT: 0x%x, COUNT: 0x%x, ADDR_MSB: 0x%x, ADDR_2: 0x%x, ADDR_LSB: 0x%x\n", \
416: MBINIT, (sizeof(mb) / (sizeof(mbo_t) + sizeof(mbi_t))), ((unsigned char *) &mbaddr)[2], \
417: ((unsigned char *) &mbaddr)[1], ((unsigned char *) &mbaddr)[0]);
418: #endif
419: mbiok = 1;
420: mbiok &= puthabyte(MBINIT);
421: mbiok &= puthabyte(sizeof(mb) / (sizeof(mbo_t) + sizeof(mbi_t)));
422: mbiok &= puthabyte(((unsigned char *) &mbaddr)[2]);
423: mbiok &= puthabyte(((unsigned char *) &mbaddr)[1]);
424: mbiok &= puthabyte(((unsigned char *) &mbaddr)[0]);
425: if (!mbiok || !hacc())
426: printf("AHA-154x: Mailbox initialization failed.\n");
427: else
428: retval = 1;
429: }
430: spl(s);
431: return retval;
432: } /* hareset() */
433:
434: /***********************************************************************
435: * dmacascade()
436: *
437: * Set the selected (AHADMACHAN) dma channel to cascade mode.
438: */
439:
440: static void dmacascade()
441:
442: {
443: int dmaporta, dmaportb, s;
444:
445: s = sphi();
446: if (AHADMACHAN == 0) {
447: dmaporta = 0x0b;
448: dmaportb = 0x0a;
449: } else {
450: dmaporta = 0xd6;
451: dmaportb = 0xd4;
452: }
453: outb(dmaporta, 0xc0 | (AHADMACHAN & 3));
454: outb(dmaportb, (AHADMACHAN & 3));
455: spl(s);
456: } /* dmacascade() */
457:
458: /***********************************************************************
459: * checkmail()
460: *
461: * Check the incoming mailboxes for messages. Do this on any Mail
462: * Box In Full interrupt and before you fail a command for timeout.
463: * The code to determine which target device finished by tid is a
464: * bit tricky and relies on the following assumptions:
465: *
466: * 1) The host adapter is installed in a Intel (big-endian)
467: * machine. Believe it or not there is (are) non-Intel CPU
468: * ISA bus machines. and the one that I know of is a M68000
469: * machine where this would not work.
470: *
471: * 2) The kernel's data space is physically contiguous and is
472: * never swapped out.
473: */
474:
475: static int checkmail()
476:
477: {
478: static int startid = 0;
479: int msgs = 0;
480: int sts;
481: int s;
482: register int id;
483: register srb_p r;
484: register int i = startid;
485:
486: do {
487: if (mb. i[i]. sts != MBIFREE) {
488: s = sphi();
489: sts = mb. i[i]. sts;
490: flip(mb. i[i]. ccbaddr);
491: id = (unsigned) ((mb. i[i]. ccbaddr & 0x00ffffffL) - ccbbase) / sizeof(haccb_t);
492: if (r = actv[id]) {
493: switch (sts) {
494: case MBIABRTFLD:
495: devmsg(r->dev, "Command 0x%x abort failed\n", r->cdb. g0. opcode);
496: case MBISUCCESS:
497: case MBIERROR:
498: r->status = ccb[id]. trgtsts;
499: break;
500: case MBIABORTED:
501: devmsg(r->dev, "Command 0x%x aborted successfully\n", r->cdb. g0. opcode);
502: r->status = ST_DRVABRT;
503: break;
504: default:
505: printf("Host Adapter Mailbox In value corrupted\n");
506: break;
507: }
508:
509: actv[id] = NULL;
510: if (r->cleanup)
511: (*(r->cleanup))(r);
512: msgs |= bit(id);
513: }
514: mb. i[i]. ccbaddr = 0;
515: spl(s);
516: }
517: else if (msgs)
518: break;
519: i = (i + 1) & 7;
520: } while (i != startid);
521: startid = i;
522:
523: return msgs;
524: } /* checkmail() */
525:
526: /***********************************************************************
527: * Driver Interface Functions
528: */
529:
530: /***********************************************************************
531: * hatimer()
532: *
533: * Host adapter Timeout handler.
534: */
535:
536: void hatimer()
537:
538: {
539: register int id;
540: register srb_p r;
541: register int active;
542: int s;
543:
544: s = sphi();
545: checkmail(); /* Cleanup any missed interrupts, etc. */
546: active = 0;
547: for (id = 0; id < MAXDEVS; ++id) {
548: if ((r = actv[id]) != NULL && r->timeout != 0) {
549: if (--r->timeout == 0) {
550: abortscsi(r);
551: r->status = ST_DRVABRT;
552: }
553: else
554: active = 1;
555: }
556: }
557: drvl[SCSIMAJOR]. d_time = active;
558: spl(s);
559: } /* hatimer() */
560:
561: /***********************************************************************
562: * haintr()
563: *
564: * SCSI interrupt handler for host adapter.
565: */
566:
567: void haintr()
568:
569: {
570: int intrflgs;
571:
572: intrflgs = inb(INTRFLGS);
573: if (intrflgs & ANYINTR)
574: outb(CTRLREG, IRST);
575:
576: if (hastate == ST_HAINIT)
577: return;
578: if (intrflgs & MBIF) {
579: checkmail();
580: return;
581: }
582: } /* haintr() */
583:
584: /***********************************************************************
585: * hainit()
586: *
587: * Initialize the host adapter for operation.
588: */
589:
590: int hainit()
591:
592: {
593: register int i;
594:
595: hastate = ST_HAINIT;
596: hapresent = 0;
597: printf("Host Adapter Module: AHA-154x v1.1\n");
598: if (!is_154x(AHABASE)) {
599: printf("hainit() failed: Adaptec AHA-154x not found.\n");
600: return 0;
601: }
602:
603: setivec(AHAINTR, haintr);
604: if (!(hapresent = hareset())) {
605: printf("hainit() failed: Could not initialize AHA-154x at (0x%x)\n", AHABASE);
606: return 0;
607: }
608:
609: for (i = 0; i < MAXDEVS; ++i) {
610: actv[i] = NULL;
611: mb. o[i]. ccbaddr = vtop(ccb + i);
612: flip(mb. o[i]. ccbaddr);
613: mb. o[i]. cmd = MBOFREE;
614: }
615: ccbbase = vtop(ccb);
616: dmacascade();
617: hastate = ST_HAIDLE;
618: return 1;
619: } /* hainit() */
620:
621: /***********************************************************************
622: * mkdslist()
623: *
624: * Make an Adaptec Data Segment list for a Scatter/Gather Request.
625: * Input: d - the memory area for the Scatter/Gather List.
626: * b - the bufaddr structure for the memory block.
627: */
628:
629: static int mkdslist(d, b)
630: register dsentry_p d;
631: bufaddr_p b;
632: {
633: paddr_t p_start;
634: size_t p_size;
635: paddr_t p_next;
636: int segments = 1;
637: register unsigned long start;
638: register unsigned long end;
639: dsentry_p l = d;
640:
641: switch (b->space) {
642: case KRNL_ADDR: /* Kernal Address */
643: case USER_ADDR: /* User Address (Anything goes) */
644: start = b->addr. caddr;
645: p_start = vtop(start);
646: break;
647: case SYSGLBL_ADDR: /* System Global address (yeah) */
648: start = b->addr. paddr;
649: p_start = P2P(start);
650: break;
651: case PHYS_ADDR: /* Physical Address - (who knows) */
652: default:
653: return 0;
654: }
655: end = start + b->size;
656: p_size = min(NBPC - (p_start & (NBPC - 1)), end - start);
657:
658: for ( ; ; ) {
659: d->size[2] = ((unsigned char *) &p_size)[0];
660: d->size[1] = ((unsigned char *) &p_size)[1];
661: d->size[0] = ((unsigned char *) &p_size)[2];
662: d->addr[2] = ((unsigned char *) &p_start)[0];
663: d->addr[1] = ((unsigned char *) &p_start)[1];
664: d->addr[0] = ((unsigned char *) &p_start)[2];
665: if (start + p_size >= end)
666: return segments;
667:
668: p_next = (b->space == SYSGLBL_ADDR) ? P2P(start + p_size) :
669: vtop(start + p_size);
670: if (p_next == p_start + p_size)
671: /* Continue Last Segment */
672: p_size += min(NBPC, end - start - p_size);
673: else {
674: /* Start New Segment */
675: p_start = p_next;
676: start += p_size;
677: p_size = min(NBPC, end - start);
678: ++d;
679: if (++segments > (sizeof(dslist_t) / sizeof(dsentry_t)))
680: return 0;
681: }
682: }
683: } /* mkdslist() */
684:
685: /***********************************************************************
686: * startscsi()
687: *
688: * Send a SCSI CDB to a target device on the bus.
689: */
690:
691: int startscsi(r)
692: register srb_p r;
693: {
694: register haccb_p c;
695: paddr_t bufaddr;
696: size_t datalen;
697: register int s;
698:
699: if (r->target >= MAXDEVS || r->lun >= MAXUNITS) {
700: printf("Illegal device ID: %d LUN: %d", r->target, r->lun);
701: return 0;
702: }
703:
704: ++r->tries;
705: if (actv[r->target]) {
706: devmsg(r->dev,
707: "Device busy: old opcode (0x%x) new opcode (0x%x)",
708: ccb[r->target]. cdb. g0. opcode,
709: r->cdb. g0. opcode);
710: return 0;
711: }
712:
713: s = sphi();
714: r->status = ST_PENDING;
715: c = ccb + r->target;
716: memset(c, 0, sizeof(haccb_t));
717: c->opcode = 0; /* Start SCSI CDB */
718: c->addrctrl = (r->target << 5) | (r->lun & 7);
719: if (r->xferdir & DMAREAD) c->addrctrl |= 0x08;
720: if (r->xferdir & DMAWRITE) c->addrctrl |= 0x10;
721: c->cdblen = cpycdb(&(c->cdb), &(r->cdb));
722: c->senselen = 1;
723:
724: /***********************************************************************
725: * Set up the CCB's Address here. This turned out to be a bit more
726: * complicated than I thought it would be.
727: */
728:
729: if (r->buf. space == PHYS_ADDR) {
730: c->datalen[0] = ((unsigned char *) &(r->buf. size))[2];
731: c->datalen[1] = ((unsigned char *) &(r->buf. size))[1];
732: c->datalen[2] = ((unsigned char *) &(r->buf. size))[0];
733: c->bufaddr[0] = ((unsigned char *) &(r->buf. addr. paddr))[2];
734: c->bufaddr[1] = ((unsigned char *) &(r->buf. addr. paddr))[1];
735: c->bufaddr[2] = ((unsigned char *) &(r->buf. addr. paddr))[0];
736: }
737: else {
738: datalen = mkdslist(ds[r->target]. entries, &(r->buf));
739: if (datalen == 0) {
740: printf("SCSI ID %d - Bad Scatter/Gather list\n", r->target);
741: spl(s);
742: return 0;
743: }
744: else if (datalen == 1)
745: memcpy(c->datalen, ds[r->target]. entries, 6);
746: else {
747: c->opcode = 2;
748: bufaddr = vtop(ds[r->target]. entries);
749: datalen *= 6;
750: c->datalen[0] = ((unsigned char *) &datalen)[2];
751: c->datalen[1] = ((unsigned char *) &datalen)[1];
752: c->datalen[2] = ((unsigned char *) &datalen)[0];
753: c->bufaddr[0] = ((unsigned char *) &bufaddr)[2];
754: c->bufaddr[1] = ((unsigned char *) &bufaddr)[1];
755: c->bufaddr[2] = ((unsigned char *) &bufaddr)[0];
756: }
757: }
758:
759: mb. o[r->target]. cmd = MBOSTART;
760: if (puthabyte(STARTSCSI) && (inb(STSREG) & INVDCMD) == 0) {
761: actv[r->target] = r;
762: if (r->timeout)
763: drvl[SCSIMAJOR]. d_time = 1;
764: }
765: else {
766: printf("startscsi() failed: Resetting host adapter.\n");
767: mb. o[r->target]. cmd = MBOFREE;
768: actv[r->target] = NULL;
769: r->status = ST_DRVABRT;
770: if (r->cleanup)
771: (*r->cleanup)(r);
772: hapresent = hareset();
773: return 0;
774: }
775:
776: spl(s);
777: return 1;
778: } /* startscsi() */
779:
780: /***********************************************************************
781: * abortscsi()
782: *
783: * Abort the SCSI Command at a target device on the bus.
784: */
785:
786: void abortscsi(r)
787: register srb_p r;
788: {
789: int s,
790: tries;
791:
792: printf("abortscsi(id: %d opcode: (0x%x))\n", r->target, r->cdb. g0. opcode);
793: s = sphi();
794: r->timeout = 0;
795: for (tries = 10; hapresent && tries > 0; --tries) {
796: mb. o[r->target]. cmd = MBOABORT;
797: if (puthabyte(STARTSCSI) && (inb(STSREG) & INVDCMD) == 0)
798: break;
799:
800: printf("abortscsi(): AHA-154x Command start failed.\n");
801: hapresent = hareset();
802: }
803:
804: if (tries <= 0)
805: printf("abortscsi() failed: Cannot reach host adapter\n");
806: else {
807: busyWait(checkmail, 1000);
808:
809: if (r->status == ST_PENDING) {
810: printf("abortscsi() failed: id %d\n", r->target);
811: resetdevice(r->target);
812:
813: actv[r->target] = NULL;
814: r->status = ST_DRVABRT;
815: if (r->cleanup)
816: (*r->cleanup)(r);
817: }
818: }
819:
820: spl(s);
821: } /* abortscsi() */
822:
823: /***********************************************************************
824: * resetdevice()
825: *
826: * Reset a SCSI target.
827: */
828:
829: void resetdevice(id)
830: register int id;
831: {
832: register haccb_p c = &(ccb[HAI_HAID]);
833: int tries;
834:
835: c->opcode = 0x81;
836: c->addrctrl = (id << 5);
837: for (tries = 10; tries > 0; --tries) {
838: if (!hapresent)
839: hapresent = hareset();
840: if (hapresent) {
841: mb. o[HAI_HAID]. cmd = MBOSTART;
842: if (puthabyte(STARTSCSI) && (inb(STSREG) & INVDCMD) == 0)
843: break;
844: }
845: }
846: } /* resetdevice() */
847:
848: /***********************************************************************
849: * haihdgeta() -- Get disk driver paramters.
850: *
851: * This function is provided to support the HDGETA/HDSETA I/O Controls
852: * so you don't need the old Adaptec SCSI driver to set up the partition
853: * table on initial setup. There is a catch-22 with this. You need
854: * to know the drive's geometry in order to set up the partition table
855: * but cannot get the drive's geometry until you have set up the partition
856: * table. We solve this by using the drive's size and then dividing
857: * down based upon SDS_HDS heads and SDS_SPT sectors per track. Every
858: * host adapter will want to do this differently. The Adaptec solution
859: * is the best that I've seen so far. (It allows you to use Huge (1.0
860: * GB) disks under DOS without trouble.
861: */
862:
863: void haihdgeta(hdp, diskcap)
864: register hdparm_t *hdp;
865: register unsigned diskcap;
866: {
867: unsigned short ncyl = (unsigned short) (diskcap / (HAI_SD_HDS * HAI_SD_SPT)),
868: landc = ncyl,
869: rwccp = 0xffff,
870: wpcc = 0xffff;
871:
872: memset(hdp, 0, sizeof(hdparm_t));
873: *((unsigned short *) hdp->ncyl) = ncyl;
874: *((unsigned short *) hdp->rwccp) = rwccp;
875: *((unsigned short *) hdp->wpcc) = wpcc;
876: *((unsigned short *) hdp->landc) = landc;
877:
878: hdp->nhead = HAI_SD_HDS;
879: if (hdp->nhead > 8)
880: hdp->ctrl |= 8;
881: hdp->nspt = HAI_SD_SPT;
882: } /* haihdseta() */
883:
884: /***********************************************************************
885: * haihdseta() -- Set disk parameters in accordance with HDSETA
886: * I/O Control.
887: *
888: * Set the disk paramters accordingly for a request from the fdisk
889: * program. This call really doesn't do anything on the adaptec or
890: * in the SCSI driver in general because SCSI Disks use Logical Block
891: * addressing rather than Cylinder/Head/Track addressing found with
892: * less intelligent Disk drive types. What this will do is allow
893: * the fdisk program to work so a user can format his disk and install
894: * Coherent on it (A Good Thing). This boils down to a fancy way to
895: * patch SDS_HDS and SDS_SPT.
896: */
897:
898: void haihdseta(hdp)
899: register hdparm_t *hdp;
900: {
901: HAI_SD_HDS = hdp->nhead;
902: HAI_SD_SPT = hdp->nspt;
903: } /* haihdseta() */
904:
905: /* End of file */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.