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