![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to scsi.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / sys / hpstand|
Return to scsi.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sys / hpstand |
1.1 root 1: /*
2: * Copyright (c) 1988 University of Utah.
3: * Copyright (c) 1990 The Regents of the University of California.
4: * All rights reserved.
5: *
6: * This code is derived from software contributed to Berkeley by
7: * Van Jacobson of Lawrence Berkeley Laboratory and the Systems
8: * Programming Group of the University of Utah Computer Science Department.
9: *
10: * Redistribution is only permitted until one year after the first shipment
11: * of 4.4BSD by the Regents. Otherwise, redistribution and use in source and
12: * binary forms are permitted provided that: (1) source distributions retain
13: * this entire copyright notice and comment, and (2) distributions including
14: * binaries display the following acknowledgement: This product includes
15: * software developed by the University of California, Berkeley and its
16: * contributors'' in the documentation or other materials provided with the
17: * distribution and in all advertising materials mentioning features or use
18: * of this software. Neither the name of the University nor the names of
19: * its contributors may be used to endorse or promote products derived from
20: * this software without specific prior written permission.
21: * THIS SOFTWARE IS PROVIDED AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
22: * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
23: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
24: *
25: * from: Utah $Hdr: scsi.c 1.3 90/01/27$
26: *
27: * @(#)scsi.c 7.1 (Berkeley) 5/8/90
28: */
29:
30: /*
31: * SCSI bus driver for standalone programs.
32: */
33:
34: #include "../sys/types.h"
35: #include "../sys/reboot.h"
36: #include "../hpdev/device.h"
37: #include "../hpdev/scsireg.h"
38: #include "scsivar.h"
39:
40: #include "saio.h"
41: #include "samachdep.h"
42:
43: struct scsi_softc scsi_softc[NSCSI];
44:
45: #define scsiunit(x) ((x) >> 3)
46: #define scsislave(x) ((x) & 7)
47:
48: void scsireset();
49: int scsi_cmd_wait = 500;
50: int scsi_data_wait = 300000;
51:
52: scsiinit()
53: {
54: extern struct hp_hw sc_table[];
55: register struct hp_hw *hw;
56: register struct scsi_softc *hs;
57: register int i, addr;
58: static int first = 1;
59:
60: i = 0;
61: for (hw = sc_table; i < NSCSI && hw < &sc_table[MAX_CTLR]; hw++) {
62: if (hw->hw_type != SCSI)
63: continue;
64: hs = &scsi_softc[i];
65: hs->sc_addr = hw->hw_addr;
66: scsireset(i);
67: if (howto & RB_ASKNAME)
68: printf("scsi%d at sc%d\n", i, hw->hw_sc);
69: /*
70: * Adjust devtype on first call. This routine assumes that
71: * adaptor is in the high byte of devtype.
72: */
73: if (first && ((devtype >> 24) & 0xff) == hw->hw_sc) {
74: devtype = (devtype & 0x00ffffff) | (i << 24);
75: first = 0;
76: }
77: hs->sc_alive = 1;
78: i++;
79: }
80: }
81:
82: scsialive(unit)
83: register int unit;
84: {
85: unit = scsiunit(unit);
86: if (unit >= NSCSI || scsi_softc[unit].sc_alive == 0)
87: return (0);
88: return (1);
89: }
90:
91: void
92: scsireset(unit)
93: register int unit;
94: {
95: volatile register struct scsidevice *hd;
96: register struct scsi_softc *hs;
97: u_int i;
98:
99: unit = scsiunit(unit);
100: hs = &scsi_softc[unit];
101: hd = (struct scsidevice *)hs->sc_addr;
102: hd->scsi_id = 0xFF;
103: DELAY(100);
104: /*
105: * Disable interrupts then reset the FUJI chip.
106: */
107: hd->scsi_csr = 0;
108: hd->scsi_sctl = SCTL_DISABLE | SCTL_CTRLRST;
109: hd->scsi_scmd = 0;
110: hd->scsi_tmod = 0;
111: hd->scsi_pctl = 0;
112: hd->scsi_temp = 0;
113: hd->scsi_tch = 0;
114: hd->scsi_tcm = 0;
115: hd->scsi_tcl = 0;
116: hd->scsi_ints = 0;
117:
118: /*
119: * Configure the FUJI chip with its SCSI address, all
120: * interrupts enabled & appropriate parity.
121: */
122: i = (~hd->scsi_hconf) & 0x7;
123: hs->sc_scsi_addr = 1 << i;
124: hd->scsi_bdid = i;
125: if (hd->scsi_hconf & HCONF_PARITY)
126: hd->scsi_sctl = SCTL_DISABLE | SCTL_ABRT_ENAB |
127: SCTL_SEL_ENAB | SCTL_RESEL_ENAB |
128: SCTL_INTR_ENAB | SCTL_PARITY_ENAB;
129: else
130: hd->scsi_sctl = SCTL_DISABLE | SCTL_ABRT_ENAB |
131: SCTL_SEL_ENAB | SCTL_RESEL_ENAB |
132: SCTL_INTR_ENAB;
133: hd->scsi_sctl &=~ SCTL_DISABLE;
134: }
135:
136:
137: int
138: scsiabort(hs, hd)
139: register struct scsi_softc *hs;
140: volatile register struct scsidevice *hd;
141: {
142: printf("scsi error: scsiabort\n");
143: return (0);
144: }
145:
146: static int
147: issue_select(hd, target, our_addr)
148: volatile register struct scsidevice *hd;
149: u_char target, our_addr;
150: {
151: if (hd->scsi_ssts & (SSTS_INITIATOR|SSTS_TARGET|SSTS_BUSY))
152: return (1);
153:
154: if (hd->scsi_ints & INTS_DISCON)
155: hd->scsi_ints = INTS_DISCON;
156:
157: hd->scsi_pctl = 0;
158: hd->scsi_temp = (1 << target) | our_addr;
159: /* select timeout is hardcoded to 2ms */
160: hd->scsi_tch = 0;
161: hd->scsi_tcm = 32;
162: hd->scsi_tcl = 4;
163:
164: hd->scsi_scmd = SCMD_SELECT;
165: return (0);
166: }
167:
168: static int
169: wait_for_select(hd)
170: volatile register struct scsidevice *hd;
171: {
172: u_char ints;
173:
174: while ((ints = hd->scsi_ints) == 0)
175: DELAY(1);
176: hd->scsi_ints = ints;
177: return (!(hd->scsi_ssts & SSTS_INITIATOR));
178: }
179:
180: static int
181: ixfer_start(hd, len, phase, wait)
182: volatile register struct scsidevice *hd;
183: int len;
184: u_char phase;
185: register int wait;
186: {
187:
188: hd->scsi_tch = len >> 16;
189: hd->scsi_tcm = len >> 8;
190: hd->scsi_tcl = len;
191: hd->scsi_pctl = phase;
192: hd->scsi_tmod = 0; /*XXX*/
193: hd->scsi_scmd = SCMD_XFR | SCMD_PROG_XFR;
194:
195: /* wait for xfer to start or svc_req interrupt */
196: while ((hd->scsi_ssts & SSTS_BUSY) == 0) {
197: if (hd->scsi_ints || --wait < 0)
198: return (0);
199: DELAY(1);
200: }
201: return (1);
202: }
203:
204: static int
205: ixfer_out(hd, len, buf)
206: volatile register struct scsidevice *hd;
207: int len;
208: register u_char *buf;
209: {
210: register int wait = scsi_data_wait;
211:
212: for (; len > 0; --len) {
213: while (hd->scsi_ssts & SSTS_DREG_FULL) {
214: if (hd->scsi_ints || --wait < 0)
215: return (len);
216: DELAY(1);
217: }
218: hd->scsi_dreg = *buf++;
219: }
220: return (0);
221: }
222:
223: static int
224: ixfer_in(hd, len, buf)
225: volatile register struct scsidevice *hd;
226: int len;
227: register u_char *buf;
228: {
229: register int wait = scsi_data_wait;
230:
231: for (; len > 0; --len) {
232: while (hd->scsi_ssts & SSTS_DREG_EMPTY) {
233: if (hd->scsi_ints || --wait < 0) {
234: while (! (hd->scsi_ssts & SSTS_DREG_EMPTY)) {
235: *buf++ = hd->scsi_dreg;
236: --len;
237: }
238: return (len);
239: }
240: DELAY(1);
241: }
242: *buf++ = hd->scsi_dreg;
243: }
244: return (len);
245: }
246:
247: static int
248: scsiicmd(hs, target, cbuf, clen, buf, len, xferphase)
249: struct scsi_softc *hs;
250: int target;
251: u_char *cbuf;
252: int clen;
253: u_char *buf;
254: int len;
255: u_char xferphase;
256: {
257: volatile register struct scsidevice *hd =
258: (struct scsidevice *)hs->sc_addr;
259: int i;
260: u_char phase, ints;
261: register int wait;
262:
263: /* select the SCSI bus (it's an error if bus isn't free) */
264: if (issue_select(hd, target, hs->sc_scsi_addr))
265: return (0);
266: if (wait_for_select(hd))
267: return (0);
268: /*
269: * Wait for a phase change (or error) then let the device
270: * sequence us through the various SCSI phases.
271: */
272: phase = CMD_PHASE;
273: while (1) {
274: wait = scsi_cmd_wait;
275: switch (phase) {
276:
277: case CMD_PHASE:
278: if (ixfer_start(hd, clen, phase, wait))
279: if (ixfer_out(hd, clen, cbuf))
280: goto abort;
281: phase = xferphase;
282: break;
283:
284: case DATA_IN_PHASE:
285: if (len <= 0)
286: goto abort;
287: wait = scsi_data_wait;
288: if (ixfer_start(hd, len, phase, wait) ||
289: !(hd->scsi_ssts & SSTS_DREG_EMPTY))
290: ixfer_in(hd, len, buf);
291: phase = STATUS_PHASE;
292: break;
293:
294: case DATA_OUT_PHASE:
295: if (len <= 0)
296: goto abort;
297: wait = scsi_data_wait;
298: if (ixfer_start(hd, len, phase, wait))
299: if (ixfer_out(hd, len, buf))
300: goto abort;
301: phase = STATUS_PHASE;
302: break;
303:
304: case STATUS_PHASE:
305: wait = scsi_data_wait;
306: if (ixfer_start(hd, sizeof(hs->sc_stat), phase, wait) ||
307: !(hd->scsi_ssts & SSTS_DREG_EMPTY))
308: ixfer_in(hd, sizeof(hs->sc_stat), &hs->sc_stat);
309: phase = MESG_IN_PHASE;
310: break;
311:
312: case MESG_IN_PHASE:
313: if (ixfer_start(hd, sizeof(hs->sc_msg), phase, wait) ||
314: !(hd->scsi_ssts & SSTS_DREG_EMPTY)) {
315: ixfer_in(hd, sizeof(hs->sc_msg), &hs->sc_msg);
316: hd->scsi_scmd = SCMD_RST_ACK;
317: }
318: phase = BUS_FREE_PHASE;
319: break;
320:
321: case BUS_FREE_PHASE:
322: return (1);
323:
324: default:
325: printf("unexpected scsi phase %d\n", phase);
326: goto abort;
327: }
328: /* wait for last command to complete */
329: while ((ints = hd->scsi_ints) == 0) {
330: if (--wait < 0)
331: goto abort;
332: DELAY(1);
333: }
334: hd->scsi_ints = ints;
335: if (ints & INTS_SRV_REQ)
336: phase = hd->scsi_psns & PHASE;
337: else if (ints & INTS_DISCON)
338: return (1);
339: else if ((ints & INTS_CMD_DONE) == 0) {
340: goto abort;
341: }
342: }
343: abort:
344: scsiabort(hs, hd);
345: return (0);
346: }
347:
348: int
349: scsi_test_unit_rdy(unit)
350: {
351: int ctlr = scsiunit(unit);
352: int slave = scsislave(unit);
353: register struct scsi_softc *hs = &scsi_softc[ctlr];
354: static struct scsi_cdb6 cdb = { CMD_TEST_UNIT_READY };
355:
356: if (scsiicmd(hs, slave, &cdb, sizeof(cdb), (u_char *)0, 0,
357: STATUS_PHASE) == 0)
358: return (0);
359:
360: return (hs->sc_stat == 0);
361: }
362:
363: int
364: scsi_request_sense(unit, buf, len)
365: int unit;
366: u_char *buf;
367: unsigned len;
368: {
369: int ctlr = scsiunit(unit);
370: int slave = scsislave(unit);
371: register struct scsi_softc *hs = &scsi_softc[ctlr];
372: static struct scsi_cdb6 cdb = { CMD_REQUEST_SENSE };
373:
374: cdb.len = len;
375: return (scsiicmd(hs, slave, &cdb, sizeof(cdb), buf, len, DATA_IN_PHASE));
376: }
377:
378: int
379: scsi_read_capacity(unit, buf, len)
380: int unit;
381: u_char *buf;
382: unsigned len;
383: {
384: int ctlr = scsiunit(unit);
385: int slave = scsislave(unit);
386: register struct scsi_softc *hs = &scsi_softc[ctlr];
387: static struct scsi_cdb10 cdb = { CMD_READ_CAPACITY };
388:
389: return (scsiicmd(hs, slave, &cdb, sizeof(cdb), buf, len, DATA_IN_PHASE));
390: }
391:
392: int
393: scsi_tt_read(unit, buf, len, blk, nblk)
394: int unit;
395: u_char *buf;
396: u_int len;
397: daddr_t blk;
398: u_int nblk;
399: {
400: int ctlr = scsiunit(unit);
401: int slave = scsislave(unit);
402: register struct scsi_softc *hs = &scsi_softc[ctlr];
403: struct scsi_cdb10 cdb;
404: int stat;
405:
406: bzero(&cdb, sizeof(cdb));
407: cdb.cmd = CMD_READ_EXT;
408: cdb.lbah = blk >> 24;
409: cdb.lbahm = blk >> 16;
410: cdb.lbalm = blk >> 8;
411: cdb.lbal = blk;
412: cdb.lenh = nblk >> (8 + DEV_BSHIFT);
413: cdb.lenl = nblk >> DEV_BSHIFT;
414: stat = scsiicmd(hs, slave, &cdb, sizeof(cdb), buf, len, DATA_IN_PHASE);
415: if (stat == 0)
416: return (1);
417: return (hs->sc_stat);
418: }
419:
420: int
421: scsi_tt_write(unit, buf, len, blk, nblk)
422: int unit;
423: u_char *buf;
424: u_int len;
425: daddr_t blk;
426: u_int nblk;
427: {
428: int ctlr = scsiunit(unit);
429: int slave = scsislave(unit);
430: register struct scsi_softc *hs = &scsi_softc[ctlr];
431: struct scsi_cdb10 cdb;
432: int stat;
433:
434: bzero(&cdb, sizeof(cdb));
435: cdb.cmd = CMD_WRITE_EXT;
436: cdb.lbah = blk >> 24;
437: cdb.lbahm = blk >> 16;
438: cdb.lbalm = blk >> 8;
439: cdb.lbal = blk;
440: cdb.lenh = nblk >> (8 + DEV_BSHIFT);
441: cdb.lenl = nblk >> DEV_BSHIFT;
442: stat = scsiicmd(hs, slave, &cdb, sizeof(cdb), buf, len, DATA_OUT_PHASE);
443: if (stat == 0)
444: return (1);
445: return (hs->sc_stat);
446: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.