![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to st.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / sys / boot / stand|
Return to st.c CVS log | Up to [Research Unix] / researchv9 / sys / boot / stand |
1.1 root 1: /*
2: * @(#)st.c 1.1 86/02/03 Copyright (c) 1985 by Sun Microsystems, Inc.
3: */
4:
5: #include <sys/types.h>
6: #include <sys/inode.h>
7: #include <sun/dklabel.h>
8: #include <sun/dkio.h>
9: #include <sys/buf.h>
10: #include <sundev/screg.h>
11: #include <sundev/sireg.h>
12: #include <sundev/scsi.h>
13: #include <sundev/streg.h>
14: #include <machine/idprom.h>
15: #include "saio.h"
16: #include "param.h"
17:
18: /*
19: * Driver for Sysgen SC4000 and EMULEX MT-02 SCSI tape controllers.
20: * Supports qic11 format only.
21: */
22: extern int scdoit();
23: #ifdef SUN3
24: extern int sidoit();
25: #endif
26:
27: #define min(a,b) ((a)<(b)? (a): (b))
28:
29: #define NSD 1
30: unsigned long staddrs[NSD] = { 0x0, };
31:
32: extern int xxprobe(), xxboot();
33: int stopen(), stclose(), ststrategy();
34:
35:
36: struct stparam {
37: int st_target;
38: int st_unit;
39: int st_eof;
40: int st_lastcmd;
41: int st_ctype;
42: #ifdef SUN3
43: int st_ha_type;
44: #endif
45: struct saioreq subsip[1]; /* sip for host adapter */
46: };
47:
48: /*
49: * DMA-able buffers
50: */
51: #ifdef SUN2
52: /* virtual addresses are precious on Sun-2 */
53: #define MAXSTBSIZE (20*1024)
54: #endif
55: #ifdef SUN3
56: #define MAXSTBSIZE (127*512)
57: #endif
58: struct stdma {
59: char sbuffer[SENSE_LENGTH];
60: char databuffer[MAXSTBSIZE];
61: };
62:
63: #define STSBUF (((struct stdma *)sip->si_dmaaddr)->sbuffer)
64: #define STBUF (((struct stdma *)sip->si_dmaaddr)->databuffer)
65:
66: #define ISAEMULEX(stp) (stp->st_ctype == ST_TYPE_EMULEX ? 1 : 0)
67:
68: /*
69: * What resources we need to run
70: */
71: struct devinfo stinfo = {
72: 0, /* No device to map in */
73: sizeof (struct stdma),
74: sizeof (struct stparam),
75: NSD, /* Dummy devices */
76: staddrs, /* Dummy devices */
77: MAP_MAINMEM,
78: MAXSTBSIZE, /* transfer size */
79: };
80:
81: struct boottab stdriver = {
82: "st", xxprobe, xxboot,
83: stopen, stclose, ststrategy,
84: "st: SCSI tape", &stinfo
85: };
86:
87: #define TAPE_TARGET 4 /* default SCSI target # for tape */
88:
89: #define SENSE_BITS \
90: "\020\17NoCart\16NoDrive\15WriteProt\14EndMedium\13HardErr\12WrongBlock\
91: \11FileMark\7InvCmd\6NoData\5Flaking\4BOT\0034\0022\1GotReset"
92:
93: #define SENSELOC 4 /* sysgen returns sense at this offset */
94:
95: #define ROUNDUP(x) ((x + DEV_BSIZE - 1) & ~(DEV_BSIZE - 1))
96:
97: #ifdef SUN3
98: /*
99: * Determine type of host adaptor interface, si or sc.
100: * Returns 1 if si host adaptor and 0 if sc host adaptor.
101: */
102: st_probe(sip)
103: struct saioreq *sip;
104: {
105: if (siprobe(sip)) {
106: return (1);
107: } else {
108: return (0);
109: }
110: }
111: #endif
112:
113: /*
114: * Open the SCSI Tape controller
115: */
116: int
117: stopen(sip)
118: register struct saioreq *sip;
119: {
120: register struct stparam *stp;
121: register int r;
122: register int skip;
123: register int i;
124: struct scsi_cdb cdb;
125: struct scsi_scb scb;
126:
127: stp = (struct stparam *) sip->si_devdata;
128: bzero( (char *)stp, (sizeof (struct stparam)));
129:
130: *stp->subsip = *sip; /* initialize subsip */
131:
132: #ifdef SUN3
133: {
134: extern struct boottab scdriver;
135: extern struct boottab sidriver;
136:
137: /* FIXME, find out which scsi interface to use */
138: if (st_probe(sip)) {
139: stp->st_ha_type = 1;
140:
141: /* FIXME, must vector thru table */
142: stp->subsip->si_boottab = &sidriver;
143: } else {
144: stp->st_ha_type = 0;
145:
146: /* FIXME, must vector thru table */
147: stp->subsip->si_boottab = &scdriver;
148: }
149: }
150: #endif
151: #ifdef SUN2
152: {
153: extern struct boottab scdriver;
154:
155: stp->subsip->si_boottab = &scdriver;
156: }
157: #endif
158:
159: stp->subsip->si_unit = sip->si_unit >> 3; /* Target number */
160: if (stp->subsip->si_unit == 0) {
161: stp->subsip->si_unit = TAPE_TARGET;
162: }
163:
164: r = devopen(stp->subsip);
165: if (r < 0) return r;
166:
167: /* Logical unit number */
168: stp->st_unit = sip->si_unit & 0x07;
169:
170: /*
171: * Must wait for tape controller to become ready.
172: * This takes about 10 seconds for the Emulex.
173: */
174: /*
175: * Test for the controller being ready. First test will fail if
176: * the SCSI bus is permanently busy or if a previous op was
177: * interrupted in mid-transfer. Second one should work.
178: */
179: for (i = 0; i < 2; i++) {
180: bzero((char *) &cdb, sizeof cdb);
181: cdb.cmd = SC_TEST_UNIT_READY;
182: cdb.count = 0;
183: stp->subsip->si_cc = 0;
184: stp->subsip->si_ma = 0;
185: #ifdef SUN3
186: if (stp->st_ha_type)
187: r = sidoit(&cdb, &scb, stp->subsip);
188: else
189: #endif
190: r = scdoit(&cdb, &scb, stp->subsip);
191: }
192:
193: /*
194: * To figure out what type of tape controller is out there we send
195: * a REQUEST_SENSE command and see how much sense data comes back.
196: */
197: stp->st_ctype = ST_TYPE_EMULEX;
198: cdb.cmd = SC_REQUEST_SENSE;
199: stp->subsip->si_cc = cdb.count = ST_EMULEX_SENSE_LEN;
200: stp->subsip->si_ma = STSBUF;
201: #ifdef SUN3
202: if (stp->st_ha_type)
203: r = sidoit(&cdb, &scb, stp->subsip);
204: else
205: #endif
206: r = scdoit(&cdb, &scb, stp->subsip);
207: if (r != ST_EMULEX_SENSE_LEN) {
208: stp->st_ctype = ST_TYPE_SYSGEN;
209: cdb.cmd = SC_REQUEST_SENSE;
210: stp->subsip->si_cc = cdb.count = ST_SYSGEN_SENSE_LEN;
211: stp->subsip->si_ma = STSBUF;
212: #ifdef SUN3
213: if (stp->st_ha_type)
214: r = sidoit(&cdb, &scb, stp->subsip);
215: else
216: #endif
217: r = scdoit(&cdb, &scb, stp->subsip);
218: if (r == -1) {
219: printf("stopen: cannot get sense, %d\n", r);
220: return (-1);
221: }
222: }
223:
224: /*
225: * Default format mode for emulex is qic24.
226: * Needs to be qic11.
227: */
228: if (ISAEMULEX(stp)) {
229: sip->si_cc = EM_MS_PL_LEN;
230: if (stcmd(SC_QIC11, sip, 1) == 0) {
231: printf("stopen: mode select command fail");
232: return (-1);
233: }
234: }
235:
236: /*
237: * Rewind a few times until it works. First one will fail if
238: * the SCSI bus is permanently busy if a previous op was interrupted
239: * in mid-transfer. Second one will fail with POR status, after
240: * the scsi bus is reset from the busy. Third one should work.
241: */
242: sip->si_cc = 0;
243: if (stcmd(SC_REWIND, sip, 0) == 0 &&
244: stcmd(SC_REWIND, sip, 0) == 0 &&
245: stcmd(SC_REWIND, sip, 1) == 0) {
246: return (-1);
247: }
248: skip = sip->si_boff;
249: while (skip--) {
250: sip->si_cc = 0;
251: if (stcmd(SC_SPACE_FILE, sip, 1) == 0) {
252: return (-1);
253: }
254: }
255: stp->st_eof = 0;
256: stp->st_lastcmd = 0;
257: return (0);
258: }
259:
260: /*
261: * Close the tape drive.
262: */
263: stclose(sip)
264: register struct saioreq *sip;
265: {
266: register struct stparam *stp;
267:
268: stp = (struct stparam *) sip->si_devdata;
269: if (stp->st_lastcmd == SC_WRITE) {
270: (void) stcmd(SC_WRITE_FILE_MARK, sip, 0);
271: }
272: (void) stcmd(SC_REWIND, sip, 0);
273: }
274:
275:
276: /*
277: * Perform a read or write of the SCSI tape.
278: */
279: int
280: ststrategy(sip, rw)
281: register struct saioreq *sip;
282: int rw;
283: {
284: register struct stparam *stp;
285:
286: stp = (struct stparam *) sip->si_devdata;
287: if (stp->st_eof) {
288: stp->st_eof = 0;
289: return (0);
290: }
291: return (stcmd(rw == WRITE ? SC_WRITE : SC_READ, sip, 1));
292: }
293:
294: /*
295: * Execute a scsi tape command
296: */
297: int
298: stcmd(cmd, sip, errprint)
299: int cmd;
300: register struct saioreq *sip;
301: int errprint;
302: {
303: register struct st_emulex_mspl *mode;
304: register int r, i, c;
305: register char *buf;
306: register struct stparam *stp;
307: struct scsi_cdb cdb, scdb;
308: struct scsi_scb scb, sscb;
309: int count;
310: int qic;
311: int sense_length;
312: char *cp;
313: struct st_emulex_sense *ems;
314: struct st_sysgen_sense *scs;
315:
316: count = sip->si_cc;
317: stp = (struct stparam *)sip->si_devdata;
318: buf = sip->si_ma;
319:
320: if (cmd == SC_WRITE && buf != STBUF) {
321: bcopy(buf, STBUF, (unsigned)count);
322: }
323:
324: /* set up cdb */
325: bzero((char *) &cdb, sizeof cdb);
326: cdb.cmd = cmd;
327: cdb.lun = stp->st_unit;
328: c = ROUNDUP(count) / DEV_BSIZE;
329: cdb.high_count = c >> 16;
330: cdb.mid_count = (c >> 8) & 0xFF;
331: cdb.low_count = c & 0xFF;
332: stp->subsip->si_ma = STBUF;
333: stp->subsip->si_cc = ROUNDUP(count);
334:
335: /* some fields in the cdb are command specific */
336: switch (cmd) {
337:
338: case SC_QIC11:
339: stp->subsip->si_ma = 0;
340: stp->subsip->si_cc = 0;
341: if (ISAEMULEX(stp)) {
342: qic = ST_EMULEX_QIC11;
343: cdb.cmd = SC_MODE_SELECT;
344: goto MODE;
345: } else {
346: cdb.cmd = SC_QIC02;
347: cdb.high_count = ST_SYSGEN_QIC11;
348: break;
349: }
350: /* NOTREACHED */
351:
352: case SC_QIC24:
353: stp->subsip->si_ma = 0;
354: stp->subsip->si_cc = 0;
355: if (ISAEMULEX(stp)) {
356: qic = ST_EMULEX_QIC24;
357: cdb.cmd = SC_MODE_SELECT;
358: goto MODE;
359: } else {
360: cdb.cmd = SC_QIC02;
361: cdb.high_count = ST_SYSGEN_QIC24;
362: break;
363: }
364: /* NOTREACHED */
365: MODE:
366: case SC_MODE_SELECT:
367: mode = (struct st_emulex_mspl *)STSBUF;
368: bzero(mode, sizeof(*mode));
369: mode->hdr.bufm = 1;
370: mode->bd.density = qic;
371: mode->hdr.bd_len = EM_MS_BD_LEN;
372: stp->subsip->si_ma = (char *)mode;
373: stp->subsip->si_cc = cdb.count = EM_MS_PL_LEN;
374: break;
375:
376: case SC_SPACE_FILE:
377: cdb.cmd = SC_SPACE; /* the real SCSI cmd */
378: cdb.t_code = 1; /* space file, not rec */
379: cdb.low_count = 1; /* space 1 file, not 0 */
380: stp->subsip->si_ma = 0;
381: stp->subsip->si_cc = 0;
382: break;
383:
384: case SC_WRITE_FILE_MARK:
385: cdb.count = 1;
386: /* fall through... */
387:
388: case SC_TEST_UNIT_READY:
389: case SC_REWIND:
390: case SC_LOAD:
391: stp->subsip->si_ma = 0;
392: stp->subsip->si_cc = 0;
393: break;
394:
395: case SC_READ:
396: case SC_WRITE:
397: if (ISAEMULEX(stp)) {
398: cdb.t_code = 1;
399: }
400: break;
401:
402: default:
403: if (errprint)
404: printf("st: unknown command\n");
405: return (0);
406: }
407:
408: /* execute the command */
409: #ifdef SUN3
410: if (stp->st_ha_type)
411: r = sidoit(&cdb, &scb, stp->subsip);
412: else
413: #endif
414: r = scdoit(&cdb, &scb, stp->subsip);
415:
416: /* allow for tape blocking */
417: if (r > count)
418: r = count;
419: /* error */
420: if (r == -1)
421: return (0);
422:
423: if (cmd == SC_READ) {
424: if (min(count, r))
425: bcopy(STBUF, buf, (unsigned)(min(count, r)));
426: }
427:
428: /* we may need to get sense data */
429: if (scb.chk) {
430: bzero((char *) &scdb, sizeof scdb);
431: scdb.cmd = SC_REQUEST_SENSE;
432: scdb.lun = stp->st_unit;
433: if (ISAEMULEX(stp)) {
434: sense_length = stp->subsip->si_cc =
435: scdb.count = ST_EMULEX_SENSE_LEN;
436: } else {
437: sense_length = stp->subsip->si_cc =
438: scdb.count = ST_SYSGEN_SENSE_LEN;
439: }
440: stp->subsip->si_ma = STSBUF;
441: #ifdef SUN3
442: if (stp->st_ha_type)
443: i = sidoit(&scdb, &sscb, stp->subsip );
444: else
445: #endif
446: i = scdoit(&scdb, &sscb, stp->subsip );
447: if (i != sense_length) {
448: if (errprint) {
449: printf("st: sense error\n");
450: }
451: stp->st_eof = 1;
452: return (0);
453: }
454: if (ISAEMULEX(stp)) {
455: ems = (struct st_emulex_sense *)STSBUF;
456: if ((ems->ext_sense.fil_mk == 0) && errprint) {
457: printf("st: error:\n");
458: printf("\tsense key is %x",
459: ems->ext_sense.key);
460: printf("\terror is %x\n",
461: ems->error);
462: }
463: stp->st_eof = 1;
464: return (r);
465: } else {
466: scs = (struct st_sysgen_sense *)STSBUF;
467: if ((scs->qic_sense.file_mark == 0) && errprint) {
468: #ifdef STBOOT
469: printf("st: error %x\n",
470: *(unsigned short *)&STSBUF[SENSELOC]);
471: #else STBOOT
472: printf("st: error %b\n",
473: *(unsigned short *)&STSBUF[SENSELOC],
474: SENSE_BITS);
475: #endif STBOOT
476: }
477: stp->st_eof = 1;
478: return (r);
479: }
480: }
481: if (r >= count) {
482: return (count ? count : 1);
483: } else {
484: if (errprint) {
485: printf("st: short transfer\n");
486: }
487: return (r);
488: }
489: }
490:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.