![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tmscp.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / sys / vaxuba|
Return to tmscp.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / sys / vaxuba |
1.1 root 1: /* @(#)tmscp.c 7.4 (Berkeley) 5/27/88 */
2:
3: #ifndef lint
4: static char *sccsid = "@(#)tmscp.c 1.24 (ULTRIX) 1/21/86";
5: #endif lint
6:
7:
8: /************************************************************************
9: * *
10: * Licensed from Digital Equipment Corporation *
11: * Copyright (c) *
12: * Digital Equipment Corporation *
13: * Maynard, Massachusetts *
14: * 1985, 1986 *
15: * All rights reserved. *
16: * *
17: * The Information in this software is subject to change *
18: * without notice and should not be construed as a commitment *
19: * by Digital Equipment Corporation. Digital makes no *
20: * representations about the suitability of this software for *
21: * any purpose. It is supplied "As Is" without expressed or *
22: * implied warranty. *
23: * *
24: * If the Regents of the University of California or its *
25: * licensees modify the software in a manner creating *
26: * diriviative copyright rights, appropriate copyright *
27: * legends may be placed on the drivative work in addition *
28: * to that set forth above. *
29: * *
30: ************************************************************************
31: *
32: * tmscp.c - TMSCP (TK50/TU81) tape device driver
33: *
34: * Modification History:
35: *
36: * 06-Jan-86 - afd
37: * Changed the probe routine to use DELAY (not TODR). This now
38: * works for MicroVAXen as well. This eliminates the busy-wait
39: * for MicroVAXen so a dead TK50 controller will not hang autoconf.
40: *
41: * 06-Dec-85 - afd
42: * Fixed a bug in density selection. The "set unit characteristics"
43: * command to select density, was clearing the "unit flags" field
44: * where the CACHE bit was for TU81-E. Now the unit's "format" and
45: * "unitflgs" are saved in tms_info struct. And are used on STUNT
46: * commands.
47: *
48: * 19-Oct-85 - afd
49: * Added support to the open routine to allow drives to be opened
50: * for low density (800 or 1600 bpi) use. When the slave routine
51: * initiates a "get-unit-char" cmd, the format menu for the unit
52: * is saved in the tms_info structure. The format menu is used in the
53: * start routine to select the proper low density.
54: *
55: * 02-Oct-85 - afd
56: * When a tmscp-type controller is initializing, it is possible for
57: * the sa reg to become 0 between states. Thus the init code in
58: * the interrupt routine had to be modified to reflect this.
59: *
60: * 21-Sep-85 - afd
61: * The TK50 declares a serious exception when a tape mark is encountered.
62: * This causes problems to dd (& other UN*X utilities). So a flag
63: * is set in the rsp() routine when a tape mark is encountered. If
64: * this flag is set, the start() routine appends the Clear Serious
65: * Exception modifier to the next command.
66: *
67: * 03-Sep-85 -- jaw
68: * messed up previous edit..
69: *
70: * 29-Aug-85 - jaw
71: * fixed bugs in 8200 and 750 buffered datapath handling.
72: *
73: * 06-Aug-85 - afd
74: * 1. When repositioning records or files, the count of items skipped
75: * does NOT HAVE to be returned by controllers (& the TU81 doesn't).
76: * So tmscprsp() had to be modified to stop reporting
77: * residual count errors on reposition commands.
78: *
79: * 2. Fixed bug in the open routine which allowed multiple opens.
80: *
81: * 18-Jul-85 - afd
82: * 1. Need to return status when mt status (or corresponding ioctl) is done.
83: * Save resid, flags, endcode & status in tmscprsp() routine (except on
84: * clear serious exception no-op). Return these fields when status
85: * ioctl is done (in tmscpcommand()). How they are returned:
86: * mt_resid = resid
87: * mt_dsreg = flags|endcode
88: * mt_erreg = status
89: *
90: * 2. Added latent support for enabling/disabling caching. This is
91: * handled along with all other ioctl commands.
92: *
93: * 3. Need to issue a no-op on unrecognized ioctl in tmscpstart(), since
94: * we have already commited to issuing a command at that point.
95: *
96: * 4. In tmscprsp() routine if encode is 0200 (invalid command issued);
97: * We need to: Unlink the buffer from the I/O wait queue,
98: * and signal iodone, so the higher level command can exit!
99: * Just as if it were a valid command.
100: *
101: * 11-jul-85 -- jaw
102: * fix bua/bda map registers.
103: *
104: * 19-Jun-85 -- jaw
105: * VAX8200 name change.
106: *
107: * 06-Jun-85 - jaw
108: * fixes for 8200.
109: *
110: * 9-Apr-85 - afd
111: * Added timeout code to the probe routine, so if the controller
112: * fails to init in 10 seconds we return failed status.
113: *
114: * 13-Mar-85 -jaw
115: * Changes for support of the VAX8200 were merged in.
116: *
117: * 27-Feb-85 -tresvik
118: * Changes for support of the VAX8600 were merged in.
119: *
120: */
121:
122: #include "tms.h"
123: #if NTMSCP > 0
124:
125: #include "param.h"
126: #include "systm.h"
127: #include "buf.h"
128: #include "conf.h"
129: #include "dir.h"
130: #include "user.h"
131: #include "file.h"
132: #include "map.h"
133: #include "vm.h"
134: #include "ioctl.h"
135: #include "syslog.h"
136: #include "mtio.h"
137: #include "cmap.h"
138: #include "uio.h"
139: #include "tty.h"
140:
141: #include "../vax/pte.h"
142: #include "../vax/cpu.h"
143: #include "../vax/mtpr.h"
144: #include "ubareg.h"
145: #include "ubavar.h"
146:
147: #define TENSEC (1000)
148: #define TMS_PRI LOG_INFO
149:
150: #define NRSPL2 3 /* log2 number of response packets */
151: #define NCMDL2 3 /* log2 number of command packets */
152: #define NRSP (1<<NRSPL2)
153: #define NCMD (1<<NCMDL2)
154:
155: #include "tmscpreg.h"
156: #include "../vax/tmscp.h"
157:
158: /* Software state per controller */
159:
160: struct tmscp_softc {
161: short sc_state; /* state of controller */
162: short sc_mapped; /* Unibus map allocated for tmscp struct? */
163: int sc_ubainfo; /* Unibus mapping info */
164: struct tmscp *sc_tmscp; /* Unibus address of tmscp struct */
165: int sc_ivec; /* interrupt vector address */
166: short sc_credits; /* transfer credits */
167: short sc_lastcmd; /* pointer into command ring */
168: short sc_lastrsp; /* pointer into response ring */
169: } tmscp_softc[NTMSCP];
170:
171: struct tmscp {
172: struct tmscpca tmscp_ca; /* communications area */
173: struct mscp tmscp_rsp[NRSP]; /* response packets */
174: struct mscp tmscp_cmd[NCMD]; /* command packets */
175: } tmscp[NTMSCP];
176:
177: /*
178: * Per drive-unit info
179: */
180: struct tms_info {
181: daddr_t tms_dsize; /* Max user size from online pkt */
182: unsigned tms_type; /* Drive type int field */
183: int tms_resid; /* residual from last xfer */
184: u_char tms_endcode; /* last command endcode */
185: u_char tms_flags; /* last command end flags */
186: unsigned tms_status; /* Command status from last command */
187: char tms_openf; /* lock against multiple opens */
188: char tms_lastiow; /* last op was a write */
189: char tms_serex; /* set when serious exception occurs */
190: char tms_clserex; /* set when serex being cleared by no-op */
191: short tms_fmtmenu; /* the unit's format (density) menu */
192: short tms_unitflgs; /* unit flag parameters */
193: short tms_format; /* the unit's current format (density) */
194: struct tty *tms_ttyp; /* record user's tty for errors */
195: } tms_info[NTMS];
196: struct uba_ctlr *tmscpminfo[NTMSCP];
197: struct uba_device *tmsdinfo[NTMS];
198: /*
199: * ifdef other tmscp devices here if they allow more than 1 unit/controller
200: */
201: struct uba_device *tmscpip[NTMSCP][1];
202: struct buf ctmscpbuf[NTMSCP]; /* internal cmd buffer (for ioctls) */
203: struct buf tmsutab[NTMS]; /* Drive queue */
204: struct buf tmscpwtab[NTMSCP]; /* I/O wait queue, per controller */
205: int tmscpmicro[NTMSCP]; /* to store microcode level */
206: short utoctlr[NTMS]; /* Slave unit to controller mapping */
207: /* filled in by the slave routine */
208:
209: /* Bits in minor device */
210: #define TMSUNIT(dev) (minor(dev)&03)
211: #define T_NOREWIND 04
212: #define T_HIDENSITY 010
213:
214: /* Slave unit to controller mapping */
215: #define TMSCPCTLR(dev) (utoctlr[TMSUNIT(dev)])
216:
217: /*
218: * Internal (ioctl) command codes (these must also be declared in the
219: * tmscpioctl routine). These correspond to ioctls in mtio.h
220: */
221: #define TMS_WRITM 0 /* write tape mark */
222: #define TMS_FSF 1 /* forward space file */
223: #define TMS_BSF 2 /* backward space file */
224: #define TMS_FSR 3 /* forward space record */
225: #define TMS_BSR 4 /* backward space record */
226: #define TMS_REW 5 /* rewind tape */
227: #define TMS_OFFL 6 /* rewind tape & mark unit offline */
228: #define TMS_SENSE 7 /* noop - do a get unit status */
229: #define TMS_CACHE 8 /* enable cache */
230: #define TMS_NOCACHE 9 /* disable cache */
231: /* These go last: after all real mt cmds, just bump the numbers up */
232: #define TMS_CSE 10 /* clear serious exception */
233: #define TMS_LOWDENSITY 11 /* set unit to low density */
234: #define TMS_HIDENSITY 12 /* set unit to high density */
235:
236: /*
237: * Controller states
238: */
239: #define S_IDLE 0 /* hasn't been initialized */
240: #define S_STEP1 1 /* doing step 1 init */
241: #define S_STEP2 2 /* doing step 2 init */
242: #define S_STEP3 3 /* doing step 3 init */
243: #define S_SCHAR 4 /* doing "set controller characteristics" */
244: #define S_RUN 5 /* running */
245:
246: int tmscperror = 0; /* causes hex dump of packets */
247: int tmscp_cp_wait = 0; /* Something to wait on for command */
248: /* packets and or credits. */
249: int wakeup();
250: extern int hz; /* Should find the right include */
251:
252: #ifdef DEBUG
253: #define printd if (tmscpdebug) printf
254: int tmscpdebug = 1;
255: #define printd10 if(tmscpdebug >= 10) printf
256: #endif
257:
258: int tmscpprobe(), tmscpslave(), tmscpattach(), tmscpintr();
259: struct mscp *tmscpgetcp();
260:
261: #define DRVNAME "tms"
262: #define CTRLNAME "tmscp"
263:
264: u_short tmscpstd[] = { 0174500, 0 };
265: struct uba_driver tmscpdriver =
266: { tmscpprobe, tmscpslave, tmscpattach, 0, tmscpstd, DRVNAME, tmsdinfo, CTRLNAME
267: , tmscpminfo, 0};
268:
269: #define b_qsize b_resid /* queue size per drive, in tmsutab */
270: #define b_ubinfo b_resid /* Unibus mapping info, per buffer */
271:
272:
273: /*************************************************************************/
274:
275: #define DELAYTEN 1000
276:
277: tmscpprobe(reg, ctlr)
278: caddr_t reg; /* address of the IP register */
279: int ctlr; /* index of controller in the tmscp_softc array */
280: {
281: register int br, cvec; /* MUST be 1st (r11 & r10): IPL and intr vec */
282: register struct tmscp_softc *sc = &tmscp_softc[ctlr];
283: /* ptr to software controller structure */
284: struct tmscpdevice *tmscpaddr; /* ptr to tmscpdevice struct (IP & SA) */
285: int count; /* for probe delay time out */
286:
287: # ifdef lint
288: br = 0; cvec = br; br = cvec; reg = reg;
289: tmscpreset(0); tmscpintr(0);
290: # endif
291:
292: tmscpaddr = (struct tmscpdevice *) reg;
293: /*
294: * Set host-settable interrupt vector.
295: * Assign 0 to the ip register to start the tmscp-device initialization.
296: * The device is not really initialized at this point, this is just to
297: * find out if the device exists.
298: */
299: sc->sc_ivec = (uba_hd[numuba].uh_lastiv -= 4);
300: tmscpaddr->tmscpip = 0;
301:
302: count=0;
303: while(count < DELAYTEN)
304: { /* wait for at most 10 secs */
305: if((tmscpaddr->tmscpsa & TMSCP_STEP1) != 0)
306: break;
307: DELAY(10000);
308: count=count+1;
309: }
310: if (count == DELAYTEN)
311: return(0);
312:
313: tmscpaddr->tmscpsa = TMSCP_ERR|(NCMDL2<<11)|(NRSPL2<<8)|TMSCP_IE|(sc->sc_ivec/4);
314:
315: count=0;
316: while(count < DELAYTEN)
317: {
318: if((tmscpaddr->tmscpsa & TMSCP_STEP2) != 0)
319: break;
320: DELAY(10000);
321: count = count+1;
322: }
323: if (count == DELAYTEN)
324: return(0);
325:
326: #ifdef VAX630
327: if (cpu == VAX_630)
328: br = 0x15; /* screwy interrupt structure */
329: #endif
330: return(sizeof (struct tmscpdevice));
331: }
332:
333: /*
334: * Try to find a slave (a drive) on the controller.
335: * If the controller is not in the run state, call init to initialize it.
336: */
337: tmscpslave (ui, reg)
338: struct uba_device *ui; /* ptr to the uba device structure */
339: caddr_t reg; /* addr of the device controller */
340: {
341: register struct uba_ctlr *um = tmscpminfo[ui->ui_ctlr];
342: register struct tmscp_softc *sc = &tmscp_softc[ui->ui_ctlr];
343: register struct tms_info *tms = &tms_info[ui->ui_unit];
344: struct tmscpdevice *tmscpaddr; /* ptr to IP & SA */
345: struct mscp *mp;
346: int i; /* Something to write into to start */
347: /* the tmscp polling */
348:
349: # ifdef lint
350: reg = reg;
351: # endif
352: tmscpaddr = (struct tmscpdevice *)um->um_addr;
353: /*
354: * If its not in the run state, start the initialization process
355: * (tmscpintr will complete it); if the initialization doesn't start;
356: * then return.
357: */
358: if(sc->sc_state != S_RUN)
359: {
360: # ifdef DEBUG
361: printd("tmscpslave: ctlr not running: calling init \n");
362: # endif
363: if(!tmscpinit(ui->ui_ctlr))
364: return(0);
365: }
366: /*
367: * Wait for the controller to come into the run state or go idle.
368: * If it goes idle return.
369: */
370: # ifdef DEBUG
371: i=1;
372: # endif
373: while(sc->sc_state != S_RUN && sc->sc_state != S_IDLE)
374: # ifdef DEBUG
375: if (tmscpaddr->tmscpsa & TMSCP_ERR && i)
376: {
377: printd("tmscp-device: fatal error (%o)\n", tmscpaddr->tmscpsa&0xffff);
378: i=0;
379: }
380: # endif
381: ; /* wait */
382: if(sc->sc_state == S_IDLE)
383: { /* The tmscp device failed to initialize */
384: printf("tmscp controller failed to init\n");
385: return(0);
386: }
387: /* The controller is up so see if the drive is there */
388: if(0 == (mp = tmscpgetcp(um)))
389: {
390: printf("tmscp can't get command packet\n");
391: return(0);
392: }
393: /* Need to determine the drive type for generic driver */
394: mp->mscp_opcode = M_OP_GTUNT; /* This should give us the device type */
395: mp->mscp_unit = ui->ui_slave;
396: mp->mscp_cmdref = (long) ui->ui_slave;
397: tms->tms_status = 0; /* set to zero */
398: tmscpip[ui->ui_ctlr][ui->ui_slave] = ui;
399: *((long *) mp->mscp_dscptr ) |= TMSCP_OWN | TMSCP_INT;/* maybe we should poll*/
400: i = tmscpaddr->tmscpip;
401: #ifdef lint
402: i = i;
403: #endif
404: while(!tms->tms_status)
405: ; /* Wait for some status */
406: # ifdef DEBUG
407: printd("tmscpslave: status = %o\n",tms->tms_status & M_ST_MASK);
408: # endif
409: tmscpip[ui->ui_ctlr][ui->ui_slave] = 0;
410: if(!tms->tms_type) /* packet from a GTUNT */
411: return(0); /* Failed No such drive */
412: else
413: return(1); /* Got it and it is there */
414: }
415:
416:
417: /*
418: * Set ui flags to zero to show device is not online & set tmscpip.
419: * Unit to Controller mapping is set up here.
420: * Open routine will issue the online command, later.
421: */
422: tmscpattach (ui)
423: register struct uba_device *ui; /* ptr to unibus dev struct */
424: {
425:
426: ui->ui_flags = 0;
427: tmscpip[ui->ui_ctlr][ui->ui_slave] = ui;
428: # ifdef DEBUG
429: /*
430: * Check to see if the drive is available.
431: * If not then just print debug.
432: */
433: if(tms_info[ui->ui_unit].tms_status != M_ST_AVLBL)
434: printd("tmscpattach: unavailable \n");
435: # endif
436: utoctlr[ui->ui_unit] = ui->ui_ctlr;
437: }
438:
439:
440: /*
441: * TMSCP interrupt routine.
442: */
443: tmscpintr (d)
444: int d; /* index to the controller */
445: {
446: register struct uba_ctlr *um = tmscpminfo[d];
447: register struct tmscpdevice *tmscpaddr = (struct tmscpdevice *)um->um_addr;
448: struct buf *bp;
449: register int i;
450: register struct tmscp_softc *sc = &tmscp_softc[d];
451: register struct tmscp *tm = &tmscp[d];
452: struct tmscp *ttm;
453: struct mscp *mp;
454:
455: # ifdef DEBUG
456: printd10("tmscpintr: state %d, tmscpsa %o\n", sc->sc_state, tmscpaddr->tmscpsa);
457: # endif
458:
459: /*
460: * How the interrupt is handled depends on the state of the controller.
461: */
462: switch (sc->sc_state) {
463:
464: case S_IDLE:
465: printf("tmscp%d: random interrupt ignored\n", d);
466: return;
467:
468: /* Controller was in step 1 last, see if its gone to step 2 */
469: case S_STEP1:
470: # define STEP1MASK 0174377
471: # define STEP1GOOD (TMSCP_STEP2|TMSCP_IE|(NCMDL2<<3)|NRSPL2)
472: for (i = 0; i < 150; i++)
473: {
474: if ((tmscpaddr->tmscpsa&STEP1MASK) != STEP1GOOD)
475: { /* still in step 1 (wait 1/100 sec) */
476: DELAY(10000);
477: # ifdef DEBUG
478: printd("still in step 1, delaying\n");
479: # endif DEBUG
480: }
481: else
482: break;
483: }
484: if (i > 149)
485: {
486: sc->sc_state = S_IDLE;
487: printf("failed to initialize, in step1: sa 0x%x", tmscpaddr->tmscpsa);
488: wakeup((caddr_t)um);
489: return;
490: }
491: tmscpaddr->tmscpsa = ((int)&sc->sc_tmscp->tmscp_ca.ca_ringbase)
492: | ((cpu == VAX_780 || cpu == VAX_8600) ? TMSCP_PI : 0);
493: sc->sc_state = S_STEP2;
494: return;
495:
496: /* Controller was in step 2 last, see if its gone to step 3 */
497: case S_STEP2:
498: # define STEP2MASK 0174377
499: # define STEP2GOOD (TMSCP_STEP3|TMSCP_IE|(sc->sc_ivec/4))
500: for (i = 0; i < 150; i++)
501: {
502: if ((tmscpaddr->tmscpsa&STEP2MASK) != STEP2GOOD)
503: { /* still in step 2 (wait 1/100 sec) */
504: DELAY(10000);
505: # ifdef DEBUG
506: printd("still in step 2, delaying\n");
507: # endif DEBUG
508: }
509: else
510: break;
511: }
512: if (i > 149)
513: {
514: sc->sc_state = S_IDLE;
515: printf("failed to initialize, in step2: sa 0x%x", tmscpaddr->tmscpsa);
516: wakeup((caddr_t)um);
517: return;
518: }
519: tmscpaddr->tmscpsa = ((int)&sc->sc_tmscp->tmscp_ca.ca_ringbase)>>16;
520: sc->sc_state = S_STEP3;
521: return;
522:
523: /* Controller was in step 3 last, see if its gone to step 4 */
524: case S_STEP3:
525: # define STEP3MASK 0174000
526: # define STEP3GOOD TMSCP_STEP4
527: for (i = 0; i < 150; i++)
528: {
529: if ((tmscpaddr->tmscpsa&STEP3MASK) != STEP3GOOD)
530: { /* still in step 3 (wait 1/100 sec) */
531: DELAY(10000);
532: # ifdef DEBUG
533: printd("still in step 3, delaying\n");
534: # endif DEBUG
535: }
536: else
537: break;
538: }
539: if (i > 149)
540: {
541: sc->sc_state = S_IDLE;
542: printf("failed to initialize, in step3: sa 0x%x", tmscpaddr->tmscpsa);
543: wakeup((caddr_t)um);
544: return;
545: }
546: /*
547: * Get microcode version and model number of controller;
548: * Signal initialization complete (_GO) (to the controller);
549: * ask for Last Fail response if tmscperror is set;
550: * Set state to "set controller characteristics".
551: */
552: tmscpmicro[d] = tmscpaddr->tmscpsa;
553: tmscpaddr->tmscpsa = TMSCP_GO | (tmscperror? TMSCP_LF : 0);
554: sc->sc_state = S_SCHAR;
555: # ifdef DEBUG
556: printd("tmscpintr: completed state %d \n", sc->sc_state);
557: printd("tmscp%d Version %d model %d\n",d,tmscpmicro[d]&0xF,
558: (tmscpmicro[d]>>4) & 0xF);
559: # endif
560:
561: /*
562: * Initialize the data structures (response and command queues).
563: */
564: ttm = sc->sc_tmscp;
565: for (i = 0; i < NRSP; i++)
566: {
567: tm->tmscp_ca.ca_rspdsc[i] = TMSCP_OWN | TMSCP_INT |
568: (long)&ttm->tmscp_rsp[i].mscp_cmdref;
569: tm->tmscp_rsp[i].mscp_dscptr = &tm->tmscp_ca.ca_rspdsc[i];
570: tm->tmscp_rsp[i].mscp_header.tmscp_msglen = mscp_msglen;
571: }
572: for (i = 0; i < NCMD; i++)
573: {
574: tm->tmscp_ca.ca_cmddsc[i] = TMSCP_INT |
575: (long)&ttm->tmscp_cmd[i].mscp_cmdref;
576: tm->tmscp_cmd[i].mscp_dscptr = &tm->tmscp_ca.ca_cmddsc[i];
577: tm->tmscp_cmd[i].mscp_header.tmscp_msglen = mscp_msglen;
578: tm->tmscp_cmd[i].mscp_header.tmscp_vcid = 1;
579: }
580: bp = &tmscpwtab[d];
581: bp->av_forw = bp->av_back = bp;
582: sc->sc_lastcmd = 1;
583: sc->sc_lastrsp = 0;
584: mp = &tmscp[um->um_ctlr].tmscp_cmd[0];
585: mp->mscp_unit = mp->mscp_modifier = 0;
586: mp->mscp_flags = 0;
587: mp->mscp_version = 0;
588: mp->mscp_cntflgs = M_CF_ATTN|M_CF_MISC|M_CF_THIS;
589: /*
590: * A host time out value of 0 means that the controller will not
591: * time out. This is ok for the TK50.
592: */
593: mp->mscp_hsttmo = 0;
594: mp->mscp_time.val[0] = 0;
595: mp->mscp_time.val[1] = 0;
596: mp->mscp_cntdep = 0;
597: mp->mscp_opcode = M_OP_STCON;
598: *((long *)mp->mscp_dscptr) |= TMSCP_OWN|TMSCP_INT;
599: i = tmscpaddr->tmscpip; /* initiate polling */
600: return;
601:
602: case S_SCHAR:
603: case S_RUN:
604: break;
605:
606: default:
607: printf("tmscp%d: interrupt in unknown state %d ignored\n",d,sc->sc_state);
608: return;
609: } /* end switch */
610:
611: /*
612: * The controller state is S_SCHAR or S_RUN
613: */
614:
615: /*
616: * If the error bit is set in the SA register then print an error
617: * message and reinitialize the controller.
618: */
619: if (tmscpaddr->tmscpsa&TMSCP_ERR)
620: {
621: printf("tmscp%d: fatal error (%o)\n", d, tmscpaddr->tmscpsa&0xffff);
622: tmscpaddr->tmscpip = 0;
623: wakeup((caddr_t)um);
624: }
625: /*
626: * Check for a buffer purge request. (Won't happen w/ TK50 on Q22 bus)
627: */
628: if (tm->tmscp_ca.ca_bdp)
629: {
630: UBAPURGE(um->um_hd->uh_uba, tm->tmscp_ca.ca_bdp);
631: tm->tmscp_ca.ca_bdp = 0;
632: tmscpaddr->tmscpsa = 0; /* signal purge complete */
633: }
634:
635: /*
636: * Check for response ring transition.
637: */
638: if (tm->tmscp_ca.ca_rspint)
639: {
640: tm->tmscp_ca.ca_rspint = 0;
641: for (i = sc->sc_lastrsp;; i++)
642: {
643: i %= NRSP;
644: if (tm->tmscp_ca.ca_rspdsc[i]&TMSCP_OWN)
645: break;
646: tmscprsp(um, tm, sc, i);
647: tm->tmscp_ca.ca_rspdsc[i] |= TMSCP_OWN;
648: }
649: sc->sc_lastrsp = i;
650: }
651:
652: /*
653: * Check for command ring transition.
654: */
655: if (tm->tmscp_ca.ca_cmdint)
656: {
657: # ifdef DEBUG
658: printd("tmscpintr: command ring transition\n");
659: # endif
660: tm->tmscp_ca.ca_cmdint = 0;
661: }
662: if(tmscp_cp_wait)
663: wakeup((caddr_t)&tmscp_cp_wait);
664: (void) tmscpstart(um);
665: }
666:
667:
668: /*
669: * Open a tmscp device and set the unit online. If the controller is not
670: * in the run state, call init to initialize the tmscp controller first.
671: */
672:
673: /* ARGSUSED */
674: tmscpopen(dev, flag)
675: dev_t dev;
676: int flag;
677: {
678: register int unit;
679: register struct uba_device *ui;
680: register struct tmscp_softc *sc;
681: register struct tms_info *tms;
682: register struct mscp *mp;
683: register struct uba_ctlr *um;
684: struct tmscpdevice *tmscpaddr;
685: int s,i;
686:
687: unit = TMSUNIT(dev);
688: # ifdef DEBUG
689: printd("tmscpopen unit %d\n",unit);
690: if(tmscpdebug)DELAY(10000);
691: # endif
692: if (unit >= NTMS || (ui = tmsdinfo[unit]) == 0 || ui->ui_alive == 0)
693: return (ENXIO);
694: tms = &tms_info[ui->ui_unit];
695: if (tms->tms_openf)
696: return (EBUSY);
697: sc = &tmscp_softc[ui->ui_ctlr];
698: tms->tms_openf = 1;
699: tms->tms_ttyp = u.u_ttyp;
700: s = spl5();
701: if (sc->sc_state != S_RUN)
702: {
703: if (sc->sc_state == S_IDLE)
704: if(!tmscpinit(ui->ui_ctlr))
705: {
706: printf("tmscp controller failed to init\n");
707: (void) splx(s);
708: tms->tms_openf = 0;
709: return(ENXIO);
710: }
711: /*
712: * Wait for initialization to complete
713: */
714: timeout(wakeup,(caddr_t)ui->ui_mi,11*hz); /* to be sure*/
715: sleep((caddr_t)ui->ui_mi, 0);
716: if (sc->sc_state != S_RUN)
717: {
718: (void) splx(s);
719: tms->tms_openf = 0;
720: return (EIO);
721: }
722: }
723: /*
724: * Check to see if the device is really there.
725: * this code was taken from Fred Canters 11 driver
726: */
727: um = ui->ui_mi;
728: tmscpaddr = (struct tmscpdevice *) um->um_addr;
729: (void) splx(s);
730: if(ui->ui_flags == 0)
731: {
732: s = spl5();
733: while(0 ==(mp = tmscpgetcp(um)))
734: {
735: tmscp_cp_wait++;
736: sleep((caddr_t)&tmscp_cp_wait,PSWP+1);
737: tmscp_cp_wait--;
738: }
739: (void) splx(s);
740: mp->mscp_opcode = M_OP_ONLIN;
741: mp->mscp_unit = ui->ui_slave;
742: mp->mscp_cmdref = (long) & tms->tms_type;
743: /* need to sleep on something */
744: # ifdef DEBUG
745: printd("tmscpopen: bring unit %d online\n",ui->ui_unit);
746: # endif
747: *((long *) mp->mscp_dscptr ) |= TMSCP_OWN | TMSCP_INT;
748: i = tmscpaddr->tmscpip;
749: #ifdef lint
750: i = i;
751: #endif
752: /*
753: * To make sure we wake up, timeout in 240 seconds.
754: * Wakeup in tmscprsp routine.
755: * 240 seconds (4 minutes) is necessary since a rewind
756: * can take a few minutes.
757: */
758: timeout(wakeup,(caddr_t) mp->mscp_cmdref,240 * hz);
759: sleep((caddr_t) mp->mscp_cmdref,PSWP+1);
760: }
761: if(ui->ui_flags == 0) {
762: tms->tms_openf = 0;
763: return(ENXIO); /* Didn't go online */
764: }
765: tms->tms_lastiow = 0;
766: /*
767: * If the high density device is not specified, set unit to low
768: * density. This is done as an "internal" ioctl command so
769: * that the command setup and response handling
770: * is done thru "regular" command routines.
771: */
772: if ((minor(dev) & T_HIDENSITY) == 0)
773: tmscpcommand(dev, TMS_LOWDENSITY, 1);
774: else
775: tmscpcommand(dev, TMS_HIDENSITY, 1);
776: return (0);
777: }
778:
779:
780: /*
781: * Close tape device.
782: *
783: * If tape was open for writing or last operation was
784: * a write, then write two EOF's and backspace over the last one.
785: * Unless this is a non-rewinding special file, rewind the tape.
786: *
787: * NOTE:
788: * We want to be sure that any serious exception is cleared on the
789: * close. A Clear Serious Exception (CSE) modifier is always done on
790: * the rewind command. For the non-rewind case we check to see if the
791: * "serex" field is set in the softc struct; if it is then issue a noop
792: * command with the CSE modifier.
793: * Make the tape available to others, by clearing openf flag.
794: */
795: tmscpclose(dev, flag)
796: register dev_t dev;
797: register flag;
798: {
799: register struct tms_info *tms;
800: register struct uba_device *ui;
801:
802: ui = tmsdinfo[TMSUNIT(dev)];
803: # ifdef DEBUG
804: printd("tmscpclose: ctlr = %d\n",TMSCPCTLR(dev));
805: printd("tmscpclose: unit = %d\n",TMSUNIT(dev));
806: if(tmscpdebug)DELAY(10000);
807: # endif
808: tms = &tms_info[ui->ui_unit];
809: if (flag == FWRITE || (flag&FWRITE) && tms->tms_lastiow)
810: {
811: /* device, command, count */
812: tmscpcommand (dev, TMS_WRITM, 1);
813: tmscpcommand (dev, TMS_WRITM, 1);
814: tmscpcommand (dev, TMS_BSR, 1);
815: }
816: if ((minor(dev)&T_NOREWIND) == 0)
817: /*
818: * Don't hang waiting for rewind complete.
819: */
820: tmscpcommand(dev, TMS_REW, 0);
821: else
822: if (tms->tms_serex)
823: {
824: # ifdef DEBUG
825: printd("tmscpclose: clearing serex\n");
826: if(tmscpdebug)DELAY(10000);
827: # endif
828: tmscpcommand(dev, TMS_CSE, 1);
829: }
830: tms->tms_openf = 0;
831: }
832:
833:
834: /*
835: * Execute a command on the tape drive a specified number of times.
836: * This routine sets up a buffer and calls the strategy routine which
837: * links the buffer onto the drive's buffer queue.
838: * The start routine will take care of creating a tmscp command packet
839: * with the command. The start routine is called by the strategy or the
840: * interrupt routine.
841: */
842:
843: tmscpcommand (dev, com, count)
844: register dev_t dev;
845: int com, count;
846: {
847: register struct uba_device *ui;
848: register struct buf *bp;
849: register int s;
850: int unit = TMSUNIT(dev);
851:
852: ui = tmsdinfo[unit];
853: bp = &ctmscpbuf[ui->ui_ctlr];
854:
855: s = spl5();
856: while (bp->b_flags&B_BUSY)
857: {
858: /*
859: * This special check is because B_BUSY never
860: * gets cleared in the non-waiting rewind case.
861: */
862: if (bp->b_bcount == 0 && (bp->b_flags&B_DONE))
863: break;
864: bp->b_flags |= B_WANTED;
865: sleep((caddr_t)bp, PRIBIO);
866: }
867: bp->b_flags = B_BUSY|B_READ;
868: splx(s);
869: /*
870: * Load the buffer. The b_count field gets used to hold the command
871: * count. the b_resid field gets used to hold the command mneumonic.
872: * These 2 fields are "known" to be "safe" to use for this purpose.
873: * (Most other drivers also use these fields in this way.)
874: */
875: bp->b_dev = dev;
876: bp->b_bcount = count;
877: bp->b_resid = com;
878: bp->b_blkno = 0;
879: tmscpstrategy(bp);
880: /*
881: * In case of rewind from close, don't wait.
882: * This is the only case where count can be 0.
883: */
884: if (count == 0)
885: return;
886: iowait(bp);
887: if (bp->b_flags&B_WANTED)
888: wakeup((caddr_t)bp);
889: bp->b_flags &= B_ERROR;
890: }
891:
892: /*
893: * Find an unused command packet
894: */
895: struct mscp *
896: tmscpgetcp(um)
897: struct uba_ctlr *um;
898: {
899: register struct mscp *mp;
900: register struct tmscpca *cp;
901: register struct tmscp_softc *sc;
902: register int i;
903: int s;
904:
905: s = spl5();
906: cp = &tmscp[um->um_ctlr].tmscp_ca;
907: sc = &tmscp_softc[um->um_ctlr];
908: /*
909: * If no credits, can't issue any commands
910: * until some outstanding commands complete.
911: */
912: i = sc->sc_lastcmd;
913: # ifdef DEBUG
914: printd10("tmscpgetcp: %d credits remain\n", sc->sc_credits);
915: # endif
916: if(((cp->ca_cmddsc[i]&(TMSCP_OWN|TMSCP_INT))==TMSCP_INT) &&
917: (sc->sc_credits >= 2))
918: {
919: sc->sc_credits--; /* This commits to issuing a command */
920: cp->ca_cmddsc[i] &= ~TMSCP_INT;
921: mp = &tmscp[um->um_ctlr].tmscp_cmd[i];
922: mp->mscp_unit = mp->mscp_modifier = 0;
923: mp->mscp_opcode = mp->mscp_flags = 0;
924: mp->mscp_bytecnt = mp->mscp_buffer = 0;
925: sc->sc_lastcmd = (i + 1) % NCMD;
926: (void) splx(s);
927: return(mp);
928: }
929: (void) splx(s);
930: return(NULL);
931: }
932:
933:
934: /*
935: * Initialize a TMSCP device. Set up UBA mapping registers,
936: * initialize data structures, and start hardware
937: * initialization sequence.
938: */
939: tmscpinit (d)
940: int d; /* index to the controller */
941: {
942: register struct tmscp_softc *sc;
943: register struct tmscp *t; /* communications area; cmd & resp packets */
944: struct tmscpdevice *tmscpaddr;
945: struct uba_ctlr *um;
946:
947: sc = &tmscp_softc[d];
948: um = tmscpminfo[d];
949: um->um_tab.b_active++;
950: t = &tmscp[d];
951: tmscpaddr = (struct tmscpdevice *)um->um_addr;
952: if (sc->sc_mapped == 0)
953: {
954: /*
955: * Map the communications area and command
956: * and response packets into Unibus address
957: * space.
958: */
959: sc->sc_ubainfo = uballoc(um->um_ubanum, (caddr_t)t, sizeof (struct tmscp), 0);
960: # ifdef MVAX
961: if (cpu == MVAX_I)
962: sc->sc_tmscp = (struct tmscp *)(sc->sc_ubainfo & 0x3fffff);
963: else
964: # endif MVAX
965: sc->sc_tmscp = (struct tmscp *)(sc->sc_ubainfo & 0x3ffff);
966: sc->sc_mapped = 1;
967: }
968:
969: /*
970: * Start the hardware initialization sequence.
971: */
972: tmscpaddr->tmscpip = 0; /* start initialization */
973:
974: while((tmscpaddr->tmscpsa & TMSCP_STEP1) == 0)
975: {
976: # ifdef DEBUG
977: printd("tmscpinit: tmscpsa = 0%o\n",tmscpaddr->tmscpsa);
978: DELAY(100000);
979: # endif
980: if(tmscpaddr->tmscpsa & TMSCP_ERR)
981: return(0); /* CHECK */
982: }
983: tmscpaddr->tmscpsa=TMSCP_ERR|(NCMDL2<<11)|(NRSPL2<<8)|TMSCP_IE|(sc->sc_ivec/4);
984: /*
985: * Initialization continues in the interrupt routine.
986: */
987: sc->sc_state = S_STEP1;
988: sc->sc_credits = 0;
989: return(1);
990: }
991:
992:
993: /*
994: * Start I/O operation
995: * This code is convoluted. The majority of it was copied from the uda driver.
996: */
997:
998: tmscpstart(um)
999: register struct uba_ctlr *um;
1000: {
1001: register struct buf *bp, *dp;
1002: register struct mscp *mp;
1003: register struct tmscp_softc *sc;
1004: register struct tms_info *tms;
1005: register struct uba_device *ui;
1006: struct tmscpdevice *tmscpaddr;
1007: struct tmscp *tm = &tmscp[um->um_ctlr];
1008: int i,tempi;
1009: char ioctl; /* flag: set true if its an IOCTL command */
1010:
1011: sc = &tmscp_softc[um->um_ctlr];
1012:
1013: for(;;)
1014: {
1015: if ((dp = um->um_tab.b_actf) == NULL)
1016: {
1017: /*
1018: * Release unneeded UBA resources and return
1019: * (drive was inactive)
1020: */
1021: um->um_tab.b_active = 0;
1022: break;
1023: }
1024: if ((bp = dp->b_actf) == NULL)
1025: {
1026: /*
1027: * No more requests for this drive, remove
1028: * from controller queue and look at next drive.
1029: * We know we're at the head of the controller queue.
1030: */
1031: dp->b_active = 0;
1032: um->um_tab.b_actf = dp->b_forw;
1033: continue; /* Need to check for loop */
1034: }
1035: um->um_tab.b_active++;
1036: tmscpaddr = (struct tmscpdevice *)um->um_addr;
1037: ui = tmsdinfo[(TMSUNIT(bp->b_dev))];
1038: tms = &tms_info[ui->ui_unit];
1039: if ((tmscpaddr->tmscpsa&TMSCP_ERR) || sc->sc_state != S_RUN)
1040: {
1041: tprintf(tms->tms_ttyp,
1042: "tms%d: hard error bn%d\n",
1043: minor(bp->b_dev)&03, bp->b_blkno);
1044: log(TMS_PRI, "tmscp%d: sa 0%o, state %d\n",um->um_ctlr,
1045: tmscpaddr->tmscpsa&0xffff, sc->sc_state);
1046: (void)tmscpinit(um->um_ctlr);
1047: /* SHOULD REQUEUE OUTSTANDING REQUESTS, LIKE TMSCPRESET */
1048: break;
1049: }
1050: /*
1051: * Default is that last command was NOT a write command;
1052: * if a write command is done it will be detected in tmscprsp.
1053: */
1054: tms->tms_lastiow = 0;
1055: if (ui->ui_flags == 0)
1056: { /* not online */
1057: if ((mp = tmscpgetcp(um)) == NULL)
1058: break;
1059: mp->mscp_opcode = M_OP_ONLIN;
1060: mp->mscp_unit = ui->ui_slave;
1061: dp->b_active = 2;
1062: um->um_tab.b_actf = dp->b_forw; /* remove from controller q */
1063: *((long *)mp->mscp_dscptr) |= TMSCP_OWN|TMSCP_INT;
1064: if (tmscpaddr->tmscpsa&TMSCP_ERR)
1065: printf("tmscp%d fatal error (0%o)\n",um->um_ctlr,
1066: tmscpaddr->tmscpsa&0xffff);
1067: i = tmscpaddr->tmscpip;
1068: continue;
1069: }
1070: switch (cpu) {
1071:
1072: case VAX_8600:
1073: case VAX_780:
1074: i = UBA_NEEDBDP|UBA_CANTWAIT;
1075: break;
1076: case VAX_750:
1077: i = um->um_ubinfo|UBA_HAVEBDP|UBA_CANTWAIT;
1078: break;
1079: case VAX_730:
1080: i = UBA_CANTWAIT;
1081: break;
1082: } /* end switch (cpu) */
1083: /*
1084: * If command is an ioctl command then set the ioctl flag for later use.
1085: * If not (i.e. it is a read or write) then attempt
1086: * to set up a buffer pointer.
1087: */
1088: ioctl = 0;
1089: if (bp == &ctmscpbuf[um->um_ctlr])
1090: ioctl = 1;
1091: else
1092: if ((i = ubasetup(um->um_ubanum, bp, i)) == 0)
1093: {
1094: if(dp->b_qsize != 0)
1095: break; /* When a command completes and */
1096: /* frees a bdp tmscpstart will be called */
1097: if ((mp = tmscpgetcp(um)) == NULL)
1098: break;
1099: # ifdef DEBUG
1100: printd("tmscpstart: GTUNT %d ubasetup = %d\n",ui->ui_unit, i);
1101: if(tmscpdebug)DELAY(10000);
1102: # endif
1103: mp->mscp_opcode = M_OP_GTUNT;
1104: mp->mscp_unit = ui->ui_slave;
1105: *((long *)mp->mscp_dscptr) |= TMSCP_OWN|TMSCP_INT;
1106: if (tmscpaddr->tmscpsa&TMSCP_ERR)
1107: printf("tmscp%d: fatal error (0%o)\n",um->um_ctlr,
1108: tmscpaddr->tmscpsa&0xffff);
1109: i = tmscpaddr->tmscpip; /* initiate polling */
1110: break;
1111: }
1112: # if defined(VAX750)
1113: if (cpu == VAX_750)
1114: tempi = i & 0xfffffff; /* mask off bdp */
1115: else
1116: # endif
1117: tempi = i;
1118: if ((mp = tmscpgetcp(um)) == NULL)
1119: {
1120: if (!ioctl) /* only need to release if NOT ioctl */
1121: ubarelse(um->um_ubanum,&tempi);
1122: break;
1123: }
1124: mp->mscp_cmdref = (long)bp; /* pointer to get back */
1125: mp->mscp_unit = ui->ui_slave;
1126: /*
1127: * If its an ioctl-type command then set up the appropriate
1128: * tmscp command; by doing a switch on the "b_resid" field where
1129: * the command mneumonic is stored.
1130: */
1131: if (ioctl)
1132: {
1133: # ifdef DEBUG
1134: printd("tmscpstart: doing ioctl cmd %d\n", bp->b_resid);
1135: # endif
1136: /*
1137: * The reccnt and tmkcnt fields are set to zero by the getcp
1138: * routine (as bytecnt and buffer fields). Thus reccnt and
1139: * tmkcnt are only modified here if they need to be set to
1140: * a non-zero value.
1141: */
1142: switch ((int)bp->b_resid) {
1143:
1144: case TMS_WRITM:
1145: mp->mscp_opcode = M_OP_WRITM;
1146: break;
1147: case TMS_FSF:
1148: mp->mscp_opcode = M_OP_REPOS;
1149: mp->mscp_tmkcnt = bp->b_bcount;
1150: break;
1151: case TMS_BSF:
1152: mp->mscp_opcode = M_OP_REPOS;
1153: mp->mscp_modifier = M_MD_REVRS;
1154: mp->mscp_tmkcnt = bp->b_bcount;
1155: break;
1156: case TMS_FSR:
1157: mp->mscp_opcode = M_OP_REPOS;
1158: mp->mscp_modifier = M_MD_OBJCT;
1159: mp->mscp_reccnt = bp->b_bcount;
1160: break;
1161: case TMS_BSR:
1162: mp->mscp_opcode = M_OP_REPOS;
1163: mp->mscp_modifier = M_MD_REVRS | M_MD_OBJCT;
1164: mp->mscp_reccnt = bp->b_bcount;
1165: break;
1166: /*
1167: * Clear serious exception is done for Rewind & Available cmds
1168: */
1169: case TMS_REW:
1170: mp->mscp_opcode = M_OP_REPOS;
1171: mp->mscp_modifier = M_MD_REWND | M_MD_CLSEX;
1172: if (bp->b_bcount == 0)
1173: mp->mscp_modifier |= M_MD_IMMED;
1174: tms->tms_serex = 0;
1175: break;
1176: case TMS_OFFL:
1177: mp->mscp_opcode = M_OP_AVAIL;
1178: mp->mscp_modifier = M_MD_UNLOD | M_MD_CLSEX;
1179: tms->tms_serex = 0;
1180: break;
1181: case TMS_SENSE:
1182: mp->mscp_opcode = M_OP_GTUNT;
1183: break;
1184: case TMS_CACHE:
1185: mp->mscp_opcode = M_OP_STUNT;
1186: tms->tms_unitflgs |= M_UF_WBKNV;
1187: mp->mscp_unitflgs = tms->tms_unitflgs;
1188: mp->mscp_format = tms->tms_format;
1189: /* default device dependant parameters */
1190: mp->mscp_mediaid = 0;
1191: break;
1192: case TMS_NOCACHE:
1193: mp->mscp_opcode = M_OP_STUNT;
1194: tms->tms_unitflgs &= ~(M_UF_WBKNV);
1195: mp->mscp_unitflgs = tms->tms_unitflgs;
1196: mp->mscp_format = tms->tms_format;
1197: /* default device dependant parameters */
1198: mp->mscp_mediaid = 0;
1199: break;
1200: case TMS_CSE:
1201: /*
1202: * This is a no-op command. It performs a
1203: * clear serious exception only. (Done on a
1204: * non-rewinding close after a serious exception.)
1205: */
1206: mp->mscp_opcode = M_OP_REPOS;
1207: mp->mscp_modifier = M_MD_CLSEX;
1208: tms->tms_serex = 0;
1209: tms->tms_clserex = 1;
1210: break;
1211: case TMS_LOWDENSITY:
1212: /*
1213: * Set the unit to low density
1214: */
1215: mp->mscp_opcode = M_OP_STUNT;
1216: mp->mscp_unitflgs = tms->tms_unitflgs;
1217: mp->mscp_mediaid = 0; /* default device dependant parameters */
1218: if ((tms->tms_fmtmenu & M_TF_800) != 0)
1219: mp->mscp_format = M_TF_800;
1220: else
1221: mp->mscp_format = M_TF_PE & tms->tms_fmtmenu;
1222: tms->tms_format = mp->mscp_format;
1223: break;
1224: case TMS_HIDENSITY:
1225: /*
1226: * Set the unit to high density (format == 0)
1227: */
1228: mp->mscp_opcode = M_OP_STUNT;
1229: mp->mscp_unitflgs = tms->tms_unitflgs;
1230: mp->mscp_mediaid = 0; /* default device dependant parameters */
1231: mp->mscp_format = 0;
1232: tms->tms_format = 0;
1233: break;
1234: default:
1235: printf("Bad ioctl on tms unit %d\n", ui->ui_unit);
1236: /* Need a no-op. Reposition no amount */
1237: mp->mscp_opcode = M_OP_REPOS;
1238: break;
1239: } /* end switch (bp->b_resid) */
1240: }
1241: else /* Its a read/write command (not an ioctl) */
1242: {
1243: mp->mscp_opcode = bp->b_flags&B_READ ? M_OP_READ : M_OP_WRITE;
1244: mp->mscp_bytecnt = bp->b_bcount;
1245: # if MVAX
1246: if (cpu == MVAX_I)
1247: {
1248: mp->mscp_buffer = (i & 0x3ffff) | TMSCP_MAP;
1249: mp->mscp_mapbase = (long)&(uba_hd[um->um_ubanum].uh_physuba->uba_map[0]);
1250: }
1251: else
1252: # endif MVAX
1253: mp->mscp_buffer = (i & 0x3ffff) | (((i>>28)&0xf)<<24);
1254:
1255: bp->b_ubinfo = tempi; /* save mapping info */
1256: }
1257: if (tms->tms_serex == 2) /* if tape mark read */
1258: {
1259: mp->mscp_modifier |= M_MD_CLSEX; /* clear serious exc */
1260: tms->tms_serex = 0;
1261: }
1262: *((long *)mp->mscp_dscptr) |= TMSCP_OWN|TMSCP_INT;
1263: # ifdef DEBUG
1264: printd("tmscpstart: opcode 0%o mod %o unit %d cnt %d\n",mp->mscp_opcode,mp->mscp_modifier,mp->mscp_unit,mp->mscp_bytecnt);
1265: if(tmscpdebug)DELAY(100000);
1266: # endif
1267: i = tmscpaddr->tmscpip; /* initiate polling */
1268: dp->b_qsize++;
1269: /*
1270: * Move drive to the end of the controller queue
1271: */
1272: if (dp->b_forw != NULL)
1273: {
1274: um->um_tab.b_actf = dp->b_forw;
1275: um->um_tab.b_actl->b_forw = dp;
1276: um->um_tab.b_actl = dp;
1277: dp->b_forw = NULL;
1278: }
1279: /*
1280: * Move buffer to I/O wait queue
1281: */
1282: dp->b_actf = bp->av_forw;
1283: dp = &tmscpwtab[um->um_ctlr];
1284: bp->av_forw = dp;
1285: bp->av_back = dp->av_back;
1286: dp->av_back->av_forw = bp;
1287: dp->av_back = bp;
1288: if (tmscpaddr->tmscpsa&TMSCP_ERR)
1289: {
1290: printf("tmscp%d: fatal error (0%o)\n", um->um_ctlr, tmscpaddr->tmscpsa&0xffff);
1291: (void)tmscpinit(um->um_ctlr);
1292: break;
1293: }
1294: } /* end for */
1295: /*
1296: * Check for response ring transitions lost in the
1297: * Race condition
1298: */
1299: for (i = sc->sc_lastrsp;; i++)
1300: {
1301: i %= NRSP;
1302: if (tm->tmscp_ca.ca_rspdsc[i]&TMSCP_OWN)
1303: break;
1304: tmscprsp(um, tm, sc, i);
1305: tm->tmscp_ca.ca_rspdsc[i] |= TMSCP_OWN;
1306: }
1307: sc->sc_lastrsp = i;
1308: }
1309:
1310:
1311: /*
1312: * Process a response packet
1313: */
1314: tmscprsp(um, tm, sc, i)
1315: register struct uba_ctlr *um;
1316: register struct tmscp *tm;
1317: register struct tmscp_softc *sc;
1318: int i;
1319: {
1320: register struct mscp *mp;
1321: register struct tms_info *tms;
1322: struct uba_device *ui;
1323: struct buf *dp, *bp;
1324: int st;
1325:
1326: mp = &tm->tmscp_rsp[i];
1327: mp->mscp_header.tmscp_msglen = mscp_msglen;
1328: sc->sc_credits += mp->mscp_header.tmscp_credits & 0xf; /* low 4 bits */
1329: if ((mp->mscp_header.tmscp_credits & 0xf0) > 0x10) /* Check */
1330: return;
1331: # ifdef DEBUG
1332: printd("tmscprsp, opcode 0%o status 0%o\n",mp->mscp_opcode,mp->mscp_status&M_ST_MASK);
1333: # endif
1334: /*
1335: * If it's an error log message (datagram),
1336: * pass it on for more extensive processing.
1337: */
1338: if ((mp->mscp_header.tmscp_credits & 0xf0) == 0x10)
1339: { /* check */
1340: tmserror(um, (struct mslg *)mp);
1341: return;
1342: }
1343: st = mp->mscp_status&M_ST_MASK;
1344: /*
1345: * The controller interrupts as drive 0.
1346: * This means that you must check for controller interrupts
1347: * before you check to see if there is a drive 0.
1348: */
1349: if((M_OP_STCON|M_OP_END) == mp->mscp_opcode)
1350: {
1351: if (st == M_ST_SUCC)
1352: {
1353: # ifdef DEBUG
1354: printd("ctlr has %d credits\n", mp->mscp_header.tmscp_credits & 0xf);
1355: printd("ctlr timeout = %d\n", mp->mscp_cnttmo);
1356: # endif
1357: sc->sc_state = S_RUN;
1358: }
1359: else
1360: sc->sc_state = S_IDLE;
1361: um->um_tab.b_active = 0;
1362: wakeup((caddr_t)um);
1363: return;
1364: }
1365: if (mp->mscp_unit >= NTMS)
1366: return;
1367: if ((ui = tmscpip[um->um_ctlr][mp->mscp_unit]) == 0)
1368: return;
1369: tms = &tms_info[ui->ui_unit];
1370: /*
1371: * Save endcode, endflags, and status for mtioctl get unit status.
1372: * NOTE: Don't do this on Clear serious exception (reposition no-op);
1373: * which is done on close since this would
1374: * overwrite the real status we want.
1375: */
1376: if (tms->tms_clserex != 1)
1377: {
1378: tms->tms_endcode = mp->mscp_opcode;
1379: tms->tms_flags = mp->mscp_flags;
1380: tms->tms_status = st;
1381: }
1382: else tms->tms_clserex = 0;
1383:
1384: switch (mp->mscp_opcode) {
1385: case M_OP_ONLIN|M_OP_END:
1386: tms->tms_type = mp->mscp_mediaid;
1387: dp = &tmsutab[ui->ui_unit];
1388: if (st == M_ST_SUCC)
1389: {
1390: /*
1391: * Link the drive onto the controller queue
1392: */
1393: dp->b_forw = NULL;
1394: if (um->um_tab.b_actf == NULL)
1395: um->um_tab.b_actf = dp;
1396: else
1397: um->um_tab.b_actl->b_forw = dp;
1398: um->um_tab.b_actl = dp;
1399: ui->ui_flags = 1; /* mark it online */
1400: tms->tms_dsize=(daddr_t)mp->mscp_maxwrt;
1401: # ifdef DEBUG
1402: printd("tmscprsp: unit %d online\n", mp->mscp_unit);
1403: # endif
1404: /*
1405: * This define decodes the Media type identifier
1406: */
1407: # define F_to_C(x,i) ( ((x)->mscp_mediaid) >> (i*5+7) & 0x1f ? ( ( (((x)->mscp_mediaid) >>( i*5 + 7)) & 0x1f) + 'A' - 1): ' ')
1408: # ifdef DEBUG
1409: printd("tmscprsp: unit %d online %x %c%c %c%c%c%d\n"
1410: ,mp->mscp_unit, mp->mscp_mediaid ,F_to_C(mp,4)
1411: ,F_to_C(mp,3), F_to_C(mp,2)
1412: ,F_to_C(mp,1), F_to_C(mp,0), mp->mscp_mediaid & 0x7f);
1413: # endif
1414: dp->b_active = 1;
1415: } /* end if st == M_ST_SUCC */
1416: else
1417: {
1418: if (bp = dp->b_actf)
1419: tprintf(tms->tms_ttyp,
1420: "tms%d: hard error bn%d: OFFLINE\n",
1421: minor(bp->b_dev)&03, bp->b_blkno);
1422: else
1423: tprintf(tms->tms_ttyp,
1424: "tms%d: hard error: OFFLINE\n",
1425: ui->ui_unit);
1426: while (bp = dp->b_actf)
1427: {
1428: dp->b_actf = bp->av_forw;
1429: bp->b_flags |= B_ERROR;
1430: iodone(bp);
1431: }
1432: }
1433: if(mp->mscp_cmdref!=NULL)
1434: /* Seems to get lost sometimes in uda */
1435: wakeup((caddr_t)mp->mscp_cmdref);
1436: break;
1437: /*
1438: * The AVAILABLE ATTENTION message occurs when the
1439: * unit becomes available after loading,
1440: * marking the unit offline (ui_flags = 0) will force an
1441: * online command prior to using the unit.
1442: */
1443: case M_OP_AVATN:
1444: ui->ui_flags = 0;
1445: tms->tms_type = mp->mscp_mediaid;
1446: break;
1447: case M_OP_END:
1448: /*
1449: * An endcode without an opcode (0200) is an invalid command.
1450: * The mscp specification states that this would be a protocol
1451: * type error, such as illegal opcodes. The mscp spec. also
1452: * states that parameter error type of invalid commands should
1453: * return the normal end message for the command. This does not appear
1454: * to be the case. An invalid logical block number returned an endcode
1455: * of 0200 instead of the 0241 (read) that was expected.
1456: */
1457:
1458: printf("tmscp%d: invalid cmd, endcode = %o, status=%o\n",
1459: um->um_ctlr, mp->mscp_opcode, st);
1460: bp = (struct buf *)mp->mscp_cmdref;
1461: /*
1462: * Unlink buffer from I/O wait queue.
1463: * And signal iodone, so the higher level command can exit!
1464: *
1465: */
1466: bp->av_back->av_forw = bp->av_forw;
1467: bp->av_forw->av_back = bp->av_back;
1468: dp = &tmsutab[ui->ui_unit];
1469: dp->b_qsize--;
1470: iodone(bp);
1471: break;
1472: case M_OP_WRITE|M_OP_END:
1473: /* mark the last io op as a write */
1474: tms->tms_lastiow = 1;
1475: case M_OP_READ|M_OP_END:
1476: case M_OP_WRITM|M_OP_END:
1477: case M_OP_REPOS|M_OP_END:
1478: case M_OP_STUNT|M_OP_END:
1479: /*
1480: * The AVAILABLE message occurs when the mt ioctl "rewoffl" is
1481: * issued. For the ioctl, "rewoffl", a tmscp AVAILABLE command is
1482: * done with the UNLOAD modifier. This performs a rewind, followed
1483: * by marking the unit offline. So mark the unit offline
1484: * software wise as well (ui_flags = 0 and
1485: * tms->tms_openf = 0).
1486: */
1487: case M_OP_AVAIL|M_OP_END:
1488: # ifdef DEBUG
1489: printd("tmscprsp: position = %d\n", mp->mscp_lbn);
1490: # endif
1491: bp = (struct buf *)mp->mscp_cmdref;
1492: /*
1493: * Only need to release buffer if the command was read or write.
1494: * No ubasetup was done in "tmscpstart" if it was an ioctl cmd.
1495: */
1496: if (mp->mscp_opcode == (M_OP_READ|M_OP_END) ||
1497: mp->mscp_opcode == (M_OP_WRITE|M_OP_END))
1498: ubarelse(um->um_ubanum, (int *)&bp->b_ubinfo);
1499: /*
1500: * Unlink buffer from I/O wait queue.
1501: */
1502: bp->av_back->av_forw = bp->av_forw;
1503: bp->av_forw->av_back = bp->av_back;
1504: # if defined(VAX750)
1505: if (cpu == VAX_750) {
1506: if ((tmscpwtab[um->um_ctlr].av_forw == &tmscpwtab[um->um_ctlr]) &&
1507: (um->um_ubinfo != 0)) {
1508: ubarelse(um->um_ubanum, &um->um_ubinfo);
1509: }
1510: else {
1511: if (mp->mscp_opcode == (M_OP_READ|M_OP_END) ||
1512: mp->mscp_opcode == (M_OP_WRITE|M_OP_END))
1513: UBAPURGE(uba_hd[um->um_ubanum].uh_uba,(um->um_ubinfo >>28) & 0x0f);
1514: }
1515: }
1516: # endif
1517: dp = &tmsutab[ui->ui_unit];
1518: dp->b_qsize--;
1519: if (st == M_ST_OFFLN || st == M_ST_AVLBL)
1520: {
1521: ui->ui_flags = 0; /* mark unit offline */
1522: tms->tms_openf = 0;
1523: tms->tms_type = mp->mscp_mediaid;
1524: /*
1525: * Link the buffer onto the front of the drive queue
1526: */
1527: if ((bp->av_forw = dp->b_actf) == 0)
1528: dp->b_actl = bp;
1529: dp->b_actf = bp;
1530: /*
1531: * Link the drive onto the controller queue
1532: */
1533: if (dp->b_active == 0)
1534: {
1535: dp->b_forw = NULL;
1536: if (um->um_tab.b_actf == NULL)
1537: um->um_tab.b_actf = dp;
1538: else
1539: um->um_tab.b_actl->b_forw = dp;
1540: um->um_tab.b_actl = dp;
1541: dp->b_active = 1;
1542: }
1543: # if defined(VAX750)
1544: if (cpu == VAX_750 && um->um_ubinfo == 0)
1545: um->um_ubinfo = uballoc(um->um_ubanum, (caddr_t)0, 0, UBA_NEEDBDP);
1546: # endif
1547: return;
1548: }
1549: if (st != M_ST_SUCC)
1550: {
1551: if (mp->mscp_flags & M_EF_SEREX)
1552: tms->tms_serex = 1;
1553: if (st != M_ST_TAPEM)
1554: {
1555: tprintf(tms->tms_ttyp,
1556: "tms%d: hard error bn%d\n",
1557: minor(bp->b_dev)&03, bp->b_blkno);
1558: errinfo(st); /* produces more info */
1559: # ifdef DEBUG
1560: printd("tmscprsp: error; status sub-code = 0%o, flags = 0%o\n",
1561: (mp->mscp_status & 177740)>>5, mp->mscp_flags);
1562: # endif
1563: bp->b_flags |= B_ERROR;
1564: }
1565: else
1566: /* Hit a tape mark - Set serex flag to
1567: * a special value so we can clear the
1568: * serious exception on the next command.
1569: */
1570: tms->tms_serex = 2;
1571: }
1572: /*
1573: * The tmscp spec states that controllers do not have to
1574: * report the number of records or files skipped. So on
1575: * reposition commands we go strictly by cmd status.
1576: */
1577: if (mp->mscp_opcode != (M_OP_REPOS|M_OP_END))
1578: bp->b_resid = bp->b_bcount - mp->mscp_bytecnt;
1579: else
1580: bp->b_resid = 0;
1581: tms->tms_resid = bp->b_resid;
1582: iodone(bp);
1583: break;
1584:
1585: case M_OP_GTUNT|M_OP_END:
1586: # ifdef DEBUG
1587: printd("tmscprsp: GTUNT end packet status = 0%o\n",st);
1588: printd("tmscprsp: unit %d mediaid %x %c%c %c%c%c%d %x %x t=%d\n"
1589: ,mp->mscp_unit, mp->mscp_mediaid
1590: ,F_to_C(mp,4),F_to_C(mp,3),F_to_C(mp,2)
1591: ,F_to_C(mp,1),F_to_C(mp,0)
1592: ,mp->mscp_mediaid & 0x7f
1593: ,mp->mscp_unitid.val[0]
1594: ,mp->mscp_unitid.val[1]
1595: ,mp->mscp_format);
1596: # endif
1597: tms->tms_type = mp->mscp_mediaid;
1598: tms->tms_fmtmenu = mp->mscp_fmtmenu;
1599: tms->tms_unitflgs = mp->mscp_unitflgs;
1600: break;
1601:
1602: default:
1603: printf("tmscp unknown packet\n");
1604: tmserror(um, (struct mslg *)mp);
1605: } /* end switch mp->mscp_opcode */
1606: }
1607:
1608:
1609: /*
1610: * Give a meaningful error when the mscp_status field returns an error code.
1611: */
1612:
1613: errinfo(st)
1614: int st; /* the status code */
1615: {
1616: switch(st) {
1617: case M_ST_ICMD:
1618: printf("invalid command\n");
1619: break;
1620: case M_ST_ABRTD:
1621: printf("command aborted\n");
1622: break;
1623: case M_ST_OFFLN:
1624: printf("unit offline\n");
1625: break;
1626: case M_ST_WRTPR:
1627: printf("unit write protected\n");
1628: break;
1629: case M_ST_COMP:
1630: printf("compare error\n");
1631: break;
1632: case M_ST_DATA:
1633: printf("data error\n");
1634: break;
1635: case M_ST_HSTBF:
1636: printf("host buffer access error\n");
1637: break;
1638: case M_ST_CNTLR:
1639: printf("controller error\n");
1640: break;
1641: case M_ST_DRIVE:
1642: printf("drive error\n");
1643: break;
1644: case M_ST_FMTER:
1645: printf("formatter error\n");
1646: break;
1647: case M_ST_BOT:
1648: printf("BOT encountered\n");
1649: break;
1650: case M_ST_TAPEM:
1651: printf("tape mark encountered\n");
1652: break;
1653: case M_ST_RDTRN:
1654: printf("record data truncated\n");
1655: break;
1656: case M_ST_PLOST:
1657: printf("position lost\n");
1658: break;
1659: case M_ST_SEX:
1660: printf("serious exception\n");
1661: break;
1662: case M_ST_LED:
1663: printf("LEOT detected\n");
1664: break;
1665: }
1666: }
1667:
1668:
1669: /*
1670: * Manage buffers and perform block mode read and write operations.
1671: */
1672:
1673: tmscpstrategy (bp)
1674: register struct buf *bp;
1675: {
1676: register struct uba_device *ui;
1677: register struct uba_ctlr *um;
1678: register struct buf *dp;
1679: register int unit = TMSUNIT(bp->b_dev);
1680: int s;
1681:
1682: if (unit >= NTMS)
1683: {
1684: # ifdef DEBUG
1685: printd ("tmscpstrategy: bad unit # %d\n",unit);
1686: # endif
1687: bp->b_flags |= B_ERROR;
1688: iodone(bp);
1689: return;
1690: }
1691: ui = tmsdinfo[unit];
1692: um = ui->ui_mi;
1693: if (ui == 0 || ui->ui_alive == 0)
1694: {
1695: bp->b_flags |= B_ERROR;
1696: iodone(bp);
1697: return;
1698: }
1699: s = spl5();
1700: /*
1701: * Link the buffer onto the drive queue
1702: */
1703: dp = &tmsutab[ui->ui_unit];
1704: if (dp->b_actf == 0)
1705: dp->b_actf = bp;
1706: else
1707: dp->b_actl->av_forw = bp;
1708: dp->b_actl = bp;
1709: bp->av_forw = 0;
1710: /*
1711: * Link the drive onto the controller queue
1712: */
1713: if (dp->b_active == 0)
1714: {
1715: dp->b_forw = NULL;
1716: if (um->um_tab.b_actf == NULL)
1717: um->um_tab.b_actf = dp;
1718: else
1719: um->um_tab.b_actl->b_forw = dp;
1720: um->um_tab.b_actl = dp;
1721: dp->b_active = 1;
1722: }
1723: /*
1724: * If the controller is not active, start it.
1725: */
1726: if (um->um_tab.b_active == 0)
1727: {
1728: # if defined(VAX750)
1729: if (cpu == VAX_750
1730: && tmscpwtab[um->um_ctlr].av_forw == &tmscpwtab[um->um_ctlr])
1731: {
1732: if (um->um_ubinfo != 0)
1733: log(TMS_PRI, "tmscpstrategy: ubinfo 0x%x\n",
1734: um->um_ubinfo);
1735: else
1736: um->um_ubinfo = uballoc(um->um_ubanum, (caddr_t)0, 0, UBA_NEEDBDP);
1737: }
1738: # endif
1739: # ifdef DEBUG
1740: printd10("tmscpstrategy: Controller not active, starting it\n");
1741: # endif
1742: (void) tmscpstart(um);
1743: }
1744: splx(s);
1745: return;
1746: }
1747:
1748: #define DBSIZE 32
1749:
1750: #define ca_Rspdsc ca_rspdsc[0]
1751: #define ca_Cmddsc ca_rspdsc[1]
1752: #define tmscp_Rsp tmscp_rsp[0]
1753: #define tmscp_Cmd tmscp_cmd[0]
1754:
1755: struct tmscp tmscpd[NTMSCP];
1756:
1757: tmscpdump(dev)
1758: dev_t dev;
1759: {
1760: struct tmscpdevice *tmscpaddr;
1761: struct tmscp *tmscp_ubaddr;
1762: char *start;
1763: int num, blk, unit;
1764: register struct uba_regs *uba;
1765: register struct uba_device *ui;
1766: register struct tmscp *tmscpp;
1767: register struct pte *io;
1768: register int i;
1769:
1770: unit = minor(dev) & 03;
1771: if (unit >= NTMS)
1772: return (ENXIO);
1773: # define phys(cast, addr) ((cast)((int)addr & 0x7fffffff))
1774: ui = phys(struct uba_device *, tmsdinfo[unit]);
1775: if (ui->ui_alive == 0)
1776: return (ENXIO);
1777: uba = phys(struct uba_hd *, ui->ui_hd)->uh_physuba;
1778: ubainit(uba);
1779: tmscpaddr = (struct tmscpdevice *)ui->ui_physaddr;
1780: DELAY(2000000);
1781: tmscpp = phys(struct tmscp *, &tmscpd[ui->ui_ctlr]);
1782:
1783: num = btoc(sizeof(struct tmscp)) + 1;
1784: io = &uba->uba_map[NUBMREG-num];
1785: for(i = 0; i<num; i++)
1786: *(int *)io++ = UBAMR_MRV|(btop(tmscpp)+i);
1787: tmscp_ubaddr = (struct tmscp *)(((int)tmscpp & PGOFSET)|((NUBMREG-num)<<9));
1788:
1789: tmscpaddr->tmscpip = 0;
1790: while ((tmscpaddr->tmscpsa & TMSCP_STEP1) == 0)
1791: if(tmscpaddr->tmscpsa & TMSCP_ERR) return(EFAULT);
1792: tmscpaddr->tmscpsa = TMSCP_ERR;
1793: while ((tmscpaddr->tmscpsa & TMSCP_STEP2) == 0)
1794: if(tmscpaddr->tmscpsa & TMSCP_ERR) return(EFAULT);
1795: tmscpaddr->tmscpsa = (short)&tmscp_ubaddr->tmscp_ca.ca_ringbase;
1796: while ((tmscpaddr->tmscpsa & TMSCP_STEP3) == 0)
1797: if(tmscpaddr->tmscpsa & TMSCP_ERR) return(EFAULT);
1798: tmscpaddr->tmscpsa = (short)(((int)&tmscp_ubaddr->tmscp_ca.ca_ringbase) >> 16);
1799: while ((tmscpaddr->tmscpsa & TMSCP_STEP4) == 0)
1800: if(tmscpaddr->tmscpsa & TMSCP_ERR) return(EFAULT);
1801: tmscpaddr->tmscpsa = TMSCP_GO;
1802: tmscpp->tmscp_ca.ca_Rspdsc = (long)&tmscp_ubaddr->tmscp_Rsp.mscp_cmdref;
1803: tmscpp->tmscp_ca.ca_Cmddsc = (long)&tmscp_ubaddr->tmscp_Cmd.mscp_cmdref;
1804: tmscpp->tmscp_Cmd.mscp_header.tmscp_vcid = 1; /* for tape */
1805: tmscpp->tmscp_Cmd.mscp_cntflgs = 0;
1806: tmscpp->tmscp_Cmd.mscp_version = 0;
1807: if (tmscpcmd(M_OP_STCON, tmscpp, tmscpaddr) == 0) {
1808: return(EFAULT);
1809: }
1810: tmscpp->tmscp_Cmd.mscp_unit = ui->ui_slave;
1811: if (tmscpcmd(M_OP_ONLIN, tmscpp, tmscpaddr) == 0) {
1812: return(EFAULT);
1813: }
1814:
1815: num = maxfree;
1816: start = 0;
1817: while (num > 0)
1818: {
1819: blk = num > DBSIZE ? DBSIZE : num;
1820: io = uba->uba_map;
1821: for (i = 0; i < blk; i++)
1822: *(int *)io++ = (btop(start)+i) | UBAMR_MRV;
1823: *(int *)io = 0;
1824: tmscpp->tmscp_Cmd.mscp_lbn = btop(start);
1825: tmscpp->tmscp_Cmd.mscp_unit = ui->ui_slave;
1826: tmscpp->tmscp_Cmd.mscp_bytecnt = blk*NBPG;
1827: # ifdef MVAX
1828: if( cpu == MVAX_I )
1829: tmscpp->tmscp_Cmd.mscp_buffer = (long) start;
1830: else
1831: # endif MVAX
1832: tmscpp->tmscp_Cmd.mscp_buffer = 0;
1833: if (tmscpcmd(M_OP_WRITE, tmscpp, tmscpaddr) == 0)
1834: return(EIO);
1835: start += blk*NBPG;
1836: num -= blk;
1837: }
1838: return (0);
1839: }
1840:
1841:
1842: /*
1843: * Perform a standalone tmscp command. This routine is only used by tmscpdump.
1844: */
1845:
1846: tmscpcmd(op, tmscpp, tmscpaddr)
1847: int op;
1848: register struct tmscp *tmscpp;
1849: struct tmscpdevice *tmscpaddr;
1850: {
1851: int i;
1852:
1853:
1854: tmscpp->tmscp_Cmd.mscp_opcode = op;
1855: tmscpp->tmscp_Rsp.mscp_header.tmscp_msglen = mscp_msglen;
1856: tmscpp->tmscp_Cmd.mscp_header.tmscp_msglen = mscp_msglen;
1857: tmscpp->tmscp_ca.ca_Rspdsc |= TMSCP_OWN|TMSCP_INT;
1858: tmscpp->tmscp_ca.ca_Cmddsc |= TMSCP_OWN|TMSCP_INT;
1859: if (tmscpaddr->tmscpsa&TMSCP_ERR)
1860: printf("tmscp fatal error (0%o)\n", tmscpaddr->tmscpsa&0xffff);
1861: i = tmscpaddr->tmscpip;
1862: #ifdef lint
1863: i = i;
1864: #endif
1865: for (;;)
1866: {
1867: if (tmscpp->tmscp_ca.ca_cmdint)
1868: tmscpp->tmscp_ca.ca_cmdint = 0;
1869: if (tmscpp->tmscp_ca.ca_rspint)
1870: break;
1871: }
1872: tmscpp->tmscp_ca.ca_rspint = 0;
1873: if (tmscpp->tmscp_Rsp.mscp_opcode != (op|M_OP_END) ||
1874: (tmscpp->tmscp_Rsp.mscp_status&M_ST_MASK) != M_ST_SUCC)
1875: {
1876: printf("error: com %d opc 0x%x stat 0x%x\ndump ", op,
1877: tmscpp->tmscp_Rsp.mscp_opcode, tmscpp->tmscp_Rsp.mscp_status);
1878: return(0);
1879: }
1880: return(1);
1881: }
1882:
1883: /*
1884: * Catch ioctl commands, and call the "command" routine to do them.
1885: */
1886:
1887: /* ARGSUSED */
1888: tmscpioctl(dev, cmd, data, flag)
1889: dev_t dev;
1890: int cmd;
1891: caddr_t data;
1892: int flag;
1893: {
1894: register struct buf *bp = &ctmscpbuf[TMSCPCTLR(dev)];
1895: register callcount; /* number of times to call cmd routine */
1896: register struct uba_device *ui;
1897: register struct tms_info *tms;
1898: int fcount; /* number of files (or records) to space */
1899: register struct mtop *mtop; /* mag tape cmd op to perform */
1900: register struct mtget *mtget; /* mag tape struct to get info in */
1901:
1902: /* we depend of the values and order of the TMS ioctl codes here */
1903: static tmsops[] =
1904: {TMS_WRITM,TMS_FSF,TMS_BSF,TMS_FSR,TMS_BSR,TMS_REW,TMS_OFFL,TMS_SENSE,
1905: TMS_CACHE,TMS_NOCACHE};
1906:
1907: switch (cmd) {
1908: case MTIOCTOP: /* tape operation */
1909: mtop = (struct mtop *)data;
1910: switch (mtop->mt_op) {
1911:
1912: case MTWEOF:
1913: callcount = mtop->mt_count;
1914: fcount = 1;
1915: break;
1916: case MTFSF: case MTBSF:
1917: case MTFSR: case MTBSR:
1918: callcount = 1;
1919: fcount = mtop->mt_count;
1920: break;
1921: case MTREW: case MTOFFL: case MTNOP:
1922: case MTCACHE: case MTNOCACHE:
1923: callcount = 1;
1924: fcount = 1; /* wait for this rewind */
1925: break;
1926: default:
1927: return (ENXIO);
1928: } /* end switch mtop->mt_op */
1929:
1930: if (callcount <= 0 || fcount <= 0)
1931: return (EINVAL);
1932: while (--callcount >= 0)
1933: {
1934: tmscpcommand(dev, tmsops[mtop->mt_op], fcount);
1935: if ((mtop->mt_op == MTFSR || mtop->mt_op == MTBSR) &&
1936: bp->b_resid)
1937: return (EIO);
1938: if (bp->b_flags & B_ERROR) /* like hitting BOT */
1939: break;
1940: }
1941: return (geterror(bp));
1942:
1943: case MTIOCGET:
1944: /*
1945: * Return status info associated with the particular UNIT.
1946: */
1947: ui = tmsdinfo[TMSUNIT(dev)];
1948: tms = &tms_info[ui->ui_unit];
1949: mtget = (struct mtget *)data;
1950: mtget->mt_type = MT_ISTMSCP;
1951: mtget->mt_dsreg = tms->tms_flags << 8;
1952: mtget->mt_dsreg |= tms->tms_endcode;
1953: mtget->mt_erreg = tms->tms_status;
1954: mtget->mt_resid = tms->tms_resid;
1955: break;
1956:
1957: default:
1958: return (ENXIO);
1959: }
1960: return (0);
1961: }
1962:
1963:
1964: /*
1965: * Reset (for raw mode use only).
1966: */
1967:
1968: tmscpreset (uban)
1969: int uban;
1970: {
1971: register struct uba_ctlr *um;
1972: register struct uba_device *ui;
1973: register struct buf *bp, *dp;
1974: register int unit;
1975: struct buf *nbp;
1976: int d;
1977:
1978: for (d = 0; d < NTMSCP; d++)
1979: {
1980: if ((um = tmscpminfo[d]) == 0 || um->um_ubanum != uban ||
1981: um->um_alive == 0)
1982: continue;
1983: printf(" tmscp%d", d);
1984: um->um_tab.b_active = 0;
1985: um->um_tab.b_actf = um->um_tab.b_actl = 0;
1986: tmscp_softc[d].sc_state = S_IDLE;
1987: tmscp_softc[d].sc_mapped = 0;
1988: for (unit = 0; unit < NTMS; unit++)
1989: {
1990: if ((ui = tmsdinfo[unit]) == 0)
1991: continue;
1992: if (ui->ui_alive == 0 || ui->ui_mi != um)
1993: continue;
1994: tmsutab[unit].b_active = 0;
1995: tmsutab[unit].b_qsize = 0;
1996: }
1997: for (bp = tmscpwtab[d].av_forw; bp != &tmscpwtab[d]; bp = nbp)
1998: {
1999: nbp = bp->av_forw;
2000: bp->b_ubinfo = 0;
2001: /*
2002: * Link the buffer onto the drive queue
2003: */
2004: dp = &tmsutab[TMSUNIT(bp->b_dev)];
2005: if (dp->b_actf == 0)
2006: dp->b_actf = bp;
2007: else
2008: dp->b_actl->av_forw = bp;
2009: dp->b_actl = bp;
2010: bp->av_forw = 0;
2011: /*
2012: * Link the drive onto the controller queue
2013: */
2014: if (dp->b_active == 0)
2015: {
2016: dp->b_forw = NULL;
2017: if (um->um_tab.b_actf == NULL)
2018: um->um_tab.b_actf = dp;
2019: else
2020: um->um_tab.b_actl->b_forw = dp;
2021: um->um_tab.b_actl = dp;
2022: dp->b_active = 1;
2023: }
2024: }
2025: (void)tmscpinit(d);
2026: }
2027: }
2028:
2029:
2030: /*
2031: * Process an error log message
2032: *
2033: * Only minimal decoding is done, only "useful"
2034: * information is printed. Eventually should
2035: * send message to an error logger.
2036: */
2037:
2038: tmserror(um, mp)
2039: register struct uba_ctlr *um;
2040: register struct mslg *mp;
2041: {
2042: register i;
2043:
2044: # ifdef DEBUG
2045: printd("tmserror:\n");
2046: # endif
2047: if(!(mp->mslg_flags & (M_LF_SUCC | M_LF_CONT)))
2048: log(TMS_PRI, "tmscp%d: %s error, ", um->um_ctlr,
2049: mp->mslg_flags & ( M_LF_SUCC | M_LF_CONT ) ? "soft" : "hard");
2050:
2051: switch (mp->mslg_format) {
2052:
2053: case M_FM_CNTERR:
2054: log(TMS_PRI, "controller error, event 0%o\n", mp->mslg_event);
2055: break;
2056: case M_FM_BUSADDR:
2057: log(TMS_PRI, "host memory access error, event 0%o, addr 0%o\n",
2058: mp->mslg_event, mp->mslg_busaddr);
2059: break;
2060: case M_FM_TAPETRN:
2061: log(TMS_PRI, "tape transfer error, unit %d, grp 0x%x, event 0%o\n",
2062: mp->mslg_unit, mp->mslg_group, mp->mslg_event);
2063: break;
2064: case M_FM_STIERR:
2065: log(TMS_PRI, "STI error, unit %d, event 0%o\n",
2066: mp->mslg_unit, mp->mslg_event);
2067: #ifdef notdef
2068: /* too painful to do with log() */
2069: for(i = 0; i < 62;i++)
2070: mprintf("\t0x%x",mp->mslg_stiunsucc[i] & 0xff);
2071: mprintf("\n");
2072: #endif
2073: break;
2074: case M_FM_STIDEL:
2075: log(TMS_PRI, "STI Drive Error Log, unit %d, event 0%o\n",
2076: mp->mslg_unit, mp->mslg_event);
2077: break;
2078: case M_FM_STIFEL:
2079: log(TMS_PRI, "STI Formatter Error Log, unit %d, event 0%o\n",
2080: mp->mslg_unit, mp->mslg_event);
2081: break;
2082: default:
2083: log(TMS_PRI, "unknown error, unit %d, format 0%o, event 0%o\n",
2084: mp->mslg_unit, mp->mslg_format, mp->mslg_event);
2085: }
2086:
2087: if (tmscperror)
2088: {
2089: register long *p = (long *)mp;
2090:
2091: for (i = 0; i < mp->mslg_header.tmscp_msglen; i += sizeof(*p))
2092: printf("%x ", *p++);
2093: printf("\n");
2094: }
2095: }
2096: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.