ts.c revision 1.14
1/* $NetBSD: ts.c,v 1.14 2005/10/15 17:29:25 yamt Exp $ */ 2 3/*- 4 * Copyright (c) 1991 The Regents of the University of California. 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. Neither the name of the University nor the names of its contributors 16 * may be used to endorse or promote products derived from this software 17 * without specific prior written permission. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 22 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 29 * SUCH DAMAGE. 30 * 31 * @(#)tmscp.c 7.16 (Berkeley) 5/9/91 32 */ 33 34/* 35 * sccsid = "@(#)tmscp.c 1.24 (ULTRIX) 1/21/86"; 36 */ 37 38/************************************************************************ 39 * * 40 * Licensed from Digital Equipment Corporation * 41 * Copyright (c) * 42 * Digital Equipment Corporation * 43 * Maynard, Massachusetts * 44 * 1985, 1986 * 45 * All rights reserved. * 46 * * 47 * The Information in this software is subject to change * 48 * without notice and should not be construed as a commitment * 49 * by Digital Equipment Corporation. Digital makes no * 50 * representations about the suitability of this software for * 51 * any purpose. It is supplied "As Is" without expressed or * 52 * implied warranty. * 53 * * 54 * If the Regents of the University of California or its * 55 * licensees modify the software in a manner creating * 56 * derivative copyright rights, appropriate copyright * 57 * legends may be placed on the derivative work in addition * 58 * to that set forth above. * 59 * * 60 ************************************************************************/ 61 62/* 63 * TSV05/TS05 device driver, written by Bertram Barth. 64 * 65 * should be TS11 compatible (untested) 66 */ 67 68#include <sys/cdefs.h> 69__KERNEL_RCSID(0, "$NetBSD: ts.c,v 1.14 2005/10/15 17:29:25 yamt Exp $"); 70 71#undef TSDEBUG 72 73/* 74 * TODO: 75 * 76 * Keep track of tape position so that lseek et al works. 77 * Use tprintf to inform the user, not the system console. 78 */ 79 80 81#include <sys/param.h> 82#include <sys/systm.h> 83#include <sys/kernel.h> 84#include <sys/buf.h> 85#include <sys/bufq.h> 86#include <sys/conf.h> 87#include <sys/errno.h> 88#include <sys/file.h> 89#include <sys/syslog.h> 90#include <sys/ioctl.h> 91#include <sys/mtio.h> 92#include <sys/uio.h> 93#include <sys/proc.h> 94 95#include <machine/bus.h> 96 97#include <dev/qbus/ubareg.h> 98#include <dev/qbus/ubavar.h> 99 100#include <dev/qbus/tsreg.h> 101 102#include "ioconf.h" 103 104struct ts { 105 struct cmd cmd; /* command packet */ 106 struct chr chr; /* characteristics packet */ 107 struct status status; /* status packet */ 108}; 109 110/* 111 * Software status, per controller. 112 * also status per tape-unit, since only one unit per controller 113 * (thus we have no struct ts_info) 114 */ 115struct ts_softc { 116 struct device sc_dev; /* Autoconf ... */ 117 struct uba_unit sc_unit; /* Struct common for UBA to talk */ 118 struct evcnt sc_intrcnt; /* Interrupt counting */ 119 struct ubinfo sc_ui; /* mapping info for struct ts */ 120 struct uba_unit sc_uu; /* Struct for UBA to communicate */ 121 bus_space_tag_t sc_iot; 122 bus_addr_t sc_ioh; 123 bus_dma_tag_t sc_dmat; 124 bus_dmamap_t sc_dmam; 125 volatile struct ts *sc_vts; /* Memory address of ts struct */ 126 struct ts *sc_bts; /* Unibus address of ts struct */ 127 int sc_type; /* TS11 or TS05? */ 128 short sc_waddr; /* Value to write to TSDB */ 129 struct bufq_state *sc_bufq; /* pending I/O requests */ 130 131 short sc_mapped; /* Unibus map allocated ? */ 132 short sc_state; /* see below: ST_xxx */ 133 short sc_rtc; /* retry count for lcmd */ 134 short sc_openf; /* lock against multiple opens */ 135 short sc_liowf; /* last operation was write */ 136 struct buf ts_cbuf; /* internal cmd buffer (for ioctls) */ 137}; 138 139#define XNAME sc->sc_dev.dv_xname 140 141#define TS_WCSR(csr, val) \ 142 bus_space_write_2(sc->sc_iot, sc->sc_ioh, csr, val) 143#define TS_RCSR(csr) \ 144 bus_space_read_2(sc->sc_iot, sc->sc_ioh, csr) 145 146#define LOWORD(x) ((int)(x) & 0xffff) 147#define HIWORD(x) (((int)(x) >> 16) & 0x3f) 148 149#define TYPE_TS11 0 150#define TYPE_TS05 1 151#define TYPE_TU80 2 152 153#define TS_INVALID 0 154#define TS_INIT 1 155#define TS_RUNNING 2 156#define TS_FASTREPOS 3 157 158static void tsintr(void *); 159static void tsinit(struct ts_softc *); 160static void tscommand(struct ts_softc *, dev_t, int, int); 161static int tsstart(struct ts_softc *, int); 162static void tswchar(struct ts_softc *); 163static int tsreset(struct ts_softc *); 164static int tsmatch(struct device *, struct cfdata *, void *); 165static void tsattach(struct device *, struct device *, void *); 166static int tsready(struct uba_unit *); 167 168CFATTACH_DECL(ts, sizeof(struct ts_softc), 169 tsmatch, tsattach, NULL, NULL); 170 171dev_type_open(tsopen); 172dev_type_close(tsclose); 173dev_type_read(tsread); 174dev_type_write(tswrite); 175dev_type_ioctl(tsioctl); 176dev_type_strategy(tsstrategy); 177dev_type_dump(tsdump); 178 179const struct bdevsw ts_bdevsw = { 180 tsopen, tsclose, tsstrategy, tsioctl, tsdump, nosize, D_TAPE 181}; 182 183const struct cdevsw ts_cdevsw = { 184 tsopen, tsclose, tsread, tswrite, tsioctl, 185 nostop, notty, nopoll, nommap, nokqfilter, D_TAPE 186}; 187 188/* Bits in minor device */ 189#define TS_UNIT(dev) (minor(dev)&03) 190#define TS_HIDENSITY 010 191 192#define TS_PRI LOG_INFO 193 194 195/* 196 * Probe for device. If found, try to raise an interrupt. 197 */ 198int 199tsmatch(struct device *parent, struct cfdata *match, void *aux) 200{ 201 struct ts_softc ssc; 202 struct ts_softc *sc = &ssc; 203 struct uba_attach_args *ua = aux; 204 int i; 205 206 sc->sc_iot = ua->ua_iot; 207 sc->sc_ioh = ua->ua_ioh; 208 sc->sc_mapped = 0; 209 sc->sc_dev.dv_parent = parent; 210 strcpy(XNAME, "ts"); 211 212 /* Try to reset the device */ 213 for (i = 0; i < 3; i++) 214 if (tsreset(sc) == 1) 215 break; 216 217 if (i == 3) 218 return 0; 219 220 tsinit(sc); 221 tswchar(sc); /* write charact. to enable interrupts */ 222 /* completion of this will raise the intr. */ 223 224 DELAY(1000000); /* Wait for interrupt */ 225 ubmemfree((void *)parent, &sc->sc_ui); 226 return 1; 227} 228 229/* 230 */ 231void 232tsattach(struct device *parent, struct device *self, void *aux) 233{ 234 struct uba_softc *uh = (void *)parent; 235 struct ts_softc *sc = (void *)self; 236 struct uba_attach_args *ua = aux; 237 int error; 238 char *t; 239 240 sc->sc_iot = ua->ua_iot; 241 sc->sc_ioh = ua->ua_ioh; 242 sc->sc_dmat = ua->ua_dmat; 243 244 sc->sc_uu.uu_softc = sc; 245 sc->sc_uu.uu_ready = tsready; 246 247 tsinit(sc); /* reset and map */ 248 249 if ((error = bus_dmamap_create(sc->sc_dmat, (64*1024), 16, (64*1024), 250 0, BUS_DMA_NOWAIT, &sc->sc_dmam))) 251 return printf(": failed create DMA map %d\n", error); 252 253 bufq_alloc(&sc->sc_bufq, "fcfs", 0); 254 255 /* 256 * write the characteristics (again) 257 */ 258 sc->sc_state = TS_INIT; /* tsintr() checks this ... */ 259 tswchar(sc); 260 if (tsleep(sc, PRIBIO, "tsattach", 100)) 261 return printf(": failed SET CHARACTERISTICS\n"); 262 263 sc->sc_state = TS_RUNNING; 264 if (uh->uh_type == UBA_UBA) { 265 if (sc->sc_vts->status.xst2 & TS_SF_TU80) { 266 sc->sc_type = TYPE_TU80; 267 t = "TU80"; 268 } else { 269 sc->sc_type = TYPE_TS11; 270 t = "TS11"; 271 } 272 } else { 273 sc->sc_type = TYPE_TS05; 274 t = "TS05"; 275 } 276 277 printf("\n%s: %s\n", XNAME, t); 278 printf("%s: rev %d, extended features %s, transport %s\n", 279 XNAME, (sc->sc_vts->status.xst2 & TS_SF_MCRL) >> 2, 280 (sc->sc_vts->status.xst2 & TS_SF_EFES ? "enabled" : "disabled"), 281 (TS_RCSR(TSSR) & TS_OFL ? "offline" : "online")); 282 283 uba_intr_establish(ua->ua_icookie, ua->ua_cvec, tsintr, 284 sc, &sc->sc_intrcnt); 285 evcnt_attach_dynamic(&sc->sc_intrcnt, EVCNT_TYPE_INTR, ua->ua_evcnt, 286 sc->sc_dev.dv_xname, "intr"); 287} 288 289/* 290 * Initialize a TS device. Set up UBA mapping registers, 291 * initialize data structures, what else ??? 292 */ 293void 294tsinit(struct ts_softc *sc) 295{ 296 if (sc->sc_mapped == 0) { 297 298 /* 299 * Map the communications area and command and message 300 * buffer into Unibus address space. 301 */ 302 sc->sc_ui.ui_size = sizeof(struct ts); 303 if ((ubmemalloc((void *)sc->sc_dev.dv_parent, 304 &sc->sc_ui, UBA_CANTWAIT))) 305 return; 306 sc->sc_vts = (void *)sc->sc_ui.ui_vaddr; 307 sc->sc_bts = (void *)sc->sc_ui.ui_baddr; 308 sc->sc_waddr = sc->sc_ui.ui_baddr | 309 ((sc->sc_ui.ui_baddr >> 16) & 3); 310 sc->sc_mapped = 1; 311 } 312 tsreset(sc); 313} 314 315/* 316 * Execute a (ioctl) command on the tape drive a specified number of times. 317 * This routine sets up a buffer and calls the strategy routine which 318 * issues the command to the controller. 319 */ 320void 321tscommand(struct ts_softc *sc, dev_t dev, int cmd, int count) 322{ 323 struct buf *bp; 324 int s; 325 326#ifdef TSDEBUG 327 printf("tscommand (%x, %d)\n", cmd, count); 328#endif 329 330 bp = &sc->ts_cbuf; 331 332 s = splbio(); 333 while (bp->b_flags & B_BUSY) { 334 /* 335 * This special check is because B_BUSY never 336 * gets cleared in the non-waiting rewind case. ??? 337 */ 338 if (bp->b_bcount == 0 && (bp->b_flags & B_DONE)) 339 break; 340 bp->b_flags |= B_WANTED; 341 (void) tsleep(bp, PRIBIO, "tscmd", 0); 342 /* check MOT-flag !!! */ 343 } 344 bp->b_flags = B_BUSY | B_READ; 345 splx(s); 346 347 /* 348 * Load the buffer. The b_count field gets used to hold the command 349 * count. the b_resid field gets used to hold the command mneumonic. 350 * These 2 fields are "known" to be "safe" to use for this purpose. 351 * (Most other drivers also use these fields in this way.) 352 */ 353 bp->b_dev = dev; 354 bp->b_bcount = count; 355 bp->b_resid = cmd; 356 bp->b_blkno = 0; 357 tsstrategy(bp); 358 /* 359 * In case of rewind from close, don't wait. 360 * This is the only case where count can be 0. 361 */ 362 if (count == 0) 363 return; 364 biowait(bp); 365 if (bp->b_flags & B_WANTED) 366 wakeup((caddr_t)bp); 367 bp->b_flags &= B_ERROR; 368} 369 370/* 371 * Start an I/O operation on TS05 controller 372 */ 373int 374tsstart(struct ts_softc *sc, int isloaded) 375{ 376 struct buf *bp; 377 int cmd; 378 379 bp = BUFQ_PEEK(sc->sc_bufq); 380 if (bp == NULL) { 381 return 0; 382 } 383#ifdef TSDEBUG 384 printf("buf: %p bcount %ld blkno %d\n", bp, bp->b_bcount, bp->b_blkno); 385#endif 386 /* 387 * Check if command is an ioctl or not (ie. read or write). 388 * If it's an ioctl then just set the flags for later use; 389 * For other commands attempt to setup a buffer pointer. 390 */ 391 if (bp == &sc->ts_cbuf) { 392 switch ((int)bp->b_resid) { 393 case MTWEOF: 394 cmd = TS_CMD_WTM; 395 break; 396 case MTFSF: 397 cmd = TS_CMD_STMF; 398 sc->sc_vts->cmd.cw1 = bp->b_bcount; 399 break; 400 case MTBSF: 401 cmd = TS_CMD_STMR; 402 sc->sc_vts->cmd.cw1 = bp->b_bcount; 403 break; 404 case MTFSR: 405 cmd = TS_CMD_SRF; 406 sc->sc_vts->cmd.cw1 = bp->b_bcount; 407 break; 408 case MTBSR: 409 cmd = TS_CMD_SRR; 410 sc->sc_vts->cmd.cw1 = bp->b_bcount; 411 break; 412 case MTREW: 413 cmd = TS_CMD_RWND; 414 break; 415 case MTOFFL: 416 cmd = TS_CMD_RWUL; 417 break; 418 case MTNOP: 419 cmd = TS_CMD_STAT; 420 break; 421 default: 422 printf ("%s: bad ioctl %d\n", sc->sc_dev.dv_xname, 423 (int)bp->b_resid); 424 /* Need a no-op. get status */ 425 cmd = TS_CMD_STAT; 426 } /* end switch (bp->b_resid) */ 427 } else { 428 if (isloaded == 0) { 429 /* 430 * now we try to map the buffer into uba map space (???) 431 */ 432 if (bus_dmamap_load(sc->sc_dmat, sc->sc_dmam, 433 bp->b_data, 434 bp->b_bcount, bp->b_proc, BUS_DMA_NOWAIT)) { 435 uba_enqueue(&sc->sc_uu); 436 return 0; 437 } 438 sc->sc_rtc = 0; 439 } 440 sc->sc_vts->cmd.cw1 = LOWORD(sc->sc_dmam->dm_segs[0].ds_addr); 441 sc->sc_vts->cmd.cw2 = HIWORD(sc->sc_dmam->dm_segs[0].ds_addr); 442 sc->sc_vts->cmd.cw3 = bp->b_bcount; 443 bp->b_error = 0; /* Used for error count */ 444#ifdef TSDEBUG 445 printf("tsstart-1: err %d\n", bp->b_error); 446#endif 447 if (bp->b_flags & B_READ) 448 cmd = TS_CMD_RNF; 449 else 450 cmd = TS_CMD_WD; 451 } 452 453 /* 454 * Now that the command-buffer is setup, give it to the controller 455 */ 456 sc->sc_vts->cmd.cmdr = TS_CF_ACK | TS_CF_IE | cmd; 457#ifdef TSDEBUG 458 printf("tsstart: sending cmdr %x\n", sc->sc_vts->cmd.cmdr); 459#endif 460 TS_WCSR(TSDB, sc->sc_waddr); 461} 462 463/* 464 * Called when there are free uba resources. 465 */ 466int 467tsready(struct uba_unit *uu) 468{ 469 struct ts_softc *sc = uu->uu_softc; 470 struct buf *bp = BUFQ_PEEK(sc->sc_bufq); 471 472 if (bus_dmamap_load(sc->sc_dmat, sc->sc_dmam, bp->b_data, 473 bp->b_bcount, bp->b_proc, BUS_DMA_NOWAIT)) 474 return 0; 475 476 tsstart(sc, 1); 477 return 1; 478} 479 480/* 481 * initialize the controller by sending WRITE CHARACTERISTICS command. 482 * contents of command- and message-buffer are assembled during this 483 * function. 484 */ 485void 486tswchar(struct ts_softc *sc) 487{ 488 /* 489 * assemble and send "WRITE CHARACTERISTICS" command 490 */ 491 492 sc->sc_vts->cmd.cmdr = TS_CF_ACK | TS_CF_IE | TS_CMD_WCHAR; 493 sc->sc_vts->cmd.cw1 = LOWORD(&sc->sc_bts->chr); 494 sc->sc_vts->cmd.cw2 = HIWORD(&sc->sc_bts->chr); 495 sc->sc_vts->cmd.cw3 = 010; /* size of charact.-data */ 496 497 sc->sc_vts->chr.sadrl = LOWORD(&sc->sc_bts->status); 498 sc->sc_vts->chr.sadrh = HIWORD(&sc->sc_bts->status); 499 sc->sc_vts->chr.onesix = (sc->sc_type == TYPE_TS05 ? 020 : 016); 500 sc->sc_vts->chr.chrw = TS_WC_ESS; 501 sc->sc_vts->chr.xchrw = TS_WCX_HSP|TS_WCX_RBUF|TS_WCX_WBUF; 502 503 TS_WCSR(TSDB, sc->sc_waddr); 504} 505 506/* 507 * Reset the TS11. Return 1 if failed, 0 if succeeded. 508 */ 509int 510tsreset(struct ts_softc *sc) 511{ 512 int timeout; 513 514 /* 515 * reset ctlr by writing into TSSR, then write characteristics 516 */ 517 timeout = 0; /* timeout in 10 seconds */ 518 TS_WCSR(TSSR, 0); /* start initialization */ 519 while ((TS_RCSR(TSSR) & TS_SSR) == 0) { 520 DELAY(10000); 521 if (timeout++ > 1000) 522 return 0; 523 } 524 return 1; 525} 526 527static void 528prtstat(struct ts_softc *sc, int sr) 529{ 530 char buf[100]; 531 532 bitmask_snprintf(sr, TS_TSSR_BITS, buf, sizeof(buf)); 533 printf("%s: TSSR=%s\n", XNAME, buf); 534 bitmask_snprintf(sc->sc_vts->status.xst0,TS_XST0_BITS,buf,sizeof(buf)); 535 printf("%s: XST0=%s\n", XNAME, buf); 536} 537 538/* 539 * TSV05/TS05 interrupt routine 540 */ 541static void 542tsintr(void *arg) 543{ 544 struct ts_softc *sc = arg; 545 struct buf *bp; 546 547 unsigned short sr = TS_RCSR(TSSR); /* save TSSR */ 548 unsigned short mh = sc->sc_vts->status.hdr; /* and msg-header */ 549 /* clear the message header ??? */ 550 551 short ccode = sc->sc_vts->cmd.cmdr & TS_CF_CCODE; 552 553#ifdef TSDEBUG 554 { 555 char buf[100]; 556 bitmask_snprintf(sr, TS_TSSR_BITS, buf, sizeof(buf)); 557 printf("tsintr: sr %x mh %x\n", sr, mh); 558 printf("srbits: %s\n", buf); 559 } 560#endif 561 /* 562 * There are two different things which can (and should) be checked: 563 * the actual (internal) state and the device's result (tssr/msg.hdr) 564 * 565 * For each state there's only one "normal" interrupt. Anything else 566 * has to be checked more intensively. Thus in a first run according 567 * to the internal state the expected interrupt is checked/handled. 568 * 569 * In a second run the remaining (not yet handled) interrupts are 570 * checked according to the drive's result. 571 */ 572 switch (sc->sc_state) { 573 574 case TS_INVALID: 575 /* 576 * Ignore unsolicited interrupts. 577 */ 578 log(LOG_WARNING, "%s: stray intr [%x,%x]\n", 579 sc->sc_dev.dv_xname, sr, mh); 580 return; 581 582 case TS_INIT: 583 /* 584 * Init phase ready. 585 */ 586 wakeup(sc); 587 return; 588 589 case TS_RUNNING: 590 case TS_FASTREPOS: 591 /* 592 * Here we expect interrupts indicating the end of 593 * commands or indicating problems. 594 */ 595 /* 596 * Anything else is handled outside this switch ... 597 */ 598 break; 599 600 default: 601 printf ("%s: unexpected interrupt during state %d [%x,%x]\n", 602 sc->sc_dev.dv_xname, sc->sc_state, sr, mh); 603 return; 604 } 605 606 /* 607 * now we check the termination class. 608 */ 609 switch (sr & TS_TC) { 610 611 case TS_TC_NORM: 612 /* 613 * Normal termination -- The operation is completed 614 * witout incident. 615 */ 616 if (sc->sc_state == TS_FASTREPOS) { 617#ifdef TSDEBUG 618 printf("Fast repos interrupt\n"); 619#endif 620 /* Fast repos succeeded, start normal data xfer */ 621 sc->sc_state = TS_RUNNING; 622 tsstart(sc, 1); 623 return; 624 } 625 sc->sc_liowf = (ccode == TS_CC_WRITE); 626 break; 627 628 case TS_TC_ATTN: 629 /* 630 * Attention condition -- this code indicates that the 631 * drive has undergone a status change, such as going 632 * off-line or coming on-line. 633 * (Without EAI enabled, no Attention interrupts occur. 634 * drive status changes are signaled by the VCK flag.) 635 */ 636 return; 637 638 case TS_TC_TSA: 639 /* 640 * Tape Status Alert -- A status condition is encountered 641 * that may have significance to the program. Bits of 642 * interest in the extended status registers include 643 * TMK, EOT and RLL. 644 */ 645#ifdef TSDEBUG 646 { 647 char buf[100]; 648 bitmask_snprintf(sc->sc_vts->status.xst0, 649 TS_XST0_BITS, buf, sizeof(buf)); 650 printf("TSA: sr %x bits %s\n", 651 sc->sc_vts->status.xst0, buf); 652 } 653#endif 654 if (sc->sc_vts->status.xst0 & TS_SF_TMK) { 655 /* Read to end-of-file. No error. */ 656 break; 657 } 658 if (sc->sc_vts->status.xst0 & TS_SF_EOT) { 659 /* End of tape. Bad. */ 660#ifdef TSDEBUG 661 printf("TS_TC_TSA: EOT\n"); 662#endif 663 bp->b_flags |= B_ERROR; 664 bp->b_error = EIO; 665 break; 666 } 667 if (sc->sc_vts->status.xst0 & TS_SF_RLS) 668 break; 669 if (sc->sc_vts->status.xst0 & TS_SF_TMK) { 670#ifdef TSDEBUG 671 printf(("Tape Mark detected")); 672#endif 673 } 674 if (sc->sc_vts->status.xst0 & TS_SF_EOT) { 675#ifdef TSDEBUG 676 printf(("End of Tape")); 677#endif 678 } 679#ifndef TSDEBUG 680 { 681 char buf[100]; 682 bitmask_snprintf(sc->sc_vts->status.xst0, 683 TS_XST0_BITS, buf, sizeof(buf)); 684 printf("TSA: sr %x bits %s\n", 685 sc->sc_vts->status.xst0, buf); 686 } 687#endif 688 break; 689 690 case TS_TC_FR: 691 /* 692 * Function Reject -- The specified function was not 693 * initiated. Bits of interest include OFL, VCK, BOT, 694 * WLE, ILC and ILA. 695 */ 696 if (sr & TS_OFL) 697 printf("tape is off-line.\n"); 698#ifdef TSDEBUG 699 { 700 char buf[100]; 701 bitmask_snprintf(sc->sc_vts->status.xst0, 702 TS_XST0_BITS, buf, sizeof(buf)); 703 printf("FR: sr %x bits %s\n", 704 sc->sc_vts->status.xst0, buf); 705 } 706#endif 707 if (sc->sc_vts->status.xst0 & TS_SF_VCK) 708 printf("Volume check\n"); 709 if (sc->sc_vts->status.xst0 & TS_SF_BOT) 710 printf("Start of tape.\n"); 711 if (sc->sc_vts->status.xst0 & TS_SF_WLE) 712 printf("Write Lock Error\n"); 713 if (sc->sc_vts->status.xst0 & TS_SF_EOT) 714 printf("End of tape.\n"); 715 break; 716 717 case TS_TC_TPD: 718 /* 719 * Recoverable Error -- Tape position is a record beyond 720 * what its position was when the function was initiated. 721 * Suggested recovery procedure is to log the error and 722 * issue the appropriate retry command. 723 * 724 * Do a fast repositioning one record back. 725 */ 726 sc->sc_state = TS_FASTREPOS; 727#ifdef TSDEBUG 728 printf("TS_TC_TPD: errcnt %d\n", sc->sc_rtc); 729#endif 730 if (sc->sc_rtc++ == 8) { 731 printf("%s: failed 8 retries\n", XNAME); 732 prtstat(sc, sr); 733 bp->b_flags |= B_ERROR; 734 bp->b_error = EIO; 735 break; 736 } 737 sc->sc_vts->cmd.cmdr = TS_CF_ACK | TS_CF_IE | TS_CMD_SRR; 738 sc->sc_vts->cmd.cw1 = 1; 739 TS_WCSR(TSDB, sc->sc_waddr); 740 return; 741 742 break; 743 744 case TS_TC_TNM: 745 /* 746 * Recoverable Error -- Tape position has not changed. 747 * Suggested recovery procedure is to log the error and 748 * reissue the original command. 749 */ 750 if (sc->sc_rtc++ == 8) { 751 printf("%s: failed 8 retries\n", XNAME); 752 prtstat(sc, sr); 753 bp->b_flags |= B_ERROR; 754 bp->b_error = EIO; 755 break; 756 } 757 tsstart(sc, 1); 758 return; 759 760 case TS_TC_TPL: 761 /* 762 * Unrecoverable Error -- Tape position has been lost. 763 * No valid recovery procedures exist unless the tape 764 * has labels or sequence numbers. 765 */ 766 printf("Tape position lost\n"); 767 bp->b_flags |= B_ERROR; 768 bp->b_error = EIO; 769 break; 770 771 case TS_TC_FCE: 772 /* 773 * Fatal subsytem Error -- The subsytem is incapable 774 * of properly performing commands, or at least its 775 * integrity is seriously questionable. Refer to the 776 * fatal class code field in the TSSR register for 777 * additional information on the type of fatal error. 778 */ 779 printf ("Fatal Controller Error\n"); 780 prtstat(sc, sr); 781 break; 782 783 default: 784 printf ("%s: error 0x%x, resetting controller\n", 785 sc->sc_dev.dv_xname, sr & TS_TC); 786 tsreset(sc); 787 } 788 if ((bp = BUFQ_GET(sc->sc_bufq)) != NULL) { 789#ifdef TSDEBUG 790 printf("tsintr2: que %p\n", BUFQ_PEEK(sc->sc_bufq)); 791#endif 792 if (bp != &sc->ts_cbuf) { /* no ioctl */ 793 bus_dmamap_unload(sc->sc_dmat, sc->sc_dmam); 794 uba_done((void *)sc->sc_dev.dv_parent); 795 } 796 bp->b_resid = sc->sc_vts->status.rbpcr; 797 if ((bp->b_flags & B_ERROR) == 0) 798 bp->b_error = 0; 799 biodone (bp); 800 } 801 tsstart(sc, 0); 802} 803 804 805/* 806 * Open a ts device and set the unit online. If the controller is not 807 * in the run state, call init to initialize the ts controller first. 808 */ 809int 810tsopen(dev_t dev, int flag, int type, struct proc *p) 811{ 812 struct ts_softc *sc; 813 int unit = TS_UNIT(dev); 814 815 if (unit >= ts_cd.cd_ndevs) 816 return ENXIO; 817 818 sc = ts_cd.cd_devs[unit]; 819 if (sc == 0) 820 return ENXIO; 821 822 if (sc->sc_state < TS_RUNNING) 823 return ENXIO; 824 825 if (sc->sc_openf) 826 return EBUSY; 827 sc->sc_openf = 1; 828 829 /* 830 * check if transport is really online. 831 * (without attention-interrupts enabled, we really don't know 832 * the actual state of the transport. Thus we call get-status 833 * (ie. MTNOP) once and check the actual status.) 834 */ 835 if (TS_RCSR(TSSR) & TS_OFL) { 836 uprintf("%s: transport is offline.\n", XNAME); 837 sc->sc_openf = 0; 838 return EIO; /* transport is offline */ 839 } 840 tscommand(sc, dev, MTNOP, 1); 841 if ((flag & FWRITE) && (sc->sc_vts->status.xst0 & TS_SF_WLK)) { 842 uprintf("%s: no write ring.\n", XNAME); 843 sc->sc_openf = 0; 844 return EROFS; 845 } 846 if (sc->sc_vts->status.xst0 & TS_SF_VCK) { 847 sc->sc_vts->cmd.cmdr = TS_CF_CVC|TS_CF_ACK; 848 TS_WCSR(TSDB, sc->sc_waddr); 849 } 850 tscommand(sc, dev, MTNOP, 1); 851#ifdef TSDEBUG 852 { 853 char buf[100]; 854 bitmask_snprintf(sc->sc_vts->status.xst0, 855 TS_XST0_BITS, buf, sizeof(buf)); 856 printf("tsopen: xst0 %s\n", buf); 857 } 858#endif 859 sc->sc_liowf = 0; 860 return 0; 861} 862 863 864/* 865 * Close tape device. 866 * 867 * If tape was open for writing or last operation was 868 * a write, then write two EOF's and backspace over the last one. 869 * Unless this is a non-rewinding special file, rewind the tape. 870 * 871 * Make the tape available to others, by clearing openf flag. 872 */ 873int 874tsclose(dev_t dev, int flag, int type, struct proc *p) 875{ 876 struct ts_softc *sc = ts_cd.cd_devs[TS_UNIT(dev)]; 877 878 if (flag == FWRITE || ((flag & FWRITE) && sc->sc_liowf)) { 879 /* 880 * We are writing two tape marks (EOT), but place the tape 881 * before the second one, so that another write operation 882 * will overwrite the second one and leave and EOF-mark. 883 */ 884 tscommand(sc, dev, MTWEOF, 1); /* Write Tape Mark */ 885 tscommand(sc, dev, MTWEOF, 1); /* Write Tape Mark */ 886 tscommand(sc, dev, MTBSF, 1); /* Skip Tape Marks Reverse */ 887 } 888 889 if ((dev & T_NOREWIND) == 0) 890 tscommand(sc, dev, MTREW, 0); 891 892 sc->sc_openf = 0; 893 sc->sc_liowf = 0; 894 return 0; 895} 896 897 898/* 899 * Manage buffers and perform block mode read and write operations. 900 */ 901void 902tsstrategy(struct buf *bp) 903{ 904 register int unit = TS_UNIT(bp->b_dev); 905 struct ts_softc *sc = (void *)ts_cd.cd_devs[unit]; 906 int s, empty; 907 908#ifdef TSDEBUG 909 printf("buf: %p bcount %ld blkno %d\n", bp, bp->b_bcount, bp->b_blkno); 910#endif 911 s = splbio (); 912 empty = (BUFQ_PEEK(sc->sc_bufq) == NULL); 913 BUFQ_PUT(sc->sc_bufq, bp); 914 if (empty) 915 tsstart(sc, 0); 916 splx(s); 917} 918 919 920/* 921 * Catch ioctl commands, and call the "command" routine to do them. 922 */ 923int 924tsioctl(dev, cmd, data, flag, p) 925 dev_t dev; 926 u_long cmd; 927 caddr_t data; 928 int flag; 929 struct proc *p; 930{ 931 struct buf *bp; 932 struct ts_softc *sc; 933 struct mtop *mtop; /* mag tape cmd op to perform */ 934 struct mtget *mtget; /* mag tape struct to get info in */ 935 int callcount; /* number of times to call routine */ 936 int scount; /* number of files/records to space */ 937 int spaceop = 0; /* flag for skip/space operation */ 938 int error = 0; 939 940#ifdef TSDEBUG 941 printf("tsioctl (%x, %lx, %p, %d)\n", dev, cmd, data, flag); 942#endif 943 944 sc = ts_cd.cd_devs[TS_UNIT(dev)]; 945 bp = &sc->ts_cbuf; 946 947 switch (cmd) { 948 case MTIOCTOP: /* do a mag tape op */ 949 mtop = (struct mtop *)data; 950 switch (mtop->mt_op) { 951 case MTWEOF: /* write an end-of-file record */ 952 callcount = mtop->mt_count; 953 scount = 1; 954 break; 955 case MTFSR: /* forward space record */ 956 case MTBSR: /* backward space record */ 957 spaceop = 1; 958 case MTFSF: /* forward space file */ 959 case MTBSF: /* backward space file */ 960 callcount = 1; 961 scount = mtop->mt_count; 962 break; 963 case MTREW: /* rewind */ 964 case MTOFFL: /* rewind and put the drive offline */ 965 case MTNOP: /* no operation, sets status only */ 966 callcount = 1; 967 scount = 1; /* wait for this rewind */ 968 break; 969 case MTRETEN: /* retension */ 970 case MTERASE: /* erase entire tape */ 971 case MTEOM: /* forward to end of media */ 972 case MTNBSF: /* backward space to begin of file */ 973 case MTCACHE: /* enable controller cache */ 974 case MTNOCACHE: /* disable controller cache */ 975 case MTSETBSIZ: /* set block size; 0 for variable */ 976 case MTSETDNSTY: /* set density code for current mode */ 977 printf("ioctl %d not implemented.\n", mtop->mt_op); 978 return (ENXIO); 979 default: 980#ifdef TSDEBUG 981 printf("invalid ioctl %d\n", mtop->mt_op); 982#endif 983 return (ENXIO); 984 } /* switch (mtop->mt_op) */ 985 986 if (callcount <= 0 || scount <= 0) { 987#ifdef TSDEBUG 988 printf("invalid values %d/%d\n", callcount, scount); 989#endif 990 return (EINVAL); 991 } 992 do { 993 tscommand(sc, dev, mtop->mt_op, scount); 994 if (spaceop && bp->b_resid) { 995#ifdef TSDEBUG 996 printf(("spaceop didn't complete\n")); 997#endif 998 return (EIO); 999 } 1000 if (bp->b_flags & B_ERROR) { 1001#ifdef TSDEBUG 1002 printf("error in ioctl %d\n", mtop->mt_op); 1003#endif 1004 break; 1005 } 1006 } while (--callcount > 0); 1007 if (bp->b_flags & B_ERROR) 1008 if ((error = bp->b_error) == 0) 1009 return (EIO); 1010 return (error); 1011 1012 case MTIOCGET: /* get tape status */ 1013 mtget = (struct mtget *)data; 1014 mtget->mt_type = MT_ISTS; 1015 mtget->mt_dsreg = TS_RCSR(TSSR); 1016 mtget->mt_erreg = sc->sc_vts->status.xst0; 1017 mtget->mt_resid = 0; /* ??? */ 1018 mtget->mt_density = 0; /* ??? */ 1019 break; 1020 1021 case MTIOCIEOT: /* ignore EOT error */ 1022#ifdef TSDEBUG 1023 printf(("MTIOCIEOT not implemented.\n")); 1024#endif 1025 return (ENXIO); 1026 1027 case MTIOCEEOT: /* enable EOT error */ 1028#ifdef TSDEBUG 1029 printf(("MTIOCEEOT not implemented.\n")); 1030#endif 1031 return (ENXIO); 1032 1033 default: 1034#ifdef TSDEBUG 1035 printf("invalid ioctl cmd 0x%lx\n", cmd); 1036#endif 1037 return (ENXIO); 1038 } 1039 1040 return (0); 1041} 1042 1043 1044/* 1045 * 1046 */ 1047int 1048tsread(dev_t dev, struct uio *uio, int flag) 1049{ 1050 return (physio (tsstrategy, NULL, dev, B_READ, minphys, uio)); 1051} 1052 1053/* 1054 * 1055 */ 1056int 1057tswrite(dev_t dev, struct uio *uio, int flag) 1058{ 1059 return (physio (tsstrategy, NULL, dev, B_WRITE, minphys, uio)); 1060} 1061 1062/* 1063 * 1064 */ 1065int 1066tsdump(dev, blkno, va, size) 1067 dev_t dev; 1068 daddr_t blkno; 1069 caddr_t va; 1070 size_t size; 1071{ 1072 return EIO; 1073} 1074