![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ss.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 / kernel / io.386|
Return to ss.c CVS log | Up to [MW Coherent from dump] / coherent / b / kernel / io.386 |
1.1 root 1: /*
2: * io.386/ss.c
3: *
4: * Device driver for Seagate ST01/ST02 scsi host adapters.
5: *
6: * Revised: Wed May 26 16:57:51 1993 CDT
7: */
8:
9: /*
10: * To do:
11: * nonzero LUN's
12: * start new command during disconnect
13: * rewrite as single state machine, instead of 7 of them
14: * separate SCSI layer from host-dependent stuff
15: */
16:
17: /*
18: * Debug levels.
19: * DEBUG = 0 No debug output.
20: * DEBUG = 1 Debug output on error only.
21: * DEBUG = 2 Debug output on error and at other selected places.
22: * DEBUG = 3 Print state machine trace.
23: * DEBUG = 4 Print info xfer phases and msg_in values.
24: */
25: #if (DEBUG >= 1)
26: static int s_id;
27: #define PR1(str) printf("%s%d ", str, s_id)
28: #else
29: #define PR1(str)
30: #endif
31: #if (DEBUG >= 2)
32: #define PR2(str) printf(str)
33: #else
34: #define PR2(str)
35: #endif
36: #if (DEBUG >= 3)
37: #define PR3(str) printf("%s%d ", str, s_id)
38: #else
39: #define PR3(str)
40: #endif
41: #if (DEBUG >= 4)
42: #define PR4(str) printf("%s%d ", str, s_id)
43: #else
44: #define PR4(str)
45: #endif
46:
47: /*
48: * Includes.
49: */
50: #include <sys/coherent.h>
51:
52: #ifdef _I386
53: #include <sys/fakeff.h>
54: #include <sys/dmac.h>
55: #endif
56: #include <sys/io.h>
57: #include <sys/sched.h>
58: #include <sys/uproc.h>
59: #include <sys/proc.h>
60: #include <sys/con.h>
61: #include <sys/stat.h>
62: #include <sys/devices.h> /* SCSI_MAJOR */
63: #include <errno.h>
64: #include <sys/fdisk.h>
65: #include <sys/hdioctl.h>
66: #include <sys/buf.h>
67: #include <sys/scsiwork.h>
68: #include <sys/typed.h>
69:
70: /*
71: * Definitions.
72: * Constants.
73: * Macros with argument lists.
74: * Typedefs.
75: * Enums.
76: */
77: #define SS_RAM 0x1800 /* Offset of parameter RAM */
78:
79: /* Future Domain */
80: #define FD_CSR 0x1C00 /* Offset of control/status register */
81: #define FD_DAT 0x1E00 /* Offset of data port */
82:
83: /* Seagate */
84: #define SS_CSR 0x1A00 /* Offset of control/status register */
85: #define SS_DAT 0x1C00 /* Offset of data port */
86:
87: #define SS_RAM_LEN 128 /* ST0x has 128 bytes of RAM */
88: #define SS_DAT_LEN 0x400 /* Byte range mapped to data port */
89: #define SS_SEL_LEN 0x2000 /* Total size of memory-mapped area */
90:
91: #define WC_ENABLE_SCSI 0x80 /* Write Control (WC) register bits */
92: #define WC_ENABLE_IRPT 0x40
93: #define WC_ENABLE_PRTY 0x20
94: #define WC_ARBITRATE 0x10
95: #define WC_ATTENTION 0x08
96: #define WC_BUSY 0x04
97: #define WC_SELECT 0x02
98: #define WC_SCSI_RESET 0x01
99:
100: #define RS_ARBIT_COMPL 0x80 /* Read STATUS (RS) register bits */
101: #define RS_PRTY_ERROR 0x40
102: #define RS_SELECT 0x20
103: #define RS_REQUEST 0x10
104: #define RS_CTRL_DATA 0x08
105: #define RS_I_O 0x04
106: #define RS_MESSAGE 0x02
107: #define RS_BUSY 0x01
108:
109: #define DEV_SCSI_ID(dev) ((dev >> 4) & 0x0007)
110: #define DEV_LUN(dev) ((dev >> 2) & 0x0003)
111: #define DEV_DRIVE(dev) ((dev >> 2) & 0x001F)
112: #define DEV_PARTN(dev) (dev & 0x0003)
113: #define DEV_SPECIAL(dev) (dev & 0x0080)
114:
115: #define HIPRI_RETRIES 5000 /* # of times to retry while hogging CPU */
116: #define LOPRI_RETRIES 5 /* # of retries with sleep between tries */
117: #define WHOLE_DRIVE NPARTN
118: #define RESET_TICKS 50 /* # of clock ticks for reset settling */
119: #define LOAD_DELAY 30000 /* Loop counter during ssload() only */
120:
121: #define BUS_FREE ((ffbyte(ss_csr) & (RS_BUSY | RS_SELECT)) == 0)
122: #define TGT_RSEL \
123: ( (ffbyte(ss_csr) & (RS_SELECT | RS_I_O )) \
124: && (ffbyte(ss_dat) & (host_id | (1<<s_id) )) )
125:
126: #define DELAY_ARB 10 /* delays units are 10 msec (clock ticks) */
127: #define DELAY_BDR 30
128: #define DELAY_BSY 20
129: #define DELAY_RES 50
130: #define DELAY_RST 40
131:
132: #define MAX_AVL_COUNT 100
133: #define MAX_BDR_COUNT 3
134: #define MAX_BSY_COUNT 3
135: #define MAX_TRY_COUNT 10
136: #define INL_MAX_REQ_POLL 800000L
137: #define WKG_MAX_REQ_POLL 20000L
138:
139: typedef enum { /* values for current driver state */
140: SST_DEQUEUE =0,
141: SST_BUS_DEV_RESET,
142: SST_HIPRI_RESET,
143: SST_LOPRI_RESET,
144: SST_POLL_ARBITN,
145: SST_POLL_BEGIN_IO,
146: SST_POLL_RESELECT,
147: SST_REQ_SENSE,
148: SST_RESET_OFF
149: } SST_TYPE;
150:
151: typedef enum { /* values for input to recovery routine */
152: RV_A_TIMEOUT,
153: RV_P_TIMEOUT,
154: RV_R_TIMEOUT,
155: RV_BF_TIMEOUT,
156: RV_CS_BUSY,
157: RV_CS_CHECK
158: } RV_TYPE;
159:
160: typedef struct ss {
161: ulong capacity;
162: ulong blocklen;
163: ulong bno;
164: int msg_in;
165: int dr_watch;
166: unchar cmdbuf[G1CMDLEN];
167: int cmdlen;
168: int cmd_bytes_out;
169: int cmdstat;
170: BUF *bp; /* current I/O request node, or NULL */
171: struct fdisk_s parmp[NPARTN+1];
172: SST_TYPE state;
173: TIM tim; /* for target-specific timers */
174: unchar avl_count;
175: unchar bdr_count;
176: unchar bsy_count;
177: unchar try_count;
178: uint busy:1; /* 1 if command uses local buffer */
179: uint expired:1; /* 1 if target's timer has expired */
180: uint ptab_read:1; /* 1 if partition table has been read */
181: uint waiting:1; /* 1 if target timer is running */
182: } ss_type;
183:
184: typedef struct {
185: uint ncyl;
186: unchar nhead;
187: unchar nspt;
188: } drv_parm_type;
189:
190: /*
191: * Functions.
192: * Import Functions.
193: * Export Functions.
194: * Local Functions.
195: */
196:
197: /* functions from bufq.c */
198: extern int bufq_init();
199: extern void bufq_rlse();
200: extern void bufq_wr_tail();
201: extern BUF * bufq_rd_head();
202: extern BUF * bufq_rm_head();
203:
204: /* functions from ssas.s */
205: extern void ss_get();
206: extern int ss_put();
207: extern int nulldev();
208: extern int nonedev();
209: #ifndef _I386
210: extern unsigned char ffbyte();
211: #endif
212:
213: static void ssopen(); /* CON functions */
214: static void ssclose();
215: static void ssblock();
216: static void ssread();
217: static void sswrite();
218: static int ssioctl();
219: static void sswatch();
220: static void ssload();
221: static void ssunload();
222:
223: static int bus_dev_reset(); /* additional support functions */
224: static int chk_reconn();
225: static void do_connect();
226: static void dummy_reconn();
227: static int far_info_xfer();
228: static int host_ident();
229: static int init_call();
230: static void init_pointers();
231: static int inquiry();
232: static int local_info_xfer();
233: static int mode_sense();
234: static void next_req();
235: static void nonpolled();
236: static int read_cap();
237: static void recover();
238: static int req_sense();
239: static int rsel_handshake();
240: static void ssdelay();
241: static void ss_finished();
242: static void ss_mach();
243: static void set_timeout();
244: static int ssinit();
245: static void ssintr();
246: static int start_arb();
247: static void stop_timeout();
248: static void tbparms();
249: static unchar xpmod();
250:
251: /*
252: * Global Data.
253: * Import Variables.
254: * Export Variables.
255: * Local Variables.
256: */
257:
258: extern short n_atdr; /* set by atcount() before any load routines run */
259:
260: CON sscon = {
261: DFBLK|DFCHR, /* Flags */
262: SCSI_MAJOR, /* Major index */
263: ssopen, /* Open */
264: ssclose, /* Close */
265: ssblock, /* Block */
266: ssread, /* Read */
267: sswrite, /* Write */
268: ssioctl, /* Ioctl */
269: nulldev, /* Powerfail */
270: sswatch, /* Timeout */
271: ssload, /* Load */
272: ssunload, /* Unload */
273: nulldev /* Poll */
274: };
275:
276: /* Patch these Export Variables to configure the driver. */
277: /*
278: * In the low byte of NSDRIVE, bit n is 1 if SCSI ID n is an installed target.
279: * The high byte indicates which type of host adapter:
280: * 00 - ST01/ST02
281: * 80 - TMC-845/850/860/875/885
282: * 40 - TMC-840/841/880/881
283: */
284: uint NSDRIVE = 0x0001;
285: uint SS_INT = 5; /* ST0[12] use either IRQ3 or IRQ5 */
286: uint SS_BASE = 0xCA00; /* Segment addr of ST0x communication area */
287:
288: /* ncyl, nhead, nspt */
289: drv_parm_type drv_parm[MAX_SCSI_ID] = {
290: { 0, 0, 0},
291: { 0, 0, 0},
292: { 0, 0, 0},
293: { 0, 0, 0},
294: { 0, 0, 0},
295: { 0, 0, 0},
296: { 0, 0, 0}
297: };
298:
299: static BUF dbuf; /* For raw I/O */
300: static paddr_t ss_base; /* physical address of ST0x comm area */
301: static faddr_t ss_fp; /* (far *) to ST0x comm area */
302:
303: static faddr_t ss_ram; /* (far *) to parameter RAM */
304: static faddr_t ss_csr; /* (far *) to control/status */
305: static faddr_t ss_dat; /* (far *) to data port */
306:
307: static TIM delay_tim; /* needed for calls to ssdelay() */
308: static int do_sst_op; /* 1 when state machine iteration continues */
309: static int ss_expired; /* 1 after local timeout */
310:
311: static uint max_req_poll; /* this changes after initialization */
312:
313: static unchar host_id; /* Host is SCSI ID #7 for Seagate, 6 for FD */
314: static unchar swap_status_bits;
315:
316: static ss_type *ss_tbl; /* points to block of "ss" structs */
317: static ss_type *ss[MAX_SCSI_ID];
318:
319: /*
320: * host_claimed is -1 if host is available, else it's the SCSI id of the
321: * target that claims the host.
322: *
323: * host is claimed at start of any of the follwoing:
324: * SCSI bus reset
325: * arbitration for block i/o request
326: * reselect
327: *
328: * host is released at:
329: * end of SCSI bus reset
330: * completion (successful or not) of block i/o request (ss_finished)
331: * disconnect <-- temporarily disabled
332: */
333: static int host_claimed;
334:
335: /*
336: * ssload() - load routine.
337: *
338: * Action: The controller is reset and the interrupt vector is grabbed.
339: * The drive characteristics are set up at this time.
340: */
341: static void ssload()
342: {
343: int erf = 0; /* 1 if error occurs */
344: int i;
345: int max_id = -1;
346: int num_drives = 0;
347: int tbnum;
348:
349:
350: /*
351: * Allocate a selector to map into ST0x memory-mapped comm area.
352: */
353: ss_base = (paddr_t)((long)(unsigned)SS_BASE << 4);
354: #ifdef _I386
355: ss_fp = map_pv(ss_base, (fsize_t)SS_SEL_LEN);
356: #else /* _I386 */
357: ss_fp = ptov(ss_base, (fsize_t)SS_SEL_LEN);
358: #endif /* _I386 */
359: ss_ram = ss_fp + SS_RAM;
360:
361: /*
362: * Primitive test of ST0x RAM.
363: */
364: sfword(ss_ram, 0xA55A);
365: sfword(ss_ram + 2, 0x3CC3);
366: sfword(ss_ram + SS_RAM_LEN - 4, 0xA55A);
367: sfword(ss_ram + SS_RAM_LEN - 2, 0x3CC3);
368: if (ffword(ss_ram) != 0xA55A /* fetch a "far" word */
369: || ffword(ss_ram + 2) != 0x3CC3
370: || ffword(ss_ram + SS_RAM_LEN - 4) != 0xA55A
371: || ffword(ss_ram + SS_RAM_LEN - 2) != 0x3CC3) {
372: printf("Error - host failed memory test\n");
373: erf = 1;
374: }
375:
376: /*
377: * Set host-dependent constants.
378: */
379: switch(NSDRIVE >> 8) {
380: case 0x00: /* ST01/ST02 */
381: ss_csr = ss_fp + SS_CSR;
382: ss_dat = ss_fp + SS_DAT;
383: host_id = 0x80; /* host is id #7 */
384: break;
385: case 0x80: /* TMC-845/850/860/875/885 */
386: ss_csr = ss_fp + FD_CSR;
387: ss_dat = ss_fp + FD_DAT;
388: host_id = 0x40; /* host is id #6 */
389: break;
390: case 0x40: /* TMC-840/841/880/881 */
391: ss_csr = ss_fp + SS_CSR;
392: ss_dat = ss_fp + SS_DAT;
393: host_id = 0x40; /* host is id #6 */
394: swap_status_bits = 1;
395: break;
396: }
397: NSDRIVE &= ~(uint)host_id;
398:
399: /*
400: * Allocate drive structs.
401: *
402: * Do a single call to kalloc() then put allocated pieces into
403: * array ss.
404: *
405: * First allocate and clear storage. Then hook up the pointers.
406: */
407: if (!erf) {
408: for (i = 0; i < MAX_SCSI_ID; i++)
409: if ((NSDRIVE >> i) & 1) {
410: max_id = i;
411: num_drives++;
412: }
413: if (num_drives == 0) {
414: printf("Error - ss has no valid target id's\n");
415: erf = 1;
416: } else if ((ss_tbl = kalloc(num_drives*sizeof(ss_type)))
417: == NULL) {
418: printf("Error - ss can't allocate structs\n");
419: erf = 1;
420: } else
421: kclear(ss_tbl, num_drives * sizeof(ss_type));
422: }
423: if (!erf) {
424: ss_type *foo = ss_tbl;
425:
426: for (i = 0; i < MAX_SCSI_ID; i++)
427: if ((NSDRIVE >> i) & 1)
428: ss[i] = foo++;
429: }
430:
431: /*
432: * Claim IRQ vector.
433: */
434: setivec(SS_INT, ssintr);
435:
436: /*
437: * Initialize drives we know about (i.e. in NSDRIVE bitmap).
438: *
439: * Part of this is getting parameters from tboot, if any.
440: * The drive number in tboot's data block must be matched with
441: * the SCSI id in question. Drive numbering in tboot is assumed
442: * to start with any "at" drives (n_atdr counts these)
443: * then proceed with SCSI drives in increasing id number order.
444: */
445: tbnum = n_atdr; /* tboot drive number for first SCSI drive */
446: host_claimed = -1;
447: bufq_init(max_id + 1);
448: max_req_poll = INL_MAX_REQ_POLL;
449: if (!erf) {
450: for (i = 0; i < MAX_SCSI_ID; i++)
451: if ((NSDRIVE >> i) & 1) {
452: tbparms(tbnum, i); /* get tboot parms */
453: ssinit(i);
454: tbnum++;
455: }
456: }
457: max_req_poll = WKG_MAX_REQ_POLL;
458: }
459:
460: /*
461: * ssunload() - unload routine.
462: */
463: static void ssunload()
464: {
465: /*
466: * Deallocate driver heap space.
467: */
468: if (ss_tbl)
469: kfree(ss_tbl);
470: bufq_rlse();
471:
472: /*
473: * Free the ST0x selector.
474: */
475: #ifdef _I386
476: unmap_pv(ss_fp);
477: #else /* _I386 */
478: vrelse(ss_fp);
479: #endif /* _I386 */
480:
481: /*
482: * Release IRQ vector.
483: */
484: clrivec(SS_INT);
485: }
486:
487: /*
488: * ssopen()
489: *
490: * Input: dev = disk device to be opened.
491: * mode = access mode [IPR,IPW, IPR+IPW].
492: *
493: * Action: Validate the minor device.
494: * Update the paritition table if necessary.
495: */
496: static void ssopen(dev, mode)
497: register dev_t dev;
498: {
499: int drive, partn;
500: struct fdisk_s *fdp;
501: ss_type * ssp;
502: int s_id;
503: unchar * msg;
504:
505: /*
506: * Set up local variables.
507: */
508: drive = DEV_SCSI_ID(dev);
509: partn = DEV_PARTN(dev);
510: s_id = DEV_SCSI_ID(dev);
511: ssp = ss[s_id];
512: fdp = ssp->parmp;
513:
514: #if (DEBUG >= 3)
515: devmsg(dev, "ssopen");
516: #endif
517:
518: /*
519: * LUN must be zero.
520: * SCSI id must have corresponding 1 in NSDRIVE bitmapped variable.
521: */
522: if (DEV_LUN(dev) != 0 || ((1 << drive) & NSDRIVE) == 0) {
523: msg = "bad LUN or SCSI id";
524: u.u_error = ENXIO;
525: goto bad_open;
526: }
527:
528: /*
529: * If "special" bit is set, partition field must be zero.
530: */
531: if (DEV_SPECIAL(dev) && partn != 0) {
532: msg = "bad special partition";
533: u.u_error = ENXIO;
534: goto bad_open;
535: }
536:
537: /*
538: * Subscripting gimmick for partition table.
539: */
540: if (dev & SDEV)
541: partn = WHOLE_DRIVE;
542:
543: /*
544: * If not accessing whole drive and the partition table has not
545: * been read yet, try to read it now.
546: * Do this by calling fdisk() with partition table device on the drive
547: * that is being accessed.
548: */
549: if (partn != WHOLE_DRIVE && !(ssp->ptab_read)) {
550: int fdisk_dev;
551:
552: fdisk_dev = (dev | SDEV) & 0xfff0;
553:
554: #if (DEBUG >=3)
555: devmsg(fdisk_dev, "calling fdisk");
556: if (fdisk(fdisk_dev, fdp)) {
557: int p;
558:
559: fdp[WHOLE_DRIVE].p_size = ssp->capacity;
560: fdp[WHOLE_DRIVE].p_base = 0;
561: printf("fdisk() succeeded\n");
562: for (p=0; p<WHOLE_DRIVE; p++)
563: printf("p=%d base=%ld size=%ld\n", p, fdp[p].p_base, fdp[p].p_size);
564: ssp->ptab_read = 1;
565: } else {
566: printf("fdisk() failed\n");
567: u.u_error = ENXIO;
568: goto bad_open;
569: }
570: #else
571: if (fdisk(fdisk_dev, fdp)) {
572: fdp[WHOLE_DRIVE].p_size = ssp->capacity;
573: fdp[WHOLE_DRIVE].p_base = 0;
574: ssp->ptab_read = 1;
575: } else {
576: msg = "bad partition table";
577: u.u_error = ENXIO;
578: goto bad_open;
579: }
580: #endif
581:
582: }
583:
584: /*
585: * Ensure partition lies within drive boundaries and is non-zero size.
586: */
587: if (partn != WHOLE_DRIVE
588: && (fdp[partn].p_base+fdp[partn].p_size) > fdp[WHOLE_DRIVE].p_size) {
589: msg = "partition exceeds drive capacity";
590: #ifdef _I386
591: u.u_error = EINVAL;
592: #else
593: u.u_error = EBADFMT;
594: #endif /* _I386 */
595: goto bad_open;
596: }
597:
598: if (partn != WHOLE_DRIVE && fdp[partn].p_size == 0) {
599: msg = "partition not found";
600: u.u_error = ENODEV;
601: goto bad_open;
602: }
603:
604: /*
605: * OK to open the device.
606: * Start watchdog timer (if not already started) for the host adapter.
607: */
608: ++drvl[SCSI_MAJOR].d_time;
609: ++ssp->dr_watch;
610: goto end_open;
611:
612: bad_open:
613: devmsg(dev, msg);
614: end_open:
615: return;
616: }
617:
618: /*
619: * ssclose()
620: */
621: static void ssclose(dev)
622: dev_t dev;
623: {
624: ss_type * ssp;
625: int s_id;
626:
627: s_id = DEV_SCSI_ID(dev);
628: ssp = ss[s_id];
629:
630: /*
631: * Decrement the number of watchdog timer requests open for host
632: * adapter and for target.
633: */
634: --drvl[SCSI_MAJOR].d_time;
635: --ssp->dr_watch;
636:
637: #if (DEBUG >= 3)
638: devmsg(dev, "ssclose");
639: #endif
640:
641: }
642:
643: /*
644: * ssread() - read a block from the raw disk
645: *
646: * Input: dev = disk device to be written to.
647: * iop = pointer to source I/O structure.
648: *
649: * Action: Invoke the common raw I/O processing code.
650: */
651: static void ssread(dev, iop)
652: dev_t dev;
653: IO *iop;
654: {
655: T_PIGGY( 0x20, printf("ssread(iop->io.vbase: %x)", iop->io.vbase); );
656:
657: ioreq( &dbuf, iop, dev, BREAD, BFRAW|BFBLK|BFIOC );
658: }
659:
660: /*
661: * sswrite() - write a block to the raw disk
662: *
663: * Input: dev = disk device to be written to.
664: * iop = pointer to source I/O structure.
665: *
666: * Action: Invoke the common raw I/O processing code.
667: */
668: static void sswrite(dev, iop)
669: dev_t dev;
670: IO *iop;
671: {
672: T_PIGGY( 0x20, printf("sswrite(iop->io.vbase: %x)", iop->io.vbase); );
673:
674: ioreq( &dbuf, iop, dev, BWRITE, BFRAW|BFBLK|BFIOC );
675: }
676:
677: /*
678: * ssioctl()
679: *
680: * Input: dev = disk device to be operated on.
681: * cmd = input/output request to be performed.
682: * vec = (pointer to) optional argument.
683: */
684: static int ssioctl(dev, cmd, vec)
685: register dev_t dev;
686: int cmd;
687: char * vec;
688: {
689: int ret = 0;
690: hdparm_t hdparm;
691: struct fdisk_s *fdp;
692: int s_id;
693: ss_type * ssp;
694:
695: s_id = DEV_SCSI_ID(dev);
696: ssp = ss[s_id];
697: fdp = ssp->parmp;
698:
699: switch(cmd) {
700: case HDGETA:
701: /*
702: * Get hard disk attributes.
703: */
704: PR3("HDGETA");
705: fdp = ssp->parmp;
706: *(short *)&hdparm.landc[0] =
707: *(short *)&hdparm.ncyl[0] = drv_parm[s_id].ncyl;
708: hdparm.nhead = drv_parm[s_id].nhead;
709: hdparm.nspt = drv_parm[s_id].nspt;
710: #if (DEBUG >= 3)
711: printf("ncyl=%d nhead=%d nspt=%d\n",
712: hdparm.ncyl[0]+((int)hdparm.ncyl[1]<<8), (int)hdparm.nhead, (int)hdparm.nspt);
713: #endif
714: kucopy(&hdparm, vec, sizeof hdparm);
715: ret = 0;
716: break;
717: case HDSETA:
718: /*
719: * Set hard disk attributes.
720: */
721: PR3("HDSETA");
722: fdp = ssp->parmp;
723: ukcopy(vec, &hdparm, sizeof hdparm);
724: drv_parm[s_id].ncyl = *(short *)&hdparm.ncyl[0];
725: drv_parm[s_id].nhead = hdparm.nhead;
726: drv_parm[s_id].nspt = hdparm.nspt;
727: #if (DEBUG >= 3)
728: printf("ncyl=%d nhead=%d nspt=%d\n",
729: hdparm.ncyl[0]+((int)hdparm.ncyl[1]<<8), (int)hdparm.nhead, (int)hdparm.nspt);
730: #endif
731: ret = 0;
732: break;
733: default:
734: u.u_error = EINVAL;
735: ret = -1;
736: }
737:
738: return ret;
739: }
740:
741: /*
742: * ssblock() - queue a block to the disk
743: *
744: * Input: bp = pointer to block to be queued.
745: *
746: * Action: Queue a block to the disk.
747: * Make sure that the transfer is within the disk partition.
748: */
749: static void ssblock(bp)
750: register BUF *bp;
751: {
752: struct fdisk_s *fdp;
753: int partition, drive, s_id;
754: dev_t dev;
755: ss_type * ssp;
756: unchar * msg = NULL;
757:
758: T_PIGGY( 0x20,
759: printf("ssblock(bp->b_vaddr: %x, bp->b_paddr: %x)",
760: bp->b_vaddr, bp->b_paddr);
761: );
762:
763: /*
764: * Set up local variables.
765: */
766: dev = bp->b_dev;
767: partition = DEV_PARTN(dev);
768: drive = DEV_DRIVE(dev);
769: s_id = DEV_SCSI_ID(dev);
770: ssp = ss[s_id];
771: if (dev & SDEV)
772: partition = WHOLE_DRIVE;
773: fdp = ssp->parmp;
774:
775: bp->b_resid = bp->b_count;
776: #if (DEBUG >= 2)
777: if (bp->b_count != BSIZE)
778: printf("b_count=%d ", bp->b_count);
779: #endif
780:
781: /*
782: * Range check disk region.
783: */
784: if (!(ssp->ptab_read)) {
785: if ( partition == WHOLE_DRIVE ) {
786: #if 0
787: /* Why did we only allow people to access the first block of WHOLE_DRIVE?
788: in cases where there was not a valid partition table? */
789: if ((bp->b_bno != 0) || (bp->b_count != BSIZE)) {
790: msg = "invalid request";
791: bp->b_flag |= BFERR;
792: goto bad_blk;
793: }
794: #endif
795: } else {
796: msg = "no partition table";
797: bp->b_flag |= BFERR;
798: goto bad_blk;
799: }
800: }
801:
802: /*
803: * Check for read at end of partition.
804: * (Need to return with b_resid = BSIZE to signal end of volume.)
805: */
806: else if ((bp->b_req == BREAD) && (bp->b_bno == fdp[partition].p_size)) {
807: goto bad_blk;
808: }
809:
810: /*
811: * Check for read past end of partition.
812: */
813: else if ( (bp->b_bno + (bp->b_count/BSIZE))
814: > fdp[partition].p_size ) {
815: msg = "partition overrun";
816: bp->b_flag |= BFERR;
817: goto bad_blk;
818: }
819:
820: /*
821: * Fail if request is for zero bytes or is not even # of blocks.
822: */
823: if ((bp->b_count % BSIZE) || bp->b_count == 0) {
824: msg = "invalid byte count";
825: bp->b_flag |= BFERR;
826: goto bad_blk;
827: }
828:
829: /*
830: * Operation appears valid.
831: * Fill fields in the node and queue the request.
832: */
833: bufq_wr_tail(s_id, bp);
834: ss_mach(s_id);
835: goto end_blk;
836:
837: /*
838: * Operation cannot be done. Release the kernel buffer structure.
839: * Value of "bp->b_flag" tells caller if error occurred.
840: */
841: bad_blk:
842: if (msg)
843: devmsg(dev, msg);
844: bdone(bp);
845:
846: end_blk:
847: return;
848: }
849:
850: /*
851: * ssintr() - Interrupt routine.
852: *
853: * If we have been reselected by a recognized target device
854: * let kernel get out of interrupt mode (defer) and do SCSI
855: * reconnect stuff.
856: */
857: static void ssintr()
858: {
859: int s_id;
860:
861: s_id = chk_reconn();
862: if (s_id != -1) {
863: if (ss[s_id]->state == SST_POLL_RESELECT)
864: defer(ss_mach, s_id);
865: else
866: defer(dummy_reconn, s_id);
867: PR3("!");
868: }
869: }
870:
871: /*
872: * dummy_reconn()
873: *
874: * Somehow we are in a state where the driver software does not expect
875: * a reconnect but a device is trying one anyway. Go thru the motions
876: * of reconnect because not servicing a hanging reselect seems to leave
877: * the target hung - in such a way that it fails to respond to reset
878: * messages and to reset on the SCSI bus.
879: */
880: static void dummy_reconn(s_id)
881: int s_id;
882: {
883: int bus_timeout;
884: unchar phase_type;
885: int s;
886: int msg_in;
887: int cmdstat;
888: int xfer_good = 1;
889: PR1("DUM");
890: if (ss[s_id]->state == SST_POLL_RESELECT) {
891: defer(ss_mach, s_id);
892: goto dum_done;
893: }
894: if (!rsel_handshake())
895: goto dum_done;
896:
897: s = sphi();
898: while (req_wait(&bus_timeout) && xfer_good) {
899: phase_type = ffbyte(ss_csr) & (RS_MESSAGE|RS_I_O|RS_CTRL_DATA);
900: switch (xpmod(phase_type)) {
901: case XP_MSG_IN:
902: msg_in = ffbyte(ss_dat);
903: switch(msg_in){
904: case MSG_CMD_CMPLT:
905: case MSG_DISCONNECT:
906: sfbyte(ss_csr, WC_ENABLE_PRTY | WC_ENABLE_IRPT);
907: break;
908: }
909: break;
910: case XP_MSG_OUT:
911: sfbyte(ss_dat, MSG_NOP);
912: sfbyte(ss_csr, WC_ENABLE_PRTY | WC_ENABLE_SCSI);
913: break;
914: case XP_STAT_IN:
915: cmdstat = ffbyte(ss_dat);
916: break;
917: case XP_CMD_OUT:
918: case XP_DATA_OUT:
919: xfer_good = 0;
920: break;
921: case XP_DATA_IN:
922: ffbyte(ss_dat);
923: break;
924: default:
925: break;
926: } /* endswitch */
927: } /* endwhile */
928: spl(s);
929:
930: dum_done:
931: return;
932: }
933:
934: /*
935: * sswatch()
936: *
937: * Invoked once per second if any devices going through this driver are open.
938: * Poll for any reselect, in case interrupt got lost.
939: */
940: static void sswatch()
941: {
942: int s_id;
943: ss_type * ssp;
944:
945: for (s_id = 0; s_id < MAX_SCSI_ID; s_id++) {
946: ssp = ss[s_id];
947: if (ssp && ssp->dr_watch)
948: defer(ss_mach, s_id);
949: } /* endfor */
950: }
951:
952: /*
953: * bus_wait()
954: *
955: * Wait for specified bit values to appear in Status Register.
956: * This uses a tight loop and does not expect to be interrupted.
957: *
958: * Argument "flags" is a double-byte value; the high byte is ANDed with
959: * status register contents, and the result is tested for equality with
960: * the low byte.
961: *
962: * Return 1 if values wanted appeared, 0 if timeout occurred.
963: */
964: static int bus_wait(flags)
965: unsigned short flags;
966: {
967: int found, i;
968: unsigned char status;
969:
970: found = 0;
971: for ( i = 0; i < HIPRI_RETRIES; i++) {
972: status = ffbyte(ss_csr);
973: if ((status & (flags >> 8)) == (flags & 0xff)) {
974: found = 1;
975: break;
976: }
977: }
978:
979: #if (DEBUG >= 1)
980: if (!found)
981: printf("TO:f=%x s=%x ", flags, status);
982: #endif
983:
984: return found;
985: }
986:
987: /*
988: * ssinit()
989: *
990: * Attempt to initialize the (unique) drive with a given SCSI id.
991: * Assume only one drive per SCSI id, having LUN = 0.
992: *
993: * Return 1 if success, 0 if failure.
994: */
995: static int ssinit(s_id)
996: int s_id;
997: {
998: int retval = 1;
999: unchar query_buf[MODESENSELEN];
1000: ss_type * ssp = ss[s_id];
1001: int dev = ((sscon.c_mind << 8) | 0x80 | (s_id << 4));
1002:
1003: printf("SCSI ID %d LUN 0\n", s_id);
1004: if (retval)
1005: if (init_call(inquiry, s_id, query_buf)) {
1006: query_buf[INQUIRYLEN] = 0;
1007: #if (debug >= 2)
1008: devmsg(dev, query_buf + 8);
1009: #endif
1010: if (query_buf[0] == 0) {
1011: retval = 1;
1012: } else
1013: devmsg(dev, "Not Direct Access Device");
1014: } else
1015: devmsg(dev, "Inquiry Failed");
1016:
1017: if (retval)
1018: if (init_call(read_cap, s_id, query_buf)) {
1019: retval = 1;
1020: ssp->capacity = query_buf[3] | (query_buf[2] << 8)
1021: | (((long)(query_buf[1])) << 16)
1022: | (((long)(query_buf[0])) << 24);
1023: ssp->blocklen = query_buf[7] | (query_buf[6] << 8)
1024: | (((long)(query_buf[5])) << 16)
1025: | (((long)(query_buf[4])) << 24);
1026:
1027: printf("Capacity=%ld blocks Block length=%ld\n",
1028: ssp->capacity, ssp->blocklen);
1029: } else
1030: devmsg(dev, "Read Capacity Failed");
1031:
1032: if (retval)
1033: if (init_call(mode_sense, s_id, query_buf)) {
1034: /*
1035: * Display physical drive parameters.
1036: */
1037: #define FMT_PG (4+8+8+12)
1038: #define DDG_PG (4+8+8+12+24)
1039: unchar heads;
1040: unsigned short spt;
1041: ulong cyls;
1042:
1043: spt=((int)query_buf[FMT_PG+10]<<8)
1044: + query_buf[FMT_PG+11];
1045: cyls=((int)query_buf[DDG_PG+2]<<16)
1046: + ((int)query_buf[DDG_PG+3]<<8)
1047: + query_buf[DDG_PG+4];
1048: heads=query_buf[DDG_PG+5];
1049:
1050: printf("Physical: cylinders=%ld ", cyls);
1051: printf("heads=%d ", heads);
1052: printf("spt=%d\n", spt);
1053:
1054: if (drv_parm[s_id].ncyl == 0) {
1055: drv_parm[s_id].ncyl = cyls;
1056: drv_parm[s_id].nhead = heads;
1057: drv_parm[s_id].nspt = spt;
1058: } else {
1059: printf("Logical: cylinders=%d ",
1060: drv_parm[s_id].ncyl);
1061: printf("heads=%d ", drv_parm[s_id].nhead);
1062: printf("spt=%d\n", drv_parm[s_id].nspt);
1063: }
1064: } else
1065: devmsg(dev, "Mode Sense Failed");
1066:
1067: return retval;
1068: }
1069:
1070: /*
1071: * far_info_xfer()
1072: *
1073: * Do bus cycle information transfer phases.
1074: * This includes message in/out, command in/out, and data in/out.
1075: *
1076: * If cmdlen is nonzero, cmdbuf is an array of bytes of that length,
1077: * to be sent to the target.
1078: *
1079: * Return 1 if bus timeout did not occur, else 0.
1080: *
1081: * pseudocode:
1082: *
1083: * while (wait for REQ true or BUSY false on SCSI bus)
1084: * if (BUSY false)
1085: * break from while loop
1086: * else
1087: * switch (xfer phase = RS_CTRL_DATA|RS_I_O|RS_MESSAGE)
1088: * case XP_MSG_IN/XP_MSG_OUT/...
1089: * handle the indicated information transfer phase
1090: * endswitch
1091: * endif
1092: * endwhile
1093: */
1094: static int far_info_xfer(s_id)
1095: int s_id;
1096: {
1097: int bus_timeout;
1098: unchar phase_type;
1099: unchar msg_in;
1100: int s;
1101: int bytes_to_send;
1102: ss_type * ssp = ss[s_id];
1103: BUF * bp = ssp->bp;
1104: int xfer_good = 1;
1105: int xfer_count = bp->b_count - bp->b_resid;
1106: int irpts_masked;
1107: int block_done=0;
1108:
1109: ssp->cmd_bytes_out = 0;
1110: ssp->msg_in = -1;
1111:
1112: irpts_masked = 0;
1113: while (req_wait(&bus_timeout) && xfer_good) {
1114: phase_type = ffbyte(ss_csr) & (RS_MESSAGE|RS_I_O|RS_CTRL_DATA);
1115: if (!irpts_masked) {
1116: s = sphi();
1117: irpts_masked = 1;
1118: }
1119: switch (xpmod(phase_type)) {
1120: case XP_MSG_IN:
1121: msg_in = ffbyte(ss_dat);
1122: switch(msg_in){
1123: case MSG_CMD_CMPLT:
1124: PR4("Mcc");
1125: ssp->msg_in = msg_in;
1126: sfbyte(ss_csr, WC_ENABLE_PRTY | WC_ENABLE_IRPT);
1127: break;
1128: case MSG_DISCONNECT:
1129: PR4("Mdc");
1130: ssp->msg_in = msg_in;
1131: sfbyte(ss_csr, WC_ENABLE_PRTY | WC_ENABLE_IRPT);
1132: break;
1133: case MSG_SAVE_DPTR:
1134: PR4("Msd");
1135: break;
1136: case MSG_RSTOR_DPTR:
1137: PR4("Mrd");
1138: break;
1139: case MSG_ABORT:
1140: PR4("Mab");
1141: break;
1142: case MSG_DEV_RESET:
1143: PR4("Mdr");
1144: break;
1145: case MSG_IDENTIFY:
1146: PR4("Mmi");
1147: break;
1148: case MSG_IDENT_DC:
1149: PR4("Mmd");
1150: break;
1151: }
1152: break;
1153: case XP_MSG_OUT:
1154: PR4("MO");
1155: /*
1156: * This case shouldn't happen. We weren't
1157: * asserting ATTENTION. Abort the bus cycle.
1158: */
1159: sfbyte(ss_dat, MSG_NOP);
1160: sfbyte(ss_csr, WC_ENABLE_PRTY | WC_ENABLE_SCSI);
1161: break;
1162: case XP_STAT_IN:
1163: PR4("SI");
1164: ssp->cmdstat = ffbyte(ss_dat);
1165: break;
1166: case XP_CMD_OUT:
1167: /*
1168: * Ship out command bytes.
1169: * Reset SCSI bus if too many command bytes are wanted.
1170: */
1171: bytes_to_send = ssp->cmdlen - ssp->cmd_bytes_out;
1172: if(bytes_to_send > 0) {
1173: sfbyte(ss_dat, ssp->cmdbuf[ssp->cmd_bytes_out++]);
1174: /*
1175: * If just sent last byte, allow interrupts.
1176: */
1177: if (bytes_to_send == 1) {
1178: PR4("CO");
1179: if (bp->b_req == BREAD) {
1180: if (irpts_masked) {
1181: spl(s);
1182: irpts_masked = 0;
1183: }
1184: }
1185: }
1186: } else { /* This case should not happen. */
1187: xfer_good = 0;
1188: }
1189: break;
1190: case XP_DATA_IN:
1191: /*
1192: * If caller's buffer has room, keep incoming
1193: * data byte.
1194: */
1195: if (block_done) {
1196: xfer_good = 0;
1197: PR1("Data in overrun");
1198: } else if (bp->b_req != BREAD) {
1199: xfer_good = 0;
1200: } else {
1201: #if 0
1202: int getbval;
1203:
1204: block_done=1;
1205: PR4("DI");
1206: if(getbval = ss_getb(ss_dat,
1207: #ifdef _I386
1208: bp->b_vaddr + xfer_count)) {
1209: #else
1210: bp->b_faddr + xfer_count)) {
1211: #endif /* _I386 */
1212: xfer_good = 0;
1213: #if (DEBUG >= 1)
1214: printf("getb=%d ", getbval);
1215: #endif
1216: }
1217: #else
1218: block_done=1;
1219: #ifdef _I386
1220:
1221: if (BSIZE != xpcopy(ss_dat, bp->b_paddr + xfer_count,
1222: BSIZE, SEG_386_KD|SEG_VIRT)) {
1223: devmsg(bp->b_dev, "XP_DATA_IN: ss_dat: %x, bp->bpaddr: %x, xfer_count: %x\n",
1224: ss_dat, bp->b_paddr, xfer_count);
1225: break;
1226: }
1227: #else
1228: ffcopy(ss_dat, bp->b_faddr + xfer_count, BSIZE);
1229: #endif /* _I386 */
1230: #endif /* 0 */
1231: }
1232: break;
1233: case XP_DATA_OUT:
1234: /*
1235: * Copy output buffer bytes to data register.
1236: */
1237: if (block_done) {
1238: xfer_good = 0;
1239: PR1("Data out overrun");
1240: } else if (bp->b_req != BWRITE) {
1241: xfer_good = 0;
1242: } else {
1243: #if 0
1244: int putbval;
1245: block_done=1;
1246: PR4("DO");
1247: if (putbval = ss_putb(ss_dat,
1248: #ifdef _I386
1249: bp->b_vaddr + xfer_count)) {
1250: #else
1251: bp->b_faddr + xfer_count)) {
1252: #endif /* _I386 */
1253: xfer_good = 0;
1254: #if (DEBUG >= 1)
1255: printf("putb=%d ", putbval);
1256: #endif
1257: }
1258: #else
1259: block_done=1;
1260: #ifdef _I386
1261: if (BSIZE != pxcopy(bp->b_paddr + xfer_count, ss_dat,
1262: BSIZE, SEG_386_KD|SEG_VIRT)) {
1263: devmsg(bp->b_dev, "XP_DATA_OUT: bp->b_paddr: %x, xfer_count: %x, ss_dat: %x\n",
1264: bp->b_paddr, xfer_count, ss_dat);
1265: break;
1266: }
1267:
1268: #else
1269: ffcopy(bp->b_faddr + xfer_count, ss_dat, BSIZE);
1270: #endif /* _I386 */
1271: #endif
1272: if (irpts_masked) {
1273: spl(s);
1274: irpts_masked = 0;
1275: }
1276: }
1277: break;
1278: default:
1279: break;
1280: } /* endswitch */
1281: }
1282: if (irpts_masked)
1283: spl(s);
1284:
1285: #if (DEBUG >= 1)
1286: switch(ssp->cmdstat) {
1287: case -1:
1288: if (msg_in != MSG_DISCONNECT)
1289: printf("CS-",ssp->cmdstat);
1290: break;
1291: case CS_GOOD:
1292: break;
1293: case CS_CHECK:
1294: printf("CSK",ssp->cmdstat);
1295: break;
1296: case CS_BUSY:
1297: printf("CSY",ssp->cmdstat);
1298: break;
1299: case CS_RESERVED:
1300: default:
1301: printf("CS%x",ssp->cmdstat);
1302: }
1303: #endif
1304:
1305: return (bus_timeout) ? 0 : 1 ;
1306: }
1307:
1308: /*
1309: * req_wait()
1310: *
1311: * This routine is called at the start of each information transfer
1312: * phase and after the last such phase.
1313: *
1314: * It returns 1 if REQ is asserted on the SCSI bus, meaning another phase
1315: * may begin, and 0 otherwise. A REQ signal will not be seen if the function
1316: * times out or if BUSY drops. A value of 1 is written to the pointer argument
1317: * if timeout occurred, else 0 is written.
1318: */
1319: static int req_wait(to_ptr)
1320: int *to_ptr;
1321: {
1322: int req_found;
1323: unsigned char status;
1324: ulong poll_ct;
1325: int s;
1326:
1327: s = splo();
1328: *to_ptr = 1;
1329: req_found = 0;
1330: for (poll_ct = 0L; poll_ct < max_req_poll; poll_ct++) {
1331: status = ffbyte(ss_csr);
1332: if (status & RS_REQUEST) {
1333: req_found = 1;
1334: *to_ptr = 0;
1335: break;
1336: } else if ((status & RS_BUSY) == 0) {
1337: *to_ptr = 0;
1338: break;
1339: }
1340: }
1341:
1342: #if (DEBUG >= 1)
1343: if (*to_ptr) {
1344: printf("TX: s=%x ", status);
1345: }
1346: #endif
1347:
1348: spl(s);
1349: return req_found;
1350: }
1351:
1352: /*
1353: * req_sense()
1354: *
1355: * Request Sense for a device. The main reason for doing this is to
1356: * clear a standing Command Status of Device Check.
1357: *
1358: * Full results are discarded. Return 1 if Device returns No Sense or
1359: * or Unit Attention. Else return 0.
1360: *
1361: */
1362: static int req_sense(s_id)
1363: int s_id;
1364: {
1365: unchar sense_buf[SENSELEN];
1366: unchar cmdbuf[G0CMDLEN];
1367: int ret = 0;
1368:
1369: cmdbuf[0] = ScmdREQUESTSENSE;
1370: cmdbuf[1] = 0;
1371: cmdbuf[2] = 0;
1372: cmdbuf[3] = 0;
1373: cmdbuf[4] = SENSELEN;
1374: cmdbuf[5] = 0;
1375:
1376: #if (DEBUG >= 2)
1377: {int i; for (i=0; i<SENSELEN; i++) sense_buf[i]=0;}
1378: #endif
1379:
1380: PR2("rqs:");
1381: if (!start_arb()) {
1382: PR2("NO arb");
1383: #if (DEBUG >= 2)
1384: printf("status=%x ", ffbyte(ss_csr));
1385: #endif
1386: goto rqs_done;
1387: }
1388:
1389: if (!host_ident(s_id, 0)) {
1390: PR2("NO host ident");
1391: #if (DEBUG >= 2)
1392: printf("status=%x ", ffbyte(ss_csr));
1393: #endif
1394: goto rqs_done;
1395: }
1396:
1397: if(!local_info_xfer(cmdbuf, G0CMDLEN, sense_buf, SENSELEN, NULL, 0)) {
1398: PR2("NO local xfer");
1399: goto rqs_done;
1400: } else {
1401: /*
1402: * Return 1 if drive responded with any of these sense keys:
1403: * 0x00 No Sense
1404: * 0x06 Unit Attention
1405: * 0x0B Aborted Command
1406: * In any of the above cases, a retry will likely succeed
1407: * without Buse Device Reset or SCSI Bus Reset.
1408: */
1409: switch (sense_buf[2]) {
1410: case 0x00:
1411: case 0x06:
1412: case 0x0B:
1413: ret = 1;
1414: break;
1415: } /* endswitch */
1416: }
1417:
1418: rqs_done:
1419: #if (DEBUG >= 2)
1420: {
1421: int i;
1422:
1423: for (i=0; i<SENSELEN;i++)
1424: printf("%x ", sense_buf[i]);
1425: printf("\n");
1426: }
1427: #endif
1428: return ret;
1429: }
1430:
1431: /*
1432: * inquiry()
1433: *
1434: * Inquiry command for a device.
1435: * Find out if device is direct access, removable, etc.
1436: *
1437: * Put result of inquiry into supplied buffer.
1438: * Return 1 if command succeeds, else 0.
1439: */
1440: static int inquiry(s_id, buf)
1441: int s_id;
1442: unchar * buf;
1443: {
1444: int ret = 0;
1445: unchar cmdbuf[G0CMDLEN];
1446:
1447: cmdbuf[0] = ScmdINQUIRY;
1448: cmdbuf[1] = 0;
1449: cmdbuf[2] = 0;
1450: cmdbuf[3] = 0;
1451: cmdbuf[4] = INQUIRYLEN;
1452: cmdbuf[5] = 0;
1453:
1454: if (start_arb() && host_ident(s_id, 0) &&
1455: local_info_xfer(cmdbuf, G0CMDLEN, buf, INQUIRYLEN, NULL, 0))
1456: ret = 1;
1457:
1458: return ret;
1459: }
1460:
1461: /*
1462: * mode_sense()
1463: *
1464: * Mode Sense command for a device.
1465: * Use this to get disk parameters:
1466: * number of cylinders
1467: * number of heads
1468: * number of sectors per track.
1469: *
1470: * Put result of mode sense into supplied buffer.
1471: * Return 1 if command succeeds, else 0.
1472: */
1473: static int mode_sense(s_id, buf)
1474: int s_id;
1475: unchar * buf;
1476: {
1477: int ret = 0;
1478: unchar cmdbuf[G0CMDLEN];
1479:
1480: cmdbuf[0] = ScmdMODESENSE;
1481: cmdbuf[1] = 0;
1482: cmdbuf[2] = 0x3F;
1483: cmdbuf[3] = 0;
1484: cmdbuf[4] = MODESENSELEN;
1485: cmdbuf[5] = 0;
1486:
1487: if (start_arb() && host_ident(s_id, 0) &&
1488: local_info_xfer(cmdbuf, G0CMDLEN, buf, MODESENSELEN, NULL, 0))
1489: ret = 1;
1490:
1491: return ret;
1492: }
1493:
1494: /*
1495: * read_cap()
1496: *
1497: * Read Capacity command for a device.
1498: *
1499: * Return 1 if command succeeds, else 0.
1500: */
1501: static int read_cap(s_id, buf)
1502: int s_id;
1503: unchar * buf;
1504: {
1505: int ret = 0;
1506: unchar cmdbuf[G1CMDLEN];
1507:
1508: cmdbuf[0] = ScmdREADCAPACITY;
1509: cmdbuf[1] = 0;
1510: cmdbuf[2] = 0;
1511: cmdbuf[3] = 0;
1512: cmdbuf[4] = 0;
1513: cmdbuf[5] = 0;
1514: cmdbuf[6] = 0;
1515: cmdbuf[7] = 0;
1516: cmdbuf[8] = 0;
1517: cmdbuf[9] = 0;
1518:
1519: if (start_arb() && host_ident(s_id, 0) &&
1520: local_info_xfer(cmdbuf, G1CMDLEN, buf, READCAPLEN, NULL, 0))
1521: ret = 1;
1522:
1523: return ret;
1524: }
1525:
1526: /*
1527: * bus_dev_reset()
1528: *
1529: * Send Bus Device Reset message to the given SCSI id.
1530: * Return 1 if host adapter was not busy and no obvious timeouts occurred,
1531: * else 0.
1532: */
1533: static int bus_dev_reset(s_id)
1534: {
1535: int bdr_ok = 1;
1536: int dev = ((sscon.c_mind << 8) | 0x80 | (s_id << 4));
1537:
1538: PR1("BDR");
1539: if (bdr_ok) {
1540: /*
1541: * Do ST0x arbitration.
1542: *
1543: * De-assert SCSI enable bit.
1544: * Write my SCSI id to port.
1545: * Start arbitration.
1546: */
1547: sfbyte(ss_csr, WC_ENABLE_PRTY);
1548: sfbyte(ss_dat, host_id);
1549: sfbyte(ss_csr, WC_ENABLE_PRTY | WC_ARBITRATE);
1550:
1551: /*
1552: * SCSI spec says there is "no maximum" to the wait for
1553: * arbitration complete.
1554: */
1555: if (!bus_wait(RS_ARBIT_COMPL << 8 | RS_ARBIT_COMPL)) {
1556: bdr_ok = 0;
1557: }
1558: }
1559:
1560: /*
1561: * Arbitration complete. Now select, with ATN to allow messages.
1562: */
1563: if (bdr_ok) {
1564: sfbyte(ss_dat, host_id | (1 << s_id)); /* Write both SCSI id's */
1565: sfbyte(ss_csr, WC_ENABLE_PRTY | WC_ENABLE_SCSI | WC_ATTENTION | WC_SELECT);
1566:
1567: if (!bus_wait(RS_BUSY << 8 | RS_BUSY))
1568: bdr_ok = 0;
1569: }
1570:
1571: if (bdr_ok) {
1572: sfbyte(ss_csr, WC_ENABLE_PRTY | WC_ENABLE_SCSI | WC_ATTENTION);
1573:
1574: if (!bus_wait(((RS_REQUEST|RS_CTRL_DATA|RS_I_O|RS_MESSAGE) << 8)
1575: | (RS_REQUEST|RS_CTRL_DATA|RS_MESSAGE)))
1576: bdr_ok = 0;
1577: }
1578:
1579: if (bdr_ok) {
1580: sfbyte(ss_csr, WC_ENABLE_PRTY | WC_ENABLE_SCSI);
1581: sfbyte(ss_dat, MSG_DEV_RESET);
1582: if (!bus_wait((0xFF << 8) | 0))
1583: bdr_ok = 0;
1584: }
1585:
1586: return bdr_ok;
1587: }
1588:
1589: /*
1590: * chk_reconn()
1591: *
1592: * Check SELECT to see if any SCSI device has tried to reconnect to the host
1593: * adapter. Called if there is an interrupt, and by the timer in case
1594: * we somehow lose an interrupt.
1595: *
1596: * Return -1 if no reselect detected, or the SCSI ID of the reselecting
1597: * target if there is one.
1598: */
1599: static int chk_reconn()
1600: {
1601: unchar csr, dat;
1602: int s_id = -1;
1603:
1604: csr = ffbyte(ss_csr);
1605: if (csr & (RS_SELECT | RS_I_O)) {
1606: dat = ffbyte(ss_dat);
1607: if ((dat & host_id) && (dat & NSDRIVE)) {
1608: dat &= ~host_id;
1609: s_id = 0;
1610: while (dat >>=1)
1611: s_id++;
1612: }
1613: }
1614:
1615: return s_id;
1616: }
1617:
1618: /*
1619: * ss_mach()
1620: *
1621: * Gives a distinct state machine for each target device.
1622: */
1623: void ss_mach(s_id)
1624: int s_id;
1625: {
1626: ss_type * ssp = ss[s_id];
1627: BUF * bp;
1628:
1629: do_sst_op = 1; /* plan to run this routine again in most cases */
1630: while (do_sst_op) {
1631: bp = ssp->bp; /* nonpolled() below can change ssp->bp */
1632: switch (ssp->state) {
1633: /*
1634: * Polling states execute whether ssp->waiting or not.
1635: */
1636: case SST_POLL_ARBITN:
1637: PR3("XPAR");
1638: if (ffbyte(ss_csr) & RS_ARBIT_COMPL) {
1639: ssp->waiting = 0;
1640: if (host_ident(s_id, 1))
1641: do_connect(s_id);
1642: else
1643: recover(s_id, RV_P_TIMEOUT);
1644: } else {
1645: if (ssp->expired) {
1646: ssp->expired = 0;
1647: recover(s_id, RV_A_TIMEOUT);
1648: } else
1649: do_sst_op = 0;
1650: }
1651: break;
1652: case SST_POLL_RESELECT:
1653: PR3("XPRS");
1654: if (TGT_RSEL) {
1655: ssp->waiting = 0;
1656: if (host_claimed == -1)
1657: host_claimed = s_id;
1658: else if (host_claimed != s_id) {
1659: #if (DEBUG >= 1)
1660: printf("%d->%d ", host_claimed, s_id);
1661: #endif
1662: }
1663: if (rsel_handshake()) {
1664: do_connect(s_id);
1665: } else {
1666: recover(s_id, RV_P_TIMEOUT);
1667: }
1668: } else { /* Reselect poll is negative */
1669: if (ssp->expired) {
1670: ssp->expired = 0;
1671: recover(s_id, RV_R_TIMEOUT);
1672: } else
1673: do_sst_op = 0;
1674: }
1675: break;
1676: case SST_POLL_BEGIN_IO:
1677: PR3("XPBI");
1678: if (bp == NULL)
1679: ssp->state = SST_DEQUEUE;
1680: else {
1681: /*
1682: * At this point a SCSI command is about to
1683: * be initiated. It may be a retry.
1684: */
1685: if (host_claimed == -1 && BUS_FREE && BUS_FREE) {
1686: ssp->waiting = 0;
1687: init_pointers(s_id);
1688: if (start_arb()) {
1689: host_claimed = s_id;
1690: if (host_ident(s_id, 1)) {
1691: do_connect(s_id);
1692: } else {
1693: recover(s_id, RV_P_TIMEOUT);
1694: }
1695: } else {
1696: /*
1697: * If arbitration does not succeed right away, it is usually
1698: * because another drive is trying to reselect the host.
1699: */
1700: set_timeout(s_id, DELAY_ARB);
1701: }
1702: } else { /* host busy or bus not free */
1703: int o_id;
1704:
1705: if ((o_id = chk_reconn()) != -1)
1706: defer(dummy_reconn, s_id);
1707: ++ssp->avl_count;
1708: if (ssp->avl_count >= MAX_AVL_COUNT)
1709: recover(s_id, RV_BF_TIMEOUT);
1710: else
1711: set_timeout(s_id, DELAY_BSY);
1712: }
1713: }
1714: break;
1715: default:
1716: if (ssp->waiting)
1717: do_sst_op = 0;
1718: else {
1719: /*
1720: * Nonpolling states execute only if no
1721: * target timer is running.
1722: */
1723: nonpolled(s_id);
1724: }
1725: } /* endswitch */
1726: } /* endwhile */
1727: }
1728:
1729: /*
1730: * nonpolled()
1731: *
1732: * Part of ss_mach() - handling of nonpolling states is taken out simply
1733: * for readability.
1734: */
1735: static void nonpolled(s_id)
1736: int s_id;
1737: {
1738: ss_type * ssp = ss[s_id];
1739: BUF * bp = ssp->bp;
1740: struct fdisk_s *fdp;
1741: int partition;
1742: dev_t dev;
1743:
1744: switch (ssp->state) {
1745: case SST_BUS_DEV_RESET:
1746: PR3("XBDR");
1747: if (bus_dev_reset(s_id)) {
1748: do_sst_op = 0;
1749: set_timeout(s_id, DELAY_BDR);
1750: ssp->state = SST_REQ_SENSE;
1751: } else
1752: recover(s_id, RV_P_TIMEOUT);
1753: break;
1754: case SST_DEQUEUE:
1755: if(bufq_rd_head(s_id) != NULL && !ssp->busy) {
1756: PR3("XDQU");
1757: ssp->busy = 1;
1758: bp = bufq_rm_head(s_id);
1759: ssp->bp = bp;
1760: dev = bp->b_dev;
1761: partition = DEV_PARTN(dev);
1762: if (dev & SDEV)
1763: partition = WHOLE_DRIVE;
1764: fdp = ssp->parmp;
1765: if (partition != WHOLE_DRIVE)
1766: ssp->bno = fdp[partition].p_base + bp->b_bno;
1767: else
1768: ssp->bno = bp->b_bno;
1769: if (bp->b_req == BREAD)
1770: ssp->cmdbuf[0] = ScmdREADEXTENDED;
1771: else
1772: ssp->cmdbuf[0] = ScmdWRITEXTENDED;
1773: ssp->cmdbuf[1] = 0;
1774: ssp->cmdbuf[2] = ssp->bno >> 24;
1775: ssp->cmdbuf[3] = ssp->bno >> 16;
1776: ssp->cmdbuf[4] = ssp->bno >> 8;
1777: ssp->cmdbuf[5] = ssp->bno;
1778: ssp->cmdbuf[6] = 0;
1779: ssp->cmdbuf[7] = 0;
1780: ssp->cmdbuf[8] = 1;
1781: ssp->cmdbuf[9] = 0;
1782: ssp->cmdlen = G1CMDLEN;
1783: init_pointers(s_id);
1784: ssp->bdr_count = 0;
1785: ssp->bsy_count = 0;
1786: ssp->try_count = 0;
1787: ssp->state = SST_POLL_BEGIN_IO;
1788: } else /* queue is empty or ssp->busy */
1789: do_sst_op = 0;
1790: break;
1791: case SST_HIPRI_RESET:
1792: case SST_LOPRI_RESET:
1793: PR1("XRST");
1794: /*
1795: * SST_LOPRI_RESET is same as SST_HIPRI_RESET for now.
1796: * Later, can implement a delay to allow other targets to
1797: * finish pending operations.
1798: */
1799: if (host_claimed == s_id || host_claimed == -1) {
1800: host_claimed = s_id;
1801: sfbyte(ss_csr, WC_ENABLE_PRTY | WC_ENABLE_SCSI | WC_SCSI_RESET); /* reset ON */
1802: ssp->state = SST_RESET_OFF;
1803: set_timeout(s_id, DELAY_RST);
1804: PR1("+");
1805: } else
1806: set_timeout(s_id, DELAY_RST);
1807: break;
1808: case SST_REQ_SENSE:
1809: PR1("XRQS");
1810: /*
1811: * Come here at end of SCSI Bus reset (and at other times).
1812: * If we have host claimed, release it.
1813: */
1814: if (host_claimed == s_id)
1815: host_claimed = -1;
1816: if (req_sense(s_id))
1817: ssp->state = SST_POLL_BEGIN_IO;
1818: else
1819: recover(s_id, RV_P_TIMEOUT);
1820: break;
1821: case SST_RESET_OFF:
1822: PR3("XRFF");
1823: sfbyte(ss_csr, WC_ENABLE_PRTY); /* reset OFF */
1824: ssp->state = SST_REQ_SENSE;
1825: set_timeout(s_id, DELAY_RST);
1826: } /* endswitch */
1827: }
1828:
1829: /*
1830: * start_arb()
1831: *
1832: * return 1 if host adapter returned Arbitration Complete within allotted
1833: * number of tries, else 0
1834: */
1835: static int start_arb()
1836: {
1837: int ret = 0;
1838: int poll_ct;
1839:
1840: sfbyte(ss_csr, WC_ENABLE_PRTY);
1841: sfbyte(ss_dat, host_id);
1842: sfbyte(ss_csr, WC_ENABLE_PRTY | WC_ARBITRATE);
1843:
1844: /*
1845: * SCSI spec says there is "no maximum" to the wait for arbitration
1846: * complete.
1847: */
1848: for (poll_ct = 0; poll_ct < HIPRI_RETRIES; poll_ct++) {
1849: if (ffbyte(ss_csr) & RS_ARBIT_COMPL) {
1850: ret = 1;
1851: break;
1852: } else if (chk_reconn() != -1) {
1853: sfbyte(ss_csr, WC_ENABLE_PRTY);
1854: break;
1855: }
1856: }
1857: #if (DEBUG >= 1)
1858: if (!ret)
1859: PR1("oSA");
1860: #endif
1861: return ret;
1862: }
1863:
1864: /*
1865: * host_ident()
1866: *
1867: * This routine is the bridge in a SCSI bus cycle between Abitration
1868: * Complete and the Information Transfer phases.
1869: *
1870: * return 1 if everything went ok, 0 in case of timeout
1871: */
1872: static int host_ident(s_id, disconnect)
1873: int s_id;
1874: int disconnect;
1875: {
1876: int ret = 0;
1877:
1878: /*
1879: * Arbitration complete. Now select, with ATN to allow messages.
1880: */
1881: sfbyte(ss_dat, host_id | (1 << s_id)); /* Write both SCSI id's */
1882: sfbyte(ss_csr, WC_ENABLE_PRTY | WC_ENABLE_SCSI | WC_ATTENTION | WC_SELECT);
1883:
1884: if (bus_wait(RS_BUSY << 8 | RS_BUSY)) {
1885: /*
1886: * Assert ATTN so target expects incoming message byte.
1887: */
1888: sfbyte(ss_csr, WC_ENABLE_PRTY | WC_ENABLE_SCSI | WC_ATTENTION);
1889:
1890: if (bus_wait(((RS_REQUEST|RS_CTRL_DATA|RS_I_O|RS_MESSAGE) << 8)
1891: | (RS_REQUEST|RS_CTRL_DATA|RS_MESSAGE))) {
1892: if (disconnect) {
1893: sfbyte(ss_dat, MSG_IDENT_DC);
1894: } else {
1895: sfbyte(ss_dat, MSG_IDENTIFY);
1896: }
1897: sfbyte(ss_csr, WC_ENABLE_PRTY | WC_ENABLE_SCSI | WC_ENABLE_IRPT);
1898: ret = 1;
1899: } else {
1900: PR1("oHI2");
1901: }
1902: } else {
1903: PR1("oHI1");
1904: }
1905: return ret;
1906: }
1907:
1908: /*
1909: * rsel_handshake()
1910: *
1911: * After Reselect is detected, a couple steps are needed before entering
1912: * Information Transfer phases. This routine does those steps.
1913: *
1914: * return 1 if ok, 0 in case of timeout.
1915: */
1916: static int rsel_handshake()
1917: {
1918: int ret = 0;
1919:
1920: sfbyte(ss_csr, WC_ENABLE_PRTY | WC_ENABLE_SCSI | WC_BUSY);
1921: if (bus_wait(RS_SELECT << 8 | 0)) {
1922: sfbyte(ss_csr, WC_ENABLE_PRTY | WC_ENABLE_SCSI);
1923: ret = 1;
1924: }
1925: return ret;
1926: }
1927:
1928: /*
1929: * set_timeout()
1930: *
1931: * Start a timer so as not to wait forever in case something goes wrong while
1932: * waiting for an event. Available delays are:
1933: *
1934: * DELAY_ARB - wait for arbitration complete
1935: * DELAY_BDR - allow settling time after Bus Device Reset
1936: * DELAY_BSY - wait for not HOST_BUSY and bus free
1937: * DELAY_RES - wait for reselect by target
1938: * DELAY_RST - allow settling times when doing SCSI Bus Reset
1939: *
1940: * Second argument is number of clock ticks to wait until timer expiration.
1941: */
1942: static void set_timeout(s_id, delay)
1943: int s_id, delay;
1944: {
1945: ss_type * ssp = ss[s_id];
1946:
1947: ssp->expired = 0;
1948: ssp->waiting = 1;
1949: do_sst_op = 0;
1950: timeout(&(ssp->tim), delay, stop_timeout, s_id);
1951: }
1952:
1953: /*
1954: * stop_timeout()
1955: *
1956: * Called on expiration of the timer for a given target.
1957: * Don't expire a timer if it's no longer active.
1958: */
1959: static void stop_timeout(s_id)
1960: int s_id;
1961: {
1962: ss_type * ssp = ss[s_id];
1963:
1964: if (ssp->waiting) {
1965: ssp->expired = 1;
1966: ssp->waiting = 0;
1967: }
1968: ss_mach(s_id);
1969: }
1970:
1971: /*
1972: * init_pointers()
1973: *
1974: * Initialize command and data pointers when starting (or restarting)
1975: * a block i/o command.
1976: */
1977: static void init_pointers(s_id)
1978: int s_id;
1979: {
1980: ss_type * ssp = ss[s_id];
1981: BUF * bp = ssp->bp;
1982:
1983: ssp->cmdstat = -1;
1984: ssp->cmd_bytes_out = 0;
1985: ssp->avl_count = 0;
1986: }
1987:
1988: /*
1989: * recover()
1990: *
1991: * This routine is called directly or indirectly from ss_mach(). It
1992: * determines what to do when the interface fails to behave as desired.
1993: *
1994: * Arguments are the SCSI id of the target HDC and an error type.
1995: * Error types are:
1996: *
1997: * RV_A_TIMEOUT (arbitration timeout)
1998: * Host adapter takes too long to respond with arbitration complete.
1999: *
2000: * RV_P_TIMEOUT (protocol timeout)
2001: * Timeout waiting for desired SCSI bus status while connected to a target.
2002: *
2003: * RV_R_TIMEOUT (reconnect timeout)
2004: * Timeout after target disconnects, waiting for reconnect.
2005: *
2006: * RV_BF_TIMEOUT (bus free timeout)
2007: * Waited too long for host not busy and BUS_FREE.
2008: *
2009: * RV_CS_BUSY (target device busy)
2010: * Command status returned was Busy.
2011: *
2012: * RV_CS_CHECK (target device check)
2013: * Command status returned was CHECK.
2014: *
2015: * Whenever an error occurs, one of the above inputs, together with the SCSI id
2016: * of the target, is sent to the recovery process. The recovery process in turn
2017: * programs the next state for the machine.
2018: */
2019: static void recover(s_id, errtype)
2020: int s_id;
2021: RV_TYPE errtype;
2022: {
2023: ss_type * ssp = ss[s_id];
2024: BUF * bp = ssp->bp;
2025:
2026: #if (DEBUG >= 1)
2027: int foo;
2028: if ((foo=chk_reconn()) != -1)
2029: printf("HONK%d ", foo);
2030: #endif
2031:
2032: ++ssp->try_count;
2033: if (ssp->try_count < MAX_TRY_COUNT) {
2034:
2035: switch (errtype) {
2036:
2037: case RV_CS_BUSY:
2038: ++ssp->bsy_count;
2039: if (ssp->bsy_count < MAX_BSY_COUNT) {
2040: ssp->state = SST_POLL_BEGIN_IO;
2041: set_timeout(s_id, DELAY_BSY);
2042: } else
2043: ssp->state = SST_BUS_DEV_RESET;
2044: break;
2045:
2046: case RV_CS_CHECK:
2047: ssp->state = SST_REQ_SENSE;
2048: break;
2049:
2050: case RV_P_TIMEOUT:
2051: /* fall thru */
2052: case RV_R_TIMEOUT:
2053: ++ssp->bdr_count;
2054: if (ssp->bdr_count < MAX_BDR_COUNT)
2055: ssp->state = SST_BUS_DEV_RESET;
2056: else
2057: ssp->state = SST_LOPRI_RESET;
2058: break;
2059:
2060: case RV_BF_TIMEOUT:
2061: /* fall thru */
2062: case RV_A_TIMEOUT:
2063: ssp->state = SST_HIPRI_RESET;
2064: }
2065: } else { /* try_count >= MAX_TRY_COUNT */
2066: if (bp) {
2067: bp->b_flag |= BFERR;
2068: printf("(%d,%d): ", major(bp->b_dev), minor(bp->b_dev));
2069: printf("%s error bno=%ld\n",
2070: (bp->b_req == BREAD) ? "read" : "write",
2071: bp->b_bno);
2072: }
2073: ss_finished(s_id);
2074: }
2075: }
2076:
2077: /*
2078: * ss_finished
2079: *
2080: * Release current i/o buffer to the O/S.
2081: */
2082: static void ss_finished(s_id)
2083: int s_id;
2084: {
2085: ss_type * ssp = ss[s_id];
2086: BUF * bp = ssp->bp;
2087: int go_again = 1;
2088:
2089: if (host_claimed == s_id)
2090: host_claimed = -1;
2091: ssp->busy = 0;
2092: if (bp) {
2093: if (!(bp->b_flag & BFERR))
2094: bp->b_resid -= BSIZE;
2095: if ((bp->b_flag & BFERR) || bp->b_resid == 0) {
2096: ssp->bp = NULL;
2097: bdone(bp);
2098: go_again = 0;
2099: }
2100: }
2101: if (go_again) {
2102: ssp->state = SST_POLL_BEGIN_IO;
2103: ssp->bdr_count = 0;
2104: ssp->bsy_count = 0;
2105: ssp->try_count = 0;
2106:
2107: ssp->bno++;
2108: ssp->cmdbuf[2] = ssp->bno >> 24;
2109: ssp->cmdbuf[3] = ssp->bno >> 16;
2110: ssp->cmdbuf[4] = ssp->bno >> 8;
2111: ssp->cmdbuf[5] = ssp->bno;
2112: } else {
2113: /*
2114: * After processing a kernel i/o request, stop the
2115: * state machine for the current id. Then start
2116: * this or some other machine which has a request
2117: * pending.
2118: */
2119: do_sst_op = 0;
2120: ssp->state = SST_DEQUEUE;
2121: next_req(s_id);
2122: }
2123: }
2124:
2125: /*
2126: * next_req()
2127: *
2128: * Given the SCSI id where an i/o request just completed, start handling
2129: * another i/o request - which may be for the same or other SCSI id.
2130: * For now, use round-robin scheduling.
2131: */
2132: static void next_req(s_id)
2133: int s_id;
2134: {
2135: int next_id = s_id;
2136:
2137: while (1) {
2138: next_id++;
2139: if (next_id >= MAX_SCSI_ID)
2140: next_id = 0;
2141: if (ss[next_id]
2142: && (ss[next_id]->state != SST_DEQUEUE || bufq_rd_head(next_id))) {
2143: defer(ss_mach, next_id);
2144: break;
2145: }
2146: if (next_id == s_id)
2147: break;
2148: }
2149: }
2150:
2151: /*
2152: * do_connect()
2153: *
2154: * This function is called when the host is successfully connected to
2155: * the target. It invokes information transfer protocol and then sets
2156: * up some sort of recovery unless the command completed successfully
2157: * or there was a normal disconnect.
2158: */
2159: static void do_connect(s_id)
2160: int s_id;
2161: {
2162: int result;
2163: ss_type * ssp = ss[s_id];
2164:
2165: result = far_info_xfer(s_id);
2166: if (!result)
2167: recover(s_id, RV_P_TIMEOUT);
2168: else if (ssp->msg_in == MSG_DISCONNECT) {
2169: ssp->state = SST_POLL_RESELECT;
2170: set_timeout(s_id, DELAY_RES);
2171: #if 0
2172: if (host_claimed == s_id)
2173: host_claimed = -1;
2174: #endif
2175: } else if (ssp->msg_in == MSG_CMD_CMPLT && ssp->cmdstat == CS_GOOD)
2176: ss_finished(s_id);
2177: else if (ssp->cmdstat == CS_BUSY)
2178: recover(s_id, RV_CS_BUSY);
2179: else if (ssp->cmdstat == CS_CHECK)
2180: recover(s_id, RV_CS_CHECK);
2181: else /* something else went wrong */
2182: recover(s_id, RV_P_TIMEOUT);
2183: }
2184:
2185: /*
2186: * local_info_xfer()
2187: *
2188: * Do bus cycle information transfer phases.
2189: * Transfer is for a command which will produce local results in the driver.
2190: * Other ...info_xfer routine handles kernel block i/o commands.
2191: *
2192: * Return 1 if transfer succeeded, else 0.
2193: *
2194: */
2195: static int local_info_xfer(cmdbuf, cmdlen, inbuf, inlen, outbuf, outlen)
2196: unchar * cmdbuf, * inbuf, * outbuf;
2197: uint cmdlen, inlen, outlen;
2198: {
2199: int bus_timeout;
2200: unchar phase_type;
2201: int s;
2202: int cmd_bytes_out = 0;
2203: int data_bytes_in = 0;
2204: int data_bytes_out = 0;
2205: int ret = 0;
2206: int xfer_good = 1;
2207: int cmdstat = -1;
2208: int msg_in = -1;
2209: #if (DEBUG >= 1)
2210: int x, xct=0;
2211: unchar xch[100];
2212: #endif
2213:
2214: s = sphi();
2215: while (req_wait(&bus_timeout) && xfer_good) {
2216: phase_type = ffbyte(ss_csr) & (RS_MESSAGE|RS_I_O|RS_CTRL_DATA);
2217: #if (DEBUG >= 1)
2218: if (xct < 100)
2219: xch[xct++]=phase_type;
2220: #endif
2221: switch (xpmod(phase_type)) {
2222: case XP_MSG_IN:
2223: msg_in = ffbyte(ss_dat);
2224: switch(msg_in){
2225: case MSG_CMD_CMPLT:
2226: case MSG_DISCONNECT:
2227: sfbyte(ss_csr, WC_ENABLE_PRTY | WC_ENABLE_IRPT);
2228: break;
2229: }
2230: break;
2231: case XP_MSG_OUT:
2232: /*
2233: * This case shouldn't happen. We weren't
2234: * asserting ATTENTION.
2235: */
2236: sfbyte(ss_dat, MSG_NOP);
2237: sfbyte(ss_csr, WC_ENABLE_PRTY | WC_ENABLE_SCSI);
2238: break;
2239: case XP_STAT_IN:
2240: cmdstat = ffbyte(ss_dat);
2241: break;
2242: case XP_CMD_OUT:
2243: /*
2244: * Ship out command bytes.
2245: */
2246: if (cmd_bytes_out < cmdlen) {
2247: sfbyte(ss_dat, cmdbuf[cmd_bytes_out++]);
2248: #if 1
2249: /*
2250: * If just sent last byte, allow interrupts.
2251: */
2252: if (cmd_bytes_out == cmdlen) {
2253: spl(s);
2254: s = sphi();
2255: }
2256: #endif
2257: } else { /* This case should not happen. */
2258: xfer_good = 0;
2259: }
2260: break;
2261: case XP_DATA_IN:
2262: /*
2263: * If caller's buffer has room, keep incoming
2264: * data byte. Else toss it.
2265: */
2266: if (data_bytes_in < inlen) {
2267: #if 0
2268: do {
2269: inbuf[data_bytes_in++] = ffbyte(ss_dat);
2270: } while (data_bytes_in < inlen);
2271: #else
2272: inbuf[data_bytes_in++] = ffbyte(ss_dat);
2273: #endif
2274: } else
2275: xfer_good = 0;
2276: break;
2277: case XP_DATA_OUT:
2278: /*
2279: * Copy output buffer bytes to data register.
2280: */
2281: if (data_bytes_out < outlen) {
2282: sfbyte(outbuf[data_bytes_out++], ss_dat);
2283: } else { /* This case should not happen. */
2284: xfer_good = 0;
2285: }
2286: break;
2287: default:
2288: break;
2289: } /* endswitch */
2290: }
2291: spl(s);
2292:
2293: if (bus_timeout) {
2294: PR1("oLX1");
2295: } else if (!xfer_good) {
2296: PR1("oLX2");
2297: } else if (cmdstat != CS_GOOD) {
2298: PR1("oLX3");
2299: #if (DEBUG >= 1)
2300: printf("cmdstat=%x ", cmdstat);
2301: #endif
2302: } else
2303: ret = 1;
2304: #if (DEBUG >= 1)
2305: if (!ret) {
2306: printf("csr=%x ", ffbyte(ss_csr));
2307: printf("xct=%d ", xct);
2308: for (x=0; x < xct; x++)
2309: printf("%x ", xch[x]);
2310: }
2311: #endif
2312:
2313: return ret;
2314: }
2315:
2316: /*
2317: * scsireset()
2318: *
2319: * Reset the SCSI bus.
2320: * Allow settling time when turning reset on/off.
2321: * Settling times were determined empirically.
2322: * Each tick is 10 msec.
2323: */
2324: static void scsireset()
2325: {
2326: int s;
2327:
2328: #if (DEBUG >= 1)
2329: printf("scsireset ");
2330: #endif
2331: s = splo();
2332: sfbyte(ss_csr, WC_ENABLE_PRTY | WC_ENABLE_SCSI | WC_SCSI_RESET);
2333: ssdelay(RESET_TICKS);
2334: sfbyte(ss_csr, WC_ENABLE_PRTY);
2335: ssdelay(RESET_TICKS);
2336: spl(s);
2337: }
2338:
2339: /*
2340: * ssdelay()
2341: *
2342: * Delay for some number of arbitrary ticks.
2343: *
2344: * Using sleep() causes a panic if this driver is linked to the kernel,
2345: * even though this routine is called only via ssload().
2346: */
2347: static void ssdelay(ticks)
2348: int ticks;
2349: {
2350: #if 0
2351: timeout(&delay_tim, ticks, wakeup, (int)&delay_tim);
2352: sleep((char *)&delay_tim, CVPAUSE, IVPAUSE, SVPAUSE);
2353: #else
2354: int i, j;
2355:
2356: for (i = 0; i < ticks; i++)
2357: for (j = 0; j < LOAD_DELAY; j++);
2358: #endif
2359: }
2360:
2361: /*
2362: * init_call()
2363: *
2364: * Call SCSI command function during initialization, with error recovery.
2365: * If the simple command fails, try a Bus Device Reset, then SCSI Bus reset.
2366: */
2367: static int init_call(fn, s_id, buf)
2368: int (*fn)();
2369: int s_id;
2370: unchar * buf;
2371: {
2372: int ret = 1;
2373: int i;
2374: int o_id;
2375: int s;
2376: s=sphi();
2377: for (i = 0; i < 2; i++) {
2378: o_id = chk_reconn();
2379: if (o_id != -1)
2380: dummy_reconn(s_id);
2381: if ((*fn)(s_id, buf))
2382: goto init_call_done;
2383:
2384: req_sense(s_id);
2385: if ((*fn)(s_id, buf))
2386: goto init_call_done;
2387:
2388: if (bus_dev_reset(s_id)) {
2389: ssdelay(RESET_TICKS);
2390: req_sense(s_id);
2391: if ((*fn)(s_id, buf))
2392: goto init_call_done;
2393: }
2394:
2395: scsireset();
2396: req_sense(s_id);
2397: if ((*fn)(s_id, buf))
2398: goto init_call_done;
2399: }
2400:
2401: ret = 0;
2402:
2403: init_call_done:
2404: spl(s);
2405: return ret;
2406: }
2407:
2408: /*
2409: * xpmod()
2410: *
2411: * Command/Data and Message bits are swapped on-board (outside the chip)
2412: * on older Future Domain host boards.
2413: */
2414: static unchar xpmod(oldphase)
2415: unchar oldphase;
2416: {
2417: unchar ret = oldphase;
2418:
2419: if (swap_status_bits) {
2420: ret &= ~(RS_CTRL_DATA | RS_MESSAGE);
2421: if (oldphase & RS_MESSAGE)
2422: ret |= RS_CTRL_DATA;
2423: if (oldphase & RS_CTRL_DATA)
2424: ret |= RS_MESSAGE;
2425: }
2426: return ret;
2427: }
2428:
2429: /*
2430: * tbparms()
2431: *
2432: * If the drive table has already been patched for this SCSI id, do nothing.
2433: * Otherwise, given the real-mode drive number (tbnum) and the SCSI id (s_id),
2434: * look for drive parameters from tertiary boot, and copy into driver
2435: * data block if we find them.
2436: */
2437: static void tbparms(tbnum, s_id)
2438: int tbnum, s_id;
2439: {
2440: FIFO *ffp;
2441: typed_space *tp;
2442: extern typed_space boot_gift;
2443:
2444: if (drv_parm[s_id].ncyl == 0
2445: && F_NULL != (ffp = fifo_open(&boot_gift, 0))) {
2446:
2447: if (tp = fifo_read(ffp)) {
2448: BIOS_DISK *bdp = (BIOS_DISK *)tp->ts_data;
2449: if ((T_BIOS_DISK == tp->ts_type) &&
2450: (tbnum == bdp->dp_drive) ) {
2451: drv_parm[s_id].ncyl = bdp->dp_cylinders;
2452: drv_parm[s_id].nhead = bdp->dp_heads;
2453: drv_parm[s_id].nspt = bdp->dp_sectors;
2454: }
2455: }
2456: fifo_close(ffp);
2457: }
2458: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.