![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cy.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / sys / vba|
Return to cy.c CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / sys / vba |
1.1 ! root 1: /* ! 2: ** Author: John R. Franks ! 3: ** Date: 16-Aug-85 ! 4: ** ! 5: ** This driver is used to control a Tapemaster tape controller. The ! 6: ** Tapemaster controller is a particularly unreasonable controller to work ! 7: ** with. ! 8: ** ! 9: ** We implement both a block device and a raw device with this driver. ! 10: ** (of course) Each device has it's own special requirement as defined below. ! 11: ** ! 12: ** The block device handles files which consist of a series of 1k byte ! 13: ** blocks. It can be read or written to like any random access device, except, ! 14: ** you can not read past the last position written to on tape. The reason ! 15: ** for this is entirly mechanical. Tape drive positioning is not accurate ! 16: ** enough to guarantee that we will not write over a portion of a following ! 17: ** record on the tape. I.e. If we had five known blocks on a tape and we ! 18: ** rewrote the fourth block on the tape, then the fifth block probably ! 19: ** had it's leading gap or the beginning of it's data overwritten. Clearly ! 20: ** the data can not be trusted, so, we just make it a rule that writting ! 21: ** to the tape in any form also defines the end of volume. ! 22: ** ! 23: ** The block device will seek automatically to the next block number if ! 24: ** the tape is mispositioned before the read is done. ! 25: ** ! 26: ** In general the block device should not be used except maybe to ! 27: ** read an exact disk image off of it. ! 28: ** ! 29: ** The raw device is responsible for large reads and writes, and all ! 30: ** ioctl control commands. Each command has to keep the tape in a consistant ! 31: ** state so that they will not be messed up by the sequence of user requests. ! 32: ** As an example: if a user back spaces after a write an end of volume record ! 33: ** will be written before the spacing occurs so that we will be able to ! 34: ** find the end of the file subsequent read operatons. ! 35: ** ! 36: ** The raw device also has the same restrictions on writes as the block ! 37: ** device. ! 38: ** ! 39: ** The ioctls supported by the system are: ! 40: ** ! 41: ** internal name value comments ! 42: ** DO_W_FM 0 Write a file mark to tape ! 43: ** DO_SFMF 1 search for a file mark in the forward direction ! 44: ** DO_SFMB 2 search fo a file mark in the backward direction. ! 45: ** DO_SPF 3 space forward one record ! 46: ** DO_SPB 4 space backward one record ! 47: ** DO_RWTA 5 rewind and wait ! 48: ** DO_RWUN 6 rewind and unload tape ! 49: ** DO_STAT 7 get drive status ! 50: ** DO_RWOV 8 rewind overlapped ! 51: ** DO_WAIT 9 wait for rewind to complete ! 52: */ ! 53: ! 54: /* Includes */ ! 55: ! 56: #include "cy.h" ! 57: #if NCY > 0 ! 58: int cydebug = 0; ! 59: #include "../h/param.h" ! 60: #include "../h/systm.h" ! 61: #include "../machine/mtpr.h" ! 62: #include "../h/vm.h" ! 63: #include "../h/buf.h" ! 64: #include "../machine/pte.h" ! 65: #include "../h/file.h" ! 66: #include "../h/dir.h" ! 67: #include "../h/user.h" ! 68: #include "../h/proc.h" ! 69: #include "../h/signal.h" ! 70: ! 71: #include "../h/uio.h" ! 72: #include "../h/ioctl.h" ! 73: #include "../h/mtio.h" ! 74: #include "../h/errno.h" ! 75: #include "../h/cmap.h" ! 76: #include "../vba/vbavar.h" ! 77: #include "../vba/cipher.h" ! 78: ! 79: ! 80: /* Definitions */ ! 81: ! 82: #define MAXCONTROLLERS 4 ! 83: #define MAX_BLOCKSIZE (TBUFSIZ*NBPG) ! 84: #define NUM_UNIT (NCY * 4) ! 85: ! 86: #define TRUE 1 ! 87: #define FALSE 0 ! 88: #define NOERROR 0 ! 89: #define RETRY 1 ! 90: #define EXTEND 2 ! 91: #define FATAL 3 ! 92: ! 93: #define MAINTAIN_POSITION 0 ! 94: #define DONT_MAINTAIN_POSITION 1 ! 95: ! 96: #define PROCESSED 0x80000000 ! 97: #define SLEEPING 0x80000000 ! 98: #define b_cmd av_back /* only unused word in request */ ! 99: ! 100: ! 101: /* ! 102: ** ioctl command offset definitions. (so we can issue ioctls internally) ! 103: */ ! 104: ! 105: #define DO_W_FM 0 ! 106: #define DO_SFMF 1 ! 107: #define DO_SFMB 2 ! 108: #define DO_SPF 3 ! 109: #define DO_SPB 4 ! 110: #define DO_RWTA 5 ! 111: #define DO_RWUN 6 ! 112: #define DO_STAT 7 ! 113: #define DO_RWOV 8 ! 114: #define DO_WAIT 9 ! 115: #define DO_WEOV 10 ! 116: #define DO_RRD 11 ! 117: #define DO_RWT 12 ! 118: #define DO_BRD 13 ! 119: #define DO_BWT 14 ! 120: ! 121: /* ! 122: ** Declarations for ioctl subroutines (needed for jump table below. ! 123: */ ! 124: ! 125: extern int cywrite_filemark(), cysearch_fm_forw(), cysearch_fm_back(); ! 126: extern int cy_space_forw(), cy_space_back(), cyrewind_tape_ta(); ! 127: extern int cyrewind_tape_unl(), cydrive_status(), cyrewind_tape_ov(); ! 128: extern int cyraw_read(), cyraw_write(), cybuf_read(), cybuf_write(); ! 129: extern int cywait_until_ready(), cywrite_0_fm(), cywrite_1_fm(); ! 130: extern int cywrite_2_fm(), cyno_op(), cywrite_eov(); ! 131: ! 132: /* ! 133: ** Jump table for ioctl functions (used in cystart). ! 134: */ ! 135: ! 136: static int (*cmd_tbl[15])() = { ! 137: cywrite_filemark, cysearch_fm_forw, cysearch_fm_back, cy_space_forw, ! 138: cy_space_back, cyrewind_tape_ta, cyrewind_tape_unl, cydrive_status, ! 139: cyrewind_tape_ov, cywait_until_ready, cywrite_eov, cyraw_read, ! 140: cyraw_write, cybuf_read, cybuf_write ! 141: }; ! 142: ! 143: /* Variables */ ! 144: ! 145: /* Autoconfigure entry point definitions */ ! 146: ! 147: extern int cyprobe(), cyslave(), cyattach(), cydgo(); ! 148: ! 149: /* physio routines */ ! 150: ! 151: extern unsigned cyminsize(); ! 152: ! 153: /* Define driver structures for UNIX */ ! 154: ! 155: extern char cy0utl[]; ! 156: #if NCY > 0 ! 157: extern char cy1utl[]; ! 158: #endif ! 159: ! 160: static fmt_scp *scp_ptrs[MAXCONTROLLERS] = { ! 161: (fmt_scp *)0xc0000c06, (fmt_scp *)0xc0000c16, ! 162: }; ! 163: ! 164: struct vba_ctlr *cyminfo[NCY]; ! 165: ! 166: struct vba_device *cydinfo[NUM_UNIT]; ! 167: ! 168: struct vba_driver cydriver = ! 169: { ! 170: cyprobe, cyslave, cyattach, cydgo, (long *)scp_ptrs, ! 171: "cipher", cydinfo, "", cyminfo ! 172: }; ! 173: ! 174: /* Define data structures for controllers */ ! 175: ! 176: typedef struct { ! 177: struct pte *map; ! 178: char *utl; ! 179: int (*interupt_path)(); ! 180: label_t environ; /* Environment variable for longjmps */ ! 181: struct buf *my_request; ! 182: struct buf *wakeup_request; ! 183: short bs; /* buffer size */ ! 184: fmt_ccb ccb; /* Channel control blocks */ ! 185: fmt_scb scb; /* System configuration blocks */ ! 186: fmt_tpb tpb; /* Tape parameter blocks */ ! 187: fmt_tpb last; /* Tape parameter blocks */ ! 188: fmt_tpb noop; /* Tape parameter blocks */ ! 189: long rawbuf[MAX_BLOCKSIZE/sizeof(long)+1]; ! 190: } ctlr_tab; ! 191: ! 192: extern int cy_normal_path(); ! 193: ! 194: ctlr_tab ctlr_info[NCY] = { ! 195: {CY0map, cy0utl, cy_normal_path} ! 196: #if NCY > 1 ! 197: ,{CY1map, cy1utl, cy_normal_path} ! 198: #if NCY > 2 ! 199: error /* Only 2 controllers can be used at this time */ ! 200: #endif ! 201: #endif ! 202: }; ! 203: ! 204: /* information needed for each drive */ ! 205: ! 206: typedef struct { ! 207: int (*cleanup)(); ! 208: struct buf u_queue; ! 209: struct buf rawbp; ! 210: long blkno; ! 211: long file_number; ! 212: short last_control; ! 213: short last_status; ! 214: short last_resid; ! 215: unsigned long bad_count; ! 216: unsigned control_proto: 16; ! 217: unsigned error_count : 8; ! 218: unsigned open : 1; ! 219: unsigned eof : 1; ! 220: unsigned bot : 1; ! 221: unsigned eot : 1; ! 222: char *message; ! 223: }unit_tab; ! 224: ! 225: unit_tab unit_info[NUM_UNIT]; ! 226: ! 227: ! 228: /* ! 229: ** Cyprobe checks to see if a controller is present on the VERSAbus. ! 230: ** An attempt is made to read from the controller's first register, if ! 231: ** a buss error does not occur then the controller is assumed to be ! 232: ** there. ! 233: ** ! 234: ** If the controller responds to the read request, then we go ahead ! 235: ** and initialize the controller for UNIX's use. If no problems were ! 236: ** reported during system initialization, then we return TRUE to the ! 237: ** system to indicate that the controller is there and everything is OK. ! 238: */ ! 239: ! 240: cyprobe(ctlr_vaddr) ! 241: register caddr_t ctlr_vaddr; ! 242: { ! 243: static int ctlr = -1; ! 244: ! 245: ctlr++; ! 246: if (!badcyaddr(ctlr_vaddr + 1)) ! 247: return cy_init_controller(ctlr_vaddr, ctlr, 1); ! 248: return FALSE; ! 249: } ! 250: ! 251: ! 252: /* ! 253: ** Cy_init_controller is called to initialize the controller after the ! 254: ** controller is reset or during Autoconfigure. All of the system control ! 255: ** blocks are initialized and the controller is asked to configure itself ! 256: ** for later use. ! 257: ** ! 258: ** If the print value is true cy_first_TM_attention will anounce ! 259: ** the type of controller we are (Tapemasher) and will print the size ! 260: ** of the internal controller buffer. ! 261: */ ! 262: ! 263: cy_init_controller(ctlr_vaddr, ctlr, print) ! 264: register caddr_t ctlr_vaddr; ! 265: register int ctlr; ! 266: register int print; ! 267: { ! 268: cy_init_sys_config_ptr(ctlr); ! 269: cy_init_sys_config_blk(ctlr); ! 270: cy_init_channel_control_blk(ctlr); ! 271: return cy_first_TM_attention(ctlr_vaddr, ctlr, print); ! 272: } ! 273: ! 274: ! 275: /* ! 276: ** Cyslave checks to see if a drive is attached to a controller. ! 277: ** There are no signals, on the serial buses from the tape drive to the ! 278: ** controller, to indicate that a drive is physically present on the ! 279: ** buss. We can only tell that a drive is there if a tape is loaded ! 280: ** on the drive and the drive is placed online. ! 281: ** ! 282: ** Since it would be ridiculus to force system operators to load ! 283: ** tapes on every tape drive on the system before every boot operation, ! 284: ** we simply indicate that the drive is there every time we are asked. ! 285: ** ! 286: ** In theory the system should be configured according to the ! 287: ** hardware configuration anyway and should not present a problem. ! 288: */ ! 289: ! 290: cyslave(vba_device_info, ctlr_vaddr) ! 291: register struct vba_device *vba_device_info; ! 292: register caddr_t ctlr_vaddr; ! 293: { ! 294: /* ! 295: * assume tape is connected because there is ! 296: * no way on earth to tell if the drive is connected or not. ! 297: */ ! 298: return TRUE; ! 299: } ! 300: ! 301: ! 302: /* ! 303: ** cyattach is used to add a drive to our internal tables. ! 304: */ ! 305: ! 306: cyattach(dev_info) ! 307: struct vba_device *dev_info; ! 308: { ! 309: register unit_tab *u_info = &unit_info[dev_info->ui_unit]; ! 310: register struct buf *ctlr_queue = &dev_info->ui_mi->um_tab; ! 311: register struct buf *unit_queue = ctlr_queue->b_forw; ! 312: register struct buf *start_queue = unit_queue; ! 313: ! 314: /* Add unit to controllers queue */ ! 315: if(ctlr_queue->b_forw == NULL) { ! 316: ctlr_queue->b_forw = &u_info->u_queue; ! 317: u_info->u_queue.b_forw = &u_info->u_queue; ! 318: } ! 319: else { ! 320: while(unit_queue->b_forw != start_queue) ! 321: unit_queue = unit_queue->b_forw; ! 322: u_info->u_queue.b_forw = start_queue; ! 323: unit_queue->b_forw = &u_info->u_queue; ! 324: } ! 325: u_info->cleanup = cyno_op; ! 326: u_info->last_status = 0; ! 327: u_info->last_control = 0; ! 328: u_info->file_number = 0; ! 329: u_info->bad_count = 0; ! 330: u_info->blkno = 0; ! 331: u_info->open = FALSE; ! 332: u_info->bot = TRUE; ! 333: u_info->eot = FALSE; ! 334: u_info->eof = FALSE; ! 335: u_info->message = NULL; ! 336: } ! 337: ! 338: ! 339: /* ! 340: ** Historic routine left over from VAX port but the definition is still ! 341: ** hanging around. ! 342: */ ! 343: ! 344: cydgo() ! 345: { ! 346: } ! 347: ! 348: /* ! 349: ** cy_init_sys_config_ptr initializes the Tapemaster system configuration ! 350: ** pointer. The Tapemaster controller requires it's own system pointer ! 351: ** in low memory. The absolute addresses are 0xc06 for controller #1, and ! 352: ** 0xc16 for controller #2. (The space definitions are in locore.s if you ! 353: ** want to add anther controller to the system. (good luck)) ! 354: ** ! 355: ** This routine sets the correct page to give kernel write access, ! 356: ** loads in the appropriate values, and then resets the page to kernel read ! 357: ** only access to prevent other routines from stepping all over the scp ! 358: ** and causing obscure tape problems. ! 359: ** ! 360: ** The format of the system configuration pointer is as follows: ! 361: ** ! 362: ** 8 bits 8 bits 32 bits (20 that count) ! 363: ** +----------+----------+----------------+ ! 364: ** | bus size | unused | Pointer to scb | ! 365: ** +----------+----------+----------------+ ! 366: */ ! 367: ! 368: cy_init_sys_config_ptr(ctlr) ! 369: register int ctlr; ! 370: { ! 371: register int *pte_ptr; ! 372: register fmt_scp *SCP = scp_ptrs[ctlr]; ! 373: ! 374: /* Set the page to kernel write access */ ! 375: pte_ptr = (int *)vtopte(0, btop(SCP)); ! 376: *pte_ptr &= ~PG_PROT; /* clear all protection bits */ ! 377: *pte_ptr |= PG_KW /* allow kernal writes */; ! 378: mtpr(SCP, TBIS); ! 379: /* load the correct values in the scp */ ! 380: SCP->bus_size = _16_BITS; ! 381: load_mbus_addr(&ctlr_info[ctlr].scb, SCP->scb_ptr); ! 382: /* Give read only privialages to the kernel */ ! 383: *pte_ptr &= ~PG_PROT; /* clear all protection bits */ ! 384: *pte_ptr |= PG_KR; /* allow only kernal */ ! 385: mtpr(SCP, TBIS); ! 386: } ! 387: ! 388: ! 389: /* ! 390: ** cy_init_sys_config_blk loads the appropriate values into the ! 391: ** system configuration block for the Tapemaster controller. ! 392: ** ! 393: ** This data structure does not contain any useful information ! 394: ** for us. The only possible use for this block is for a ! 395: ** consistancy check by the controller itself using the fixed value. ! 396: ** but that could have been done elsewhere. However the controller will ! 397: ** not run without it so we maintain this structure here..... ! 398: ** ! 399: ** The format of the system configuration block is as follows: ! 400: ** ! 401: ** 8 bits 8 bits 32 bits (20 that count) ! 402: ** +-----------+----------+----------------+ ! 403: ** | must be 3 | unused | Pointer to ccb | ! 404: ** +-----------+----------+----------------+ ! 405: */ ! 406: ! 407: cy_init_sys_config_blk(ctlr) ! 408: register int ctlr; ! 409: { ! 410: register fmt_scb *SCB = &ctlr_info[ctlr].scb; ! 411: ! 412: SCB->fixed_value = 0x3; ! 413: /* set pointer to the channel control block */ ! 414: load_mbus_addr(&ctlr_info[ctlr].ccb, SCB->ccb_ptr); ! 415: } ! 416: ! 417: ! 418: /* ! 419: ** Cy_init_channel_control_blk is used to load the initial values into ! 420: ** the ccb structures for the controller. ! 421: ** ! 422: ** The format of the channel control block is as follows: ! 423: ** ! 424: ** 8 bits 8 bits 32 bits (20 that count) ! 425: ** +-----------+----------+----------------+ ! 426: ** | CCW | gate | Pointer to tpb | ! 427: ** +-----------+----------+----------------+ ! 428: ** ! 429: ** the CCW field is used to control interupt operations. If the field is ! 430: ** equal to 11(hex) then interupts are enabled, if it contains a 9(hex) then ! 431: ** the Tapemaster controller is instructed to stop interupting (it will ! 432: ** flood the system with interupts until it is instructed to stop!) ! 433: ** ! 434: ** The gate field is used to syncronize the processor operations and ! 435: ** the controller. We close it when an operation is started, ! 436: ** It is opened by the controller when the operation is done. ! 437: */ ! 438: ! 439: cy_init_channel_control_blk(ctlr) ! 440: register int ctlr; ! 441: { ! 442: register fmt_ccb *CCB = &ctlr_info[ctlr].ccb; ! 443: ! 444: CCB->ccw = CLEAR_INTERUPT; ! 445: CCB->gate = GATE_OPEN; ! 446: /* set pointer to the tape parameter block */ ! 447: load_mbus_addr(&ctlr_info[ctlr].tpb, CCB->tpb_ptr); ! 448: } ! 449: ! 450: ! 451: /* ! 452: ** Cy_first_TM_attention is used to issue the very first command ! 453: ** after boot or after the controller is reset. This case is special ! 454: ** since we 1) should not interupt duing this sequence, 2) really need ! 455: ** to issue two commands, and 3) we need to get the controller's internal ! 456: ** buffer size for future reference. ! 457: ** ! 458: ** The print flag is used so that we only print out the greeting ! 459: ** message during Autoconfigure time. (it would be obnoxious if it ! 460: ** printed every time the drive times out.) ! 461: ** ! 462: ** The first NOOP command is issued to get the drive's attention. ! 463: ** The tpb is never even looked during the first attention. ! 464: ** ! 465: ** The second command actually configures the controller and returns ! 466: ** the internal buffersize for buffered I/O. ! 467: */ ! 468: ! 469: cy_first_TM_attention(ctlr_vaddr, ctlr, print) ! 470: register caddr_t ctlr_vaddr; ! 471: register int ctlr, print; ! 472: { ! 473: register ctlr_tab *c_info = &ctlr_info[ctlr]; ! 474: ! 475: /* set command to be CONFIGURE */ ! 476: c_info->tpb.cmd = NO_OP; ! 477: c_info->tpb.control = CW_16bits; ! 478: c_info->ccb.gate = GATE_CLOSED; ! 479: CY_ATTENTION(ctlr_vaddr); /* execute! */ ! 480: if(cywait(&c_info->ccb) || (c_info->tpb.status & CS_ERm)) { ! 481: printf("Tapemaster controller time-out during initialization!\n"); ! 482: return FALSE; ! 483: } ! 484: c_info->tpb.cmd = CONFIG; ! 485: c_info->tpb.control = CW_16bits; ! 486: c_info->ccb.gate = GATE_CLOSED; ! 487: CY_ATTENTION(ctlr_vaddr); /* execute! */ ! 488: if(cywait(&c_info->ccb) || (c_info->tpb.status & CS_ERm)) { ! 489: cyprint_err("Tapemaster configuration failure", ! 490: 0, c_info->tpb.status); ! 491: return FALSE; ! 492: } ! 493: uncache(&c_info->tpb.count); ! 494: c_info->bs = MULTIBUS_SHORT(c_info->tpb.count); ! 495: if(print) ! 496: printf("Tapemaster with %dkb buffer: controller #", ! 497: c_info->bs/1024); ! 498: return TRUE; ! 499: } ! 500: ! 501: ! 502: /* ! 503: ** Cyopen is called every time a process opens the tape for reading ! 504: ** or writting. Tape drives are single access in that only one process ! 505: ** can have the drive open at any one time. It is responsibility of ! 506: ** cyopen to keep track of whether the drive is already open and to ! 507: ** refuse access to everybody else on the system. ! 508: ** ! 509: ** The other functions of cyopen are to make sure a tape is mounted ! 510: ** and the drive is on-line, If the drive is currently rewinding we ! 511: ** should wait for it to complete before returning, if the drive is ! 512: ** at load point then our internal file pointers are reset, and to ! 513: ** set up a proto-type control word for use during later tape operations. ! 514: ** ! 515: ** The control proto-type is set up in open to save time later on. ! 516: ** It contains all the invariant information the controller needs to ! 517: ** access a drive. This information includes the unpacked unit number, ! 518: ** (See the UNIT macro below), the drive speed/density (always set at the ! 519: ** drive), the buss width (always 16 bit) and the interupts emnable bit ! 520: ** (always enabled). ! 521: */ ! 522: ! 523: /* macro to pack the unit number into Tapemaster format */ ! 524: #define UNIT(d) (((cydinfo[CYUNIT(d)]->ui_slave & 1) << 11) | \ ! 525: ((cydinfo[CYUNIT(d)]->ui_slave & 2) << 9) | \ ! 526: ((cydinfo[CYUNIT(d)]->ui_slave & 4) >> 2)) ! 527: ! 528: cyopen(dev, flag) ! 529: register int flag; ! 530: register dev_t dev; ! 531: { ! 532: register int status, unit = CYUNIT(dev); ! 533: register unit_tab *u_info = &unit_info[unit]; ! 534: ! 535: if (!(status = cyvalid_drive(unit))) { ! 536: u_info->control_proto = UNIT(dev) | CW_INTR | CW_16bits; ! 537: u_info->blkno = 0; ! 538: u_info->bad_count = 0; ! 539: u_info->eof = FALSE; ! 540: u_info->open = TRUE; ! 541: if(status = cy_open_error(dev,flag)) ! 542: u_info->open = FALSE; ! 543: } ! 544: return status; ! 545: } ! 546: ! 547: ! 548: /* ! 549: ** cyvalid_drive is called to make sure a drive is attached to ! 550: ** to the system and, if it is, if it is already open by another process. ! 551: ** If the drive is already open busy status is returned, if it is not ! 552: ** attached to the system then non-existant device is returned, otherwise, ! 553: ** zero is returned to indicate no error. ! 554: */ ! 555: ! 556: cyvalid_drive(unit) ! 557: register int unit; ! 558: { ! 559: /* if unit is less than maximum possible unit */ ! 560: if (unit < NUM_UNIT) ! 561: /* if the drive is attached */ ! 562: if (cydinfo[unit]) ! 563: /* if drive is not already open */ ! 564: if(!unit_info[unit].open) ! 565: return NOERROR; ! 566: else ! 567: return EBUSY; ! 568: return ENXIO; ! 569: } ! 570: ! 571: ! 572: /* ! 573: ** Cy_open_error is called by open after verifing that the drive ! 574: ** is eligable to be opened. The hardware status is checked and if ! 575: ** any errors are found (i.e. not online, write protected when opened for ! 576: ** writes, and opening past the end of tape marker) then the error number ! 577: ** is returned. ! 578: ** ! 579: ** As part of the sequence we must wait around if the drive is online ! 580: ** and rewinding until the rewind is done or the operator takes the drive ! 581: ** offline. During the wait we poll the drive every 5 seconds until ! 582: ** either of the above conditions are met. ! 583: */ ! 584: ! 585: cy_open_error(dev,flag) ! 586: register int flag; ! 587: register dev_t dev; ! 588: { ! 589: register int unit = CYUNIT(dev); ! 590: register unit_tab *u_info = &unit_info[CYUNIT(unit)]; ! 591: register ctlr_tab *c_info = &ctlr_info[cydinfo[unit]->ui_ctlr]; ! 592: ! 593: cycmd(dev, DO_WAIT, 1); ! 594: if(!(u_info->last_status & CS_OL)) ! 595: return ENXIO; ! 596: if((flag & FWRITE) && (u_info->last_status & CS_P)) { ! 597: uprintf("cy%d: Tape is write protected!\n", unit); ! 598: return ENXIO; ! 599: } ! 600: if(u_info->last_status & CS_LP) { ! 601: u_info->file_number = 0; ! 602: u_info->bot = TRUE; ! 603: u_info->eof = u_info->eot = FALSE; ! 604: } ! 605: return NOERROR; ! 606: } ! 607: ! 608: ! 609: /* ! 610: ** Cyclose is called every time a process closes a tape file, exits, ! 611: ** or is otherwise removed for the run queue. We take this oportunity to ! 612: ** mark the drive closed, write end of volume records (two tape marks), and ! 613: ** rewind the tape (if requested that we do so). ! 614: ** ! 615: ** Take note that we write the end of volume records by spacing backwards. ! 616: ** This is done because the all the commands keep track of the necessary ! 617: ** special cases. It just so happens that spacing back after a write will ! 618: ** generate an end of volume record before spacing back. After the space back ! 619: ** is called we space forward to position ourselfs between the two filemarks ! 620: ** in anticipation of further writes to tape. ! 621: ** ! 622: ** Also, the rewind logic takes care of end of volume records so if ! 623: ** we just issue a overlapped rewind request if we were opened using ! 624: ** the rewinding special file. ! 625: */ ! 626: ! 627: cyclose(dev, flag) ! 628: register dev_t dev; ! 629: register flag; ! 630: { ! 631: register int unit = CYUNIT(dev); ! 632: register unit_tab *u_info = &unit_info[unit]; ! 633: ! 634: if(u_info->last_status & CS_OL) ! 635: if((flag & FWRITE) && (minor(dev) & T_NOREWIND)) ! 636: cycmd(dev, DO_WEOV, 1); ! 637: else if(!(minor(dev) & T_NOREWIND)) ! 638: cycmd(dev, DO_RWOV, 1); ! 639: if(u_info->bad_count != 0) { ! 640: u_info->bad_count *= 889; ! 641: uprintf("cy%d: Warning - %d.%dcm of tape were used for recovering bad spots.\n", unit, u_info->bad_count/100, u_info->bad_count%100); ! 642: u_info->bad_count = 0; ! 643: } ! 644: u_info->open = 0; ! 645: } ! 646: ! 647: ! 648: /* ! 649: ** Cycmd is used intrernally to implement all the ioctl functions ! 650: ** that are needed by the driver. We duplicate the code in physio ! 651: ** that is used for syncronizing the processes (sleep / wakeup) so ! 652: ** that we can treat our internal command requests exactly like ! 653: ** regular reads and writes. They get put on the controller queue, ! 654: ** start processes them and iodone is called to wake us up on completion. ! 655: ** ! 656: ** We don't call physio directly because it expects data to be moved ! 657: ** and has a lot more overhead than we really need. ! 658: */ ! 659: ! 660: cycmd(dev, command, count) ! 661: register dev_t dev; ! 662: register long command; ! 663: register int count; ! 664: { ! 665: register int unit = CYUNIT(dev); ! 666: register unit_tab *u_info = &unit_info[unit]; ! 667: register unsigned short error; ! 668: register int priority = spl3(); ! 669: ! 670: while (u_info->rawbp.b_flags & B_BUSY) { ! 671: u_info->rawbp.b_flags |= B_WANTED; ! 672: sleep(&u_info->rawbp, PRIBIO+1); ! 673: } ! 674: splx(priority); ! 675: ! 676: /* load the request queue element */ ! 677: u_info->rawbp.b_error = 0; ! 678: u_info->rawbp.b_dev = dev; ! 679: u_info->rawbp.b_cmd = (struct buf *)command; ! 680: u_info->rawbp.b_bcount = count; ! 681: u_info->rawbp.b_flags = B_PHYS | B_BUSY; ! 682: queue_request(&u_info->rawbp, &u_info->u_queue, cydinfo[unit]->ui_mi); ! 683: ! 684: /* wait for operation to complete */ ! 685: while(!(u_info->rawbp.b_flags & B_DONE)) ! 686: sleep(&u_info->rawbp, PRIBIO); ! 687: u_info->rawbp.b_flags &= ~(B_PHYS | B_BUSY); ! 688: if(u_info->rawbp.b_flags & B_WANTED) ! 689: wakeup (&u_info->rawbp); ! 690: return geterror(&u_info->rawbp); ! 691: } ! 692: ! 693: /* ! 694: ** Check the validity of the request and then place ! 695: ** the request on the controller's request queue if it is ok. ! 696: ** ! 697: ** Take note that the only validity check is the block size. ! 698: ** all other checking, such as, drive number, online, controller attached, ! 699: ** is done in the open routine. ! 700: ** ! 701: ** If the drive dropped offline this will be notced int the ! 702: ** start / interupt routine (depending on when it dropped offline). ! 703: */ ! 704: ! 705: cystrategy(request) ! 706: register struct buf *request; ! 707: { ! 708: register int unit = CYUNIT(request->b_dev); ! 709: register unit_tab *u_info = &unit_info[unit]; ! 710: register struct buf *unit_queue; ! 711: ! 712: /* check the validity of the request */ ! 713: if (request->b_bcount <= MAX_BLOCKSIZE) { ! 714: /* place request on queue and start it if everything is ok */ ! 715: unit_queue = &u_info->u_queue; ! 716: buf_setup(request, MAX_BLOCKSIZE); ! 717: if(request->b_flags & B_PHYS) ! 718: if(request->b_flags & B_READ) ! 719: request->b_cmd = (struct buf *)DO_RRD; ! 720: else ! 721: request->b_cmd = (struct buf *)DO_RWT; ! 722: else ! 723: if(request->b_flags & B_READ) ! 724: request->b_cmd = (struct buf *)DO_BRD; ! 725: else { ! 726: request->b_cmd = (struct buf *)DO_BWT; ! 727: ! 728: } ! 729: queue_request(request, unit_queue, cydinfo[unit]->ui_mi); ! 730: return; ! 731: } ! 732: uprintf("cy%d: Maximum block size is %dk!\n", unit, MAX_BLOCKSIZE/1024); ! 733: request->b_error = EIO; ! 734: request->b_resid = request->b_bcount; ! 735: request->b_flags |= B_ERROR; ! 736: iodone(request); ! 737: } ! 738: ! 739: ! 740: /* ! 741: ** The routines below are used to handle a unit's request queue. ! 742: ** The queue is a linked list of buf structures. The linkage is as follows: ! 743: ** ! 744: ** +------------------------------------------------+ ! 745: ** | v ! 746: ** | +-----------+ +-----------+ +-----------+ ! 747: ** | | av_forw |------>| av_forw |--~ ~-->| av_forw |-->NULL ! 748: ** | +-----------+ +-----------+ +-----------+ ! 749: ** +-| av_back | | ......... | | ......... | ! 750: ** +-----------+ +-----------+ +-----------+ ! 751: ** | ......... | First queue Last queue ! 752: ** +-----------+ element element ! 753: ** head of unit queue ! 754: ** (unit_tab[unit].queue) ! 755: */ ! 756: ! 757: /* ! 758: ** Queue_request places a queue element on the end of a unit's ! 759: ** request queue. ! 760: */ ! 761: ! 762: queue_request(request, unit_queue, vba_ctlr_info) ! 763: register struct buf *request; ! 764: register struct buf *unit_queue; ! 765: struct vba_ctlr *vba_ctlr_info; ! 766: { ! 767: register int priority = spl3(); ! 768: ! 769: request->av_forw = NULL; ! 770: if (unit_queue->av_forw == NULL) ! 771: unit_queue->av_forw = request; ! 772: else ! 773: unit_queue->av_back->av_forw = request; ! 774: unit_queue->av_back = request; ! 775: cystart(vba_ctlr_info, request, priority); ! 776: } ! 777: ! 778: ! 779: /* ! 780: ** Dequeue_request removes the first element in a unit's request queue. ! 781: */ ! 782: ! 783: dequeue_request(unit_queue) ! 784: register struct buf *unit_queue; ! 785: { ! 786: register int priority = spl3(); ! 787: ! 788: if ((unit_queue->av_forw = unit_queue->av_forw->av_forw) == NULL) ! 789: unit_queue->av_back = NULL; ! 790: splx(priority); ! 791: } ! 792: ! 793: ! 794: /* ! 795: ** Cystart is called once for every request that is placed on a ! 796: ** controller's queue. Start is responsible for fetching requests for ! 797: ** a controller queue, starting the operation, and waiting for completion, ! 798: ** and releasing the buf structure back to UNIX or cycmd, before fetching ! 799: ** the next request. ! 800: ** ! 801: ** The controller's queue looks like this: ! 802: ** ! 803: ** +---------------------------------------+ ! 804: ** | | ! 805: ** +-----------+ | +-----------+ +-----------+ | ! 806: ** | b_forw |---+-->| b_forw |--~ ~-->| b_forw |--+ ! 807: ** +-----------+ +-----------+ +-----------+ ! 808: ** | b_back | | ......... | | ......... | ! 809: ** +-----------+ +-----------+ +-----------+ ! 810: ** | ......... | First unit queue Last unit queue ! 811: ** +-----------+ element element ! 812: ** head of controller queue ! 813: ** (cyminfo[ctlr].um_tab) ! 814: ** ! 815: ** To access the unit queues we simply get the controller's unit queue ! 816: ** pointer and if anything is on the unit queue that we are pointing to ! 817: ** we start that command, otherwise we get the next pointer and go on. ! 818: ** we know to stop looking when we have gone through the entire list ! 819: ** without starting any activity. We know we are at the end of the ! 820: ** queue when the next pointer equals the original pointer int the queue. ! 821: ** ! 822: ** To provind a fair scheduling policy we simply repoint the controller's ! 823: ** queue pointer to the next unit queue every time a command is started. ! 824: ** ! 825: ** If the controller is currently busy then we just return so that the ! 826: ** calling routine can go to sleep until we are finished processing the ! 827: ** request. ! 828: ** ! 829: ** Each buf structure has an index into a jump table loaded into ! 830: ** it by strategy or cycmd depending on where the buff originated. ! 831: ** this index is loaded so that start processing can continue without ! 832: ** much delay, and so that each operation can have it's unique requirements ! 833: ** satisfied in a clear and consistent manor. ! 834: ** ! 835: ** Each and every routine that is called by start is responsible for ! 836: ** proper tape positioning, writting end of file marks correctly, error ! 837: ** recovery, and whatever else may unique about the particular operation. ! 838: ** Each routine calls cyexecute whenever it actually wants to issue a ! 839: ** command to the controller. Each routine is also responsible for releasing ! 840: ** the request when is is done with it. ! 841: */ ! 842: ! 843: cystart(vba_ctlr_info, request, priority) ! 844: register struct vba_ctlr *vba_ctlr_info; ! 845: register struct buf *request; ! 846: { ! 847: struct buf *cyget_next(); ! 848: extern int cystart_timeout(); ! 849: register int unit = CYUNIT(request->b_dev); ! 850: register int ctlr = vba_ctlr_info->um_ctlr; ! 851: register struct buf *next, *ctlr_queue = &vba_ctlr_info->um_tab; ! 852: register unit_tab *u_info = &unit_info[unit]; ! 853: register ctlr_tab *c_info = &ctlr_info[ctlr]; ! 854: ! 855: if(ctlr_queue->b_active & SLEEPING) { ! 856: untimeout(cystart_timeout, ctlr_queue); ! 857: cystart_timeout(ctlr_queue); ! 858: } ! 859: if(ctlr_queue->b_active) { ! 860: sleep(request, PRIBIO-1); ! 861: if(request->b_flags & PROCESSED) { ! 862: if(u_info->message != NULL) { ! 863: uprintf("cy%d: %s!\n", unit, u_info->message); ! 864: u_info->message = NULL; ! 865: } ! 866: request->b_flags &= ~PROCESSED; ! 867: iodone(request); ! 868: return; ! 869: } ! 870: } ! 871: ctlr_queue->b_active = TRUE; ! 872: splx(priority); ! 873: c_info->my_request = request; ! 874: cydo_my_command(ctlr, ctlr_queue, c_info); ! 875: if(u_info->message != NULL) { ! 876: uprintf("cy%d: %s!\n", unit, u_info->message); ! 877: u_info->message = NULL; ! 878: } ! 879: request->b_flags &= ~PROCESSED; ! 880: iodone(request); ! 881: if((next = cyget_next(ctlr_queue)) != NULL) ! 882: wakeup(next); ! 883: else ! 884: ctlr_queue->b_active = FALSE; ! 885: } ! 886: ! 887: ! 888: /* ! 889: ** Cystart_timeout wakes up the start routine after it's 3 ! 890: ** second wait time is up or when a new command enters the queue. ! 891: ** ! 892: ** The timer is used to give up the processor while all drives ! 893: ** on the queue are rewinding and we need to wait for them to be dome. ! 894: ** Without this feature we would hog the processor polling for the drives ! 895: ** to be done. ! 896: */ ! 897: ! 898: cystart_timeout(ctlr_queue) ! 899: register struct buf *ctlr_queue; ! 900: { ! 901: ctlr_queue->b_active &= ~SLEEPING; ! 902: wakeup(ctlr_queue); ! 903: } ! 904: ! 905: ! 906: /* ! 907: ** Cydo_my command scans the request queues once for a ! 908: ** particular controller and calls the appropriate processing routine ! 909: ** each time we find a request that can be started. ! 910: ** ! 911: ** We return TRUE if a command is executed during this round. IF either ! 912: ** the queue is empty or all commands on the queue are waiting for the drives ! 913: ** to rewind we return FALSE. ! 914: */ ! 915: ! 916: cydo_my_command(ctlr, ctlr_queue, c_info) ! 917: register struct buf *ctlr_queue; ! 918: register ctlr_tab *c_info; ! 919: { ! 920: struct buf *cyget_next(); ! 921: register struct buf *unit_queue, *next; ! 922: ! 923: while((next = cyget_next(ctlr_queue)) != NULL) { ! 924: if(ctlr_queue->b_forw->b_active & SLEEPING) { ! 925: ctlr_queue->b_active |= SLEEPING; ! 926: timeout(cystart_timeout, ctlr_queue, 1*60); ! 927: sleep(ctlr_queue, PRIBIO); ! 928: continue; ! 929: } ! 930: if(setjmp(&ctlr_info[ctlr].environ)) ! 931: cydone(ctlr_queue); ! 932: else { ! 933: register int cmd=(int)(next->b_cmd); ! 934: ! 935: (*cmd_tbl[cmd])(next, ctlr_queue); ! 936: } ! 937: if(next->b_flags & PROCESSED) ! 938: if(c_info->my_request != next) ! 939: wakeup(next); ! 940: else ! 941: return; ! 942: } ! 943: } ! 944: ! 945: ! 946: struct buf *cyget_next(ctlr_queue) ! 947: register struct buf *ctlr_queue; ! 948: { ! 949: register struct buf *request, *unit_queue, *next = NULL; ! 950: ! 951: ctlr_queue->b_forw = ctlr_queue->b_forw->b_forw; ! 952: unit_queue = ctlr_queue->b_forw; ! 953: do { ! 954: if((request = unit_queue->av_forw) != NULL) ! 955: if(!(unit_queue->b_active & SLEEPING)) { ! 956: ctlr_queue->b_forw = unit_queue; ! 957: return request; ! 958: } ! 959: else ! 960: next = unit_queue; ! 961: unit_queue = unit_queue->b_forw; ! 962: } while(unit_queue != ctlr_queue->b_forw); ! 963: if(next != NULL) { ! 964: ctlr_queue->b_forw = next; ! 965: return next->av_forw; ! 966: } ! 967: return NULL; ! 968: } ! 969: ! 970: ! 971: /* ! 972: ** Cydone is called by each routine that is thorugh processing a ! 973: ** user request. It removes the request from our queues, counts down ! 974: ** the number of active requests that we have in our queues and releases ! 975: ** the request back to UNIX. ! 976: */ ! 977: ! 978: cydone(ctlr_queue) ! 979: register struct buf *ctlr_queue; ! 980: { ! 981: register struct buf *unit_queue = ctlr_queue->b_forw; ! 982: register struct buf *request = unit_queue->av_forw; ! 983: register int unit = CYUNIT(request->b_dev); ! 984: register ctlr_tab *c_info = &ctlr_info[cydinfo[unit]->ui_ctlr]; ! 985: ! 986: unit_queue->av_forw->b_flags |= PROCESSED; ! 987: dequeue_request(unit_queue); ! 988: } ! 989: ! 990: ! 991: /* ! 992: ** All the routines between here and Cyintr are used to process the ! 993: ** individual commands (read, write, rewind, ...) that can possibly be ! 994: ** generated by the system. ! 995: ** ! 996: ** Each command is responsible for a few things. 1) Each has to keep ! 997: ** track of special cases that are related to the individual command and ! 998: ** the previous commands sequence, 2) each is required to call iodone when ! 999: ** command is actually finished, 3) it must use cyexecute to actually ! 1000: ** start the controller, and 4) they are required to keep the tape in ! 1001: ** a consistant state so that other commands will not be messed up. ! 1002: /* ! 1003: */ ! 1004: ! 1005: /* ! 1006: ** cyraw_read handles the read requests from the raw device (cyread). ! 1007: ** ! 1008: ** The special cases are: ! 1009: ** 1) we can not read after a write. (writting defines end of file) ! 1010: ** 2) reading past end of file returns 0 bytes; ! 1011: */ ! 1012: ! 1013: cyraw_read(request, ctlr_queue) ! 1014: register struct buf *request; ! 1015: register struct buf *ctlr_queue; ! 1016: { ! 1017: register int unit = CYUNIT(request->b_dev); ! 1018: register unit_tab *u_info = &unit_info[CYUNIT(unit)]; ! 1019: register int ctlr = cydinfo[unit]->ui_ctlr; ! 1020: register ctlr_tab *c_info = &ctlr_info[ctlr]; ! 1021: register int addr, lock_flag, command; ! 1022: ! 1023: if((u_info->cleanup != cyno_op) || u_info->eof) { ! 1024: request->b_resid = request->b_bcount; ! 1025: request->b_error = ENXIO, request->b_flags |= B_ERROR; ! 1026: cydone(ctlr_queue); ! 1027: return; ! 1028: } ! 1029: if(request->b_bcount > c_info->bs) ! 1030: command = READ_TA, lock_flag = CW_LOCK; ! 1031: else ! 1032: command = READ_BU, lock_flag = 0; ! 1033: u_info->blkno++; ! 1034: addr = get_ioadr(request,c_info->rawbuf,c_info->map,c_info->utl); ! 1035: cyexecute(command, request->b_bcount, addr, lock_flag, unit, 10, FALSE); ! 1036: end_transfer(request, c_info->rawbuf, c_info->map, c_info->utl); ! 1037: cydone(ctlr_queue); ! 1038: } ! 1039: ! 1040: ! 1041: /* ! 1042: ** cyraw_write handles the write requests from the raw device. ! 1043: ** ! 1044: ** The special cases are: ! 1045: ** 1) we don't allow writes after end of tape is reached. ! 1046: */ ! 1047: ! 1048: cyraw_write(request, ctlr_queue) ! 1049: register struct buf *request; ! 1050: register struct buf *ctlr_queue; ! 1051: { ! 1052: register int unit = CYUNIT(request->b_dev); ! 1053: register unit_tab *u_info = &unit_info[CYUNIT(unit)]; ! 1054: register int ctlr = cydinfo[unit]->ui_ctlr; ! 1055: register ctlr_tab *c_info = &ctlr_info[ctlr]; ! 1056: register int addr, lock_flag, command; ! 1057: ! 1058: if(u_info->eot) { ! 1059: request->b_resid = request->b_bcount; ! 1060: request->b_error = ENXIO, request->b_flags |= B_ERROR; ! 1061: longjmp(&c_info->environ); ! 1062: } ! 1063: u_info->cleanup = cywrite_2_fm; ! 1064: if(request->b_bcount > c_info->bs) ! 1065: command = WRIT_TA, lock_flag = CW_LOCK; ! 1066: else ! 1067: command = WRIT_BU, lock_flag = 0; ! 1068: u_info->blkno++; ! 1069: addr = get_ioadr(request,c_info->rawbuf,c_info->map,c_info->utl); ! 1070: cyexecute(command, request->b_bcount, addr, lock_flag, unit, 10, FALSE); ! 1071: end_transfer(request, c_info->rawbuf, c_info->map, c_info->utl); ! 1072: cydone(ctlr_queue); ! 1073: } ! 1074: ! 1075: ! 1076: /* ! 1077: ** cywrite_filemark processes the ioctl to write filemarks to tape. ! 1078: */ ! 1079: ! 1080: cywrite_filemark(request, ctlr_queue) ! 1081: register struct buf *request; ! 1082: register struct buf *ctlr_queue; ! 1083: { ! 1084: register int unit = CYUNIT(request->b_dev); ! 1085: register unit_tab *u_info = &unit_info[CYUNIT(unit)]; ! 1086: register int ctlr = cydinfo[unit]->ui_ctlr; ! 1087: register ctlr_tab *c_info = &ctlr_info[ctlr]; ! 1088: ! 1089: if(request->b_bcount) { ! 1090: request->b_bcount--; ! 1091: if(u_info->cleanup == cywrite_1_fm) ! 1092: u_info->cleanup = cywrite_0_fm; ! 1093: if((u_info->cleanup==cywrite_2_fm)||(u_info->cleanup==cyno_op)) ! 1094: u_info->cleanup = cywrite_1_fm; ! 1095: u_info->file_number++; ! 1096: u_info->eof = TRUE; ! 1097: u_info->blkno = 0; ! 1098: cyexecute(WRIT_FM, (short)1, 0, 0, unit, 10, FALSE); ! 1099: return; ! 1100: } ! 1101: cydone(ctlr_queue); ! 1102: } ! 1103: ! 1104: ! 1105: /* ! 1106: ** cysearch_fm_forw is the ioctl to search for a filemark in the ! 1107: ** forward direction on tape. ! 1108: ** ! 1109: ** Since only one device can be active on a given controller at any ! 1110: ** given instant in time, we try to be nice and let onther devices on ! 1111: ** this controller be scheduled after we space over each record. This will ! 1112: ** at least give the apperance of overlapped operations on the controller. ! 1113: ** ! 1114: ** The special cases are: ! 1115: ** 1) if the last command was a write the we can't search. ! 1116: */ ! 1117: ! 1118: cysearch_fm_forw(request, ctlr_queue) ! 1119: register struct buf *request; ! 1120: register struct buf *ctlr_queue; ! 1121: { ! 1122: register int unit = CYUNIT(request->b_dev); ! 1123: register unit_tab *u_info = &unit_info[CYUNIT(unit)]; ! 1124: register int ctlr = cydinfo[unit]->ui_ctlr; ! 1125: register ctlr_tab *c_info = &ctlr_info[ctlr]; ! 1126: ! 1127: if((u_info->cleanup != cyno_op) || u_info->eot) { ! 1128: request->b_resid = request->b_bcount; ! 1129: request->b_error = ENXIO, request->b_flags |= B_ERROR; ! 1130: longjmp(&c_info->environ); ! 1131: } ! 1132: if(request->b_bcount && !u_info->eot) { ! 1133: if(!u_info->eot) { ! 1134: u_info->blkno++; ! 1135: cyexecute(SPAC_FM, 1, 0, 0, unit, 5, FALSE); ! 1136: if(!(u_info->eof || u_info->eot)) ! 1137: return; ! 1138: } ! 1139: request->b_bcount--; ! 1140: u_info->eof = FALSE; ! 1141: if(!u_info->eot) { ! 1142: u_info->file_number++; ! 1143: u_info->blkno = 0; ! 1144: return; ! 1145: } ! 1146: } ! 1147: if(u_info->eot) { ! 1148: request->b_resid = request->b_bcount; ! 1149: request->b_flags |= B_ERROR, request->b_error = ENXIO; ! 1150: } ! 1151: cydone(ctlr_queue); ! 1152: } ! 1153: ! 1154: ! 1155: /* ! 1156: ** cysearch_fm_back is the ioctl to search for a filemark in the ! 1157: ** reverse direction on tape. ! 1158: ** ! 1159: ** Since only one device can be active on a given controller at any ! 1160: ** given instant in time, we try to be nice and let onther devices on ! 1161: ** this controller be scheduled after we space over each record. This will ! 1162: ** at least give the apperance of overlapped operations on the controller. ! 1163: ** ! 1164: ** The special cases are: ! 1165: ** 1) can't search past begining of tape. ! 1166: ** 2) if the lasr operation was a write data then we need to add ! 1167: ** an end of volume record before we start searching. ! 1168: */ ! 1169: ! 1170: cysearch_fm_back(request, ctlr_queue) ! 1171: register struct buf *request; ! 1172: register struct buf *ctlr_queue; ! 1173: { ! 1174: register int unit = CYUNIT(request->b_dev); ! 1175: register unit_tab *u_info = &unit_info[CYUNIT(unit)]; ! 1176: register int ctlr = cydinfo[unit]->ui_ctlr; ! 1177: register ctlr_tab *c_info = &ctlr_info[ctlr]; ! 1178: ! 1179: if(!u_info->bot) { ! 1180: (*u_info->cleanup)(unit, MAINTAIN_POSITION); ! 1181: if(u_info->blkno == 0) ! 1182: request->b_bcount++; ! 1183: u_info->blkno = 0xffffffff; ! 1184: if(request->b_bcount && !u_info->bot) { ! 1185: cyexecute(SPAC_FM, 1, 0, CW_REV, unit, 6, FALSE); ! 1186: if(u_info->eof) { ! 1187: u_info->eof = FALSE; ! 1188: u_info->file_number--; ! 1189: request->b_bcount--; ! 1190: } ! 1191: return; ! 1192: } ! 1193: if(u_info->bot) { ! 1194: u_info->file_number = 0; ! 1195: if(request->b_bcount) { ! 1196: request->b_resid = request->b_bcount; ! 1197: request->b_error = ENXIO; ! 1198: request->b_flags |= B_ERROR; ! 1199: } ! 1200: } ! 1201: else { ! 1202: request->b_cmd = (struct buf *)DO_SFMF; ! 1203: request->b_bcount = 1; ! 1204: return; ! 1205: } ! 1206: } ! 1207: u_info->blkno = 0; ! 1208: u_info->eof = FALSE; ! 1209: cydone(ctlr_queue); ! 1210: } ! 1211: ! 1212: ! 1213: /* ! 1214: ** cy_space_forw is used to search forward a given number of records on ! 1215: ** tape. ! 1216: ** ! 1217: ** Since only one device can be active on a given controller at any ! 1218: ** given instant in time, we try to be nice and let onther devices on ! 1219: ** this controller be scheduled after we space over each record. This will ! 1220: ** at least give the apperance of overlapped operations on the controller. ! 1221: ** ! 1222: ** The special cases are: ! 1223: ** 1) we can't space over a filemark. ! 1224: ** 2) if the last command was a write data or filemark we can't space forward. ! 1225: */ ! 1226: ! 1227: cy_space_forw(request, ctlr_queue) ! 1228: register struct buf *request; ! 1229: register struct buf *ctlr_queue; ! 1230: { ! 1231: register int unit = CYUNIT(request->b_dev); ! 1232: register unit_tab *u_info = &unit_info[CYUNIT(unit)]; ! 1233: register int ctlr = cydinfo[unit]->ui_ctlr; ! 1234: register ctlr_tab *c_info = &ctlr_info[ctlr]; ! 1235: ! 1236: if((u_info->cleanup != cyno_op) || u_info->eof) { ! 1237: request->b_resid = request->b_bcount; ! 1238: request->b_error = ENXIO, request->b_flags |= B_ERROR; ! 1239: longjmp(&c_info->environ); ! 1240: } ! 1241: if(request->b_bcount) { ! 1242: u_info->blkno++; ! 1243: cyexecute(SPAC_FM, 1, 0, 0, unit, 10, FALSE); ! 1244: if(!u_info->eof && request->b_bcount) { ! 1245: request->b_bcount--; ! 1246: return; ! 1247: } ! 1248: } ! 1249: if(u_info->eof) { ! 1250: request->b_resid = request->b_bcount; ! 1251: request->b_error = ENXIO, request->b_flags |= B_ERROR; ! 1252: } ! 1253: cydone(ctlr_queue); ! 1254: } ! 1255: ! 1256: ! 1257: /* ! 1258: ** Cy_space_back spaces backward a given number of records. ! 1259: ** ! 1260: ** Since only one device can be active on a given controller at any ! 1261: ** given instant in time, we try to be nice and let onther devices on ! 1262: ** this controller be scheduled after we space over each record. This will ! 1263: ** at least give the apperance of overlapped operations on the controller. ! 1264: ** ! 1265: ** The special cases are: ! 1266: ** 1) we can't space over a filemark. ! 1267: ** 2) we can't space past the beginning of tape. ! 1268: ** 3) if the last operation was a write data then we need to add ! 1269: ** an end of volume record before we start searching. ! 1270: */ ! 1271: ! 1272: cy_space_back(request, ctlr_queue) ! 1273: register struct buf *request; ! 1274: register struct buf *ctlr_queue; ! 1275: { ! 1276: register int unit = CYUNIT(request->b_dev); ! 1277: register unit_tab *u_info = &unit_info[CYUNIT(unit)]; ! 1278: register int ctlr = cydinfo[unit]->ui_ctlr; ! 1279: register ctlr_tab *c_info = &ctlr_info[ctlr]; ! 1280: ! 1281: if(!u_info->bot) { ! 1282: (*u_info->cleanup)(unit, MAINTAIN_POSITION); ! 1283: if(request->b_bcount+1 && !u_info->bot && !u_info->eof) { ! 1284: request->b_bcount--; ! 1285: u_info->blkno--; ! 1286: cyexecute(SPACE, 1, 0, CW_REV, unit, 15, FALSE); ! 1287: return; ! 1288: } ! 1289: if(!u_info->bot) { ! 1290: request->b_bcount = 1; ! 1291: cy_space_forw(request); ! 1292: } ! 1293: u_info->eof = FALSE; ! 1294: } ! 1295: cydone(ctlr_queue); ! 1296: } ! 1297: ! 1298: ! 1299: /* ! 1300: ** cyrewind_tape_ta does a waiting rewind to of the tape. ! 1301: ** ! 1302: ** An overlapped rewind is issued and then we change the command type to ! 1303: ** a wait for ready ioctl. Wait for ready contains the logic to poll ! 1304: ** without blocking anything in the system, until the drive becomes ready or ! 1305: ** drops off line whichever comes first. ! 1306: */ ! 1307: ! 1308: cyrewind_tape_ta(request, ctlr_queue) ! 1309: register struct buf *request; ! 1310: register struct buf *ctlr_queue; ! 1311: { ! 1312: cyrewind_tape(request, REWD_OV); ! 1313: request->b_cmd = (struct buf *)DO_WAIT; ! 1314: } ! 1315: ! 1316: ! 1317: /* ! 1318: ** cyrewind_tape_unl does an overlapped rewind and then unloads the ! 1319: ** tape after the tape completes the rewind. This feature is handled by ! 1320: ** the individual tape drive and in some cases can not unload a tape. In ! 1321: ** this case it acts exactly like an overlapped rewind. ! 1322: */ ! 1323: ! 1324: cyrewind_tape_unl(request, ctlr_queue) ! 1325: register struct buf *request; ! 1326: register struct buf *ctlr_queue; ! 1327: { ! 1328: cyrewind_tape(request, OFF_UNL); ! 1329: cydone(ctlr_queue); ! 1330: } ! 1331: ! 1332: ! 1333: /* ! 1334: ** cyrewind_tape_ov is used to do overlapped rewinds on the system. ! 1335: ** Close is a classic example of where an overlapped rewind is needed. ! 1336: ** It would be stupid in that case to force the user to wait around ! 1337: ** (up to 5 minutes) until the tape has finished rewind. ! 1338: */ ! 1339: ! 1340: cyrewind_tape_ov(request, ctlr_queue) ! 1341: register struct buf *request; ! 1342: register struct buf *ctlr_queue; ! 1343: { ! 1344: cyrewind_tape(request, REWD_OV); ! 1345: cydone(ctlr_queue); ! 1346: } ! 1347: ! 1348: /* ! 1349: ** cyrewind tape is the common code for all rewind commands. ! 1350: ** ! 1351: ** The special cases are: ! 1352: ** 3) if the last operation was a write data then we need to add ! 1353: ** an end of volume record before we start searching. ! 1354: */ ! 1355: ! 1356: cyrewind_tape(request, command) ! 1357: register struct buf *request; ! 1358: long command; ! 1359: { ! 1360: register int unit = CYUNIT(request->b_dev); ! 1361: register unit_tab *u_info = &unit_info[CYUNIT(unit)]; ! 1362: register int ctlr = cydinfo[unit]->ui_ctlr; ! 1363: register ctlr_tab *c_info = &ctlr_info[ctlr]; ! 1364: register int time = (command == REWD_OV) ? 10 : 10*60; ! 1365: ! 1366: (*u_info->cleanup)(unit, DONT_MAINTAIN_POSITION); ! 1367: u_info->blkno = 0; ! 1368: u_info->eof = FALSE; ! 1369: u_info->bot = TRUE; ! 1370: u_info->eot = FALSE; ! 1371: u_info->file_number = 0; ! 1372: request->b_resid = 0; ! 1373: u_info->cleanup = cyno_op; ! 1374: cyexecute(command, 0, 0, 0, unit, time, FALSE); ! 1375: } ! 1376: ! 1377: ! 1378: /* ! 1379: ** Cywait_until_ready is used to wait for rewinds to complete. ! 1380: ** We check the status and if the tape is still rewinding we re-enter ourself ! 1381: ** on the activity queue to give other requests a chance to execute before we ! 1382: ** check the status again. One other thing is that we only want to check ! 1383: ** the status every five seconds. so we set a timer for five seconds and ! 1384: ** check the time left every time we enter this routine. If there is still ! 1385: ** time left then we simply reinsert ourself on the queue again and wait ! 1386: ** until next time .. ! 1387: */ ! 1388: ! 1389: ! 1390: cywait_until_ready(request, ctlr_queue) ! 1391: register struct buf *request; ! 1392: register struct buf *ctlr_queue; ! 1393: { ! 1394: extern int cywait_timeout(); ! 1395: register int unit = CYUNIT(request->b_dev); ! 1396: register int ctlr = cydinfo[unit]->ui_ctlr; ! 1397: register unit_tab *u_info = &unit_info[unit]; ! 1398: ! 1399: cyexecute(DRIVE_S, 0, 0, 0, unit, 10, FALSE); ! 1400: if((!(u_info->last_status & CS_OL)) || (u_info->last_status & CS_RDY)) { ! 1401: cydone(ctlr_queue); ! 1402: return; ! 1403: } ! 1404: ctlr_queue->b_forw->b_active |= SLEEPING; ! 1405: timeout(cywait_timeout, ctlr_queue->b_forw, 2*60); ! 1406: } ! 1407: ! 1408: ! 1409: /* ! 1410: ** cywait_timeout resets the timing flag for nice_wait after 3 seconds ! 1411: ** is up. This makes this drive eligible for scheduling again. ! 1412: */ ! 1413: ! 1414: cywait_timeout(unit_queue) ! 1415: struct buf *unit_queue; ! 1416: { ! 1417: unit_queue->b_active &= ~SLEEPING; ! 1418: } ! 1419: ! 1420: ! 1421: /* ! 1422: ** cydrive_status is used to process the status ioctl request. ! 1423: ** it depends entirly on the interupt routines to load the last_XXX ! 1424: ** registers in unit_info[]. ! 1425: */ ! 1426: ! 1427: cydrive_status(request, ctlr_queue) ! 1428: register struct buf *request; ! 1429: register struct buf *ctlr_queue; ! 1430: { ! 1431: register int unit = CYUNIT(request->b_dev); ! 1432: register unit_tab *u_info = &unit_info[CYUNIT(unit)]; ! 1433: register int ctlr = cydinfo[unit]->ui_ctlr; ! 1434: register ctlr_tab *c_info = &ctlr_info[ctlr]; ! 1435: ! 1436: cyexecute(DRIVE_S, 0, 0, 0, unit, 10, FALSE); ! 1437: cydone(ctlr_queue); ! 1438: } ! 1439: ! 1440: ! 1441: /* ! 1442: ** cybuf_read handles the read requests from the block device. ! 1443: ** ! 1444: ** The special cases are: ! 1445: ** 1) we can not read after a write. (writting defines end of file) ! 1446: ** 2) reading past end of file returns 0 bytes; ! 1447: ** 3) if we are mispositioned we have to seek to the correct block. ! 1448: ** 4) we can hit end of tape while seeking. ! 1449: ** 5) we want to be nice to other processes while seeking so we ! 1450: ** break the request up into smaller requests. ! 1451: ** 6) returns error if the block was larger than requested. ! 1452: */ ! 1453: ! 1454: cybuf_read(request, ctlr_queue) ! 1455: register struct buf *request; ! 1456: register struct buf *ctlr_queue; ! 1457: { ! 1458: register int unit = CYUNIT(request->b_dev); ! 1459: register unit_tab *u_info = &unit_info[CYUNIT(unit)]; ! 1460: register int ctlr = cydinfo[unit]->ui_ctlr; ! 1461: register ctlr_tab *c_info = &ctlr_info[ctlr]; ! 1462: register int addr, command, bus_lock; ! 1463: ! 1464: cydebug = 1; ! 1465: if(cyseek(request, ctlr_queue)) { ! 1466: if(u_info->cleanup != cyno_op) { ! 1467: clrbuf(request); ! 1468: longjmp(&c_info->environ); ! 1469: } ! 1470: if(request->b_bcount > c_info->bs) ! 1471: command = READ_TA, bus_lock = CW_LOCK; ! 1472: else ! 1473: command = READ_BU, bus_lock = 0; ! 1474: u_info->blkno++; ! 1475: addr=get_ioadr(request,c_info->rawbuf,c_info->map,c_info->utl); ! 1476: cyexecute(command,request->b_bcount,addr,bus_lock,unit,8,FALSE); ! 1477: end_transfer(request, c_info->rawbuf, c_info->map, c_info->utl); ! 1478: cydone(ctlr_queue); ! 1479: } ! 1480: } ! 1481: ! 1482: ! 1483: /* ! 1484: ** cybuf_write handles the write requests from the block device. ! 1485: ** ! 1486: ** The special cases are: ! 1487: ** 1) if we are mispositioned we have to seek to the correct block. ! 1488: ** 2) we can hit end of tape while seeking. ! 1489: ** 3) we want to be nice to other processes while seeking so we ! 1490: ** break the request up into smaller requests. ! 1491: ** 4) we don't allow writes after end of tape is reached. ! 1492: */ ! 1493: ! 1494: cybuf_write(request, ctlr_queue) ! 1495: register struct buf *request; ! 1496: register struct buf *ctlr_queue; ! 1497: { ! 1498: register int unit = CYUNIT(request->b_dev); ! 1499: register unit_tab *u_info = &unit_info[CYUNIT(unit)]; ! 1500: register int ctlr = cydinfo[unit]->ui_ctlr; ! 1501: register ctlr_tab *c_info = &ctlr_info[ctlr]; ! 1502: register int addr, command, bus_lock; ! 1503: ! 1504: if(u_info->eot && (request->b_blkno >= u_info->blkno)) { ! 1505: request->b_error = ENXIO, request->b_flags |= B_ERROR; ! 1506: request->b_resid = request->b_bcount; ! 1507: longjmp(&c_info->environ); ! 1508: } ! 1509: if(cyseek(request, ctlr_queue)) { ! 1510: u_info->cleanup = cywrite_2_fm; ! 1511: u_info->blkno++; ! 1512: if(request->b_bcount > c_info->bs) ! 1513: command = WRIT_TA, bus_lock |= CW_LOCK; ! 1514: else ! 1515: command = WRIT_BU, bus_lock = 0; ! 1516: addr=get_ioadr(request,c_info->rawbuf,c_info->map,c_info->utl); ! 1517: load_mbus_addr((char *)addr, &c_info->tpb.data_ptr); ! 1518: cyexecute(command,request->b_bcount,addr,bus_lock,unit,5,FALSE); ! 1519: end_transfer(request, c_info->rawbuf, c_info->map, c_info->utl); ! 1520: cydone(ctlr_queue); ! 1521: } ! 1522: } ! 1523: ! 1524: ! 1525: /* ! 1526: ** cyseek is used by the block device to position the tape correctly ! 1527: ** before each read or write request. ! 1528: ** ! 1529: ** The special cases are: ! 1530: ** 1) we can hit end of tape while seeking. ! 1531: ** 2) we want to be nice to other processes while seeking so we ! 1532: ** break the request up into smaller requests. ! 1533: */ ! 1534: ! 1535: cyseek(request, ctlr_queue) ! 1536: register struct buf *request; ! 1537: register struct buf *ctlr_queue; ! 1538: { ! 1539: register int unit = CYUNIT(request->b_dev); ! 1540: register unit_tab *u_info = &unit_info[CYUNIT(unit)]; ! 1541: register int ctlr = cydinfo[unit]->ui_ctlr; ! 1542: register ctlr_tab *c_info = &ctlr_info[ctlr]; ! 1543: ! 1544: if(request->b_blkno < u_info->blkno) { ! 1545: register int count; ! 1546: ! 1547: (*u_info->cleanup)(unit, MAINTAIN_POSITION); ! 1548: count = ((request->b_blkno+1) == u_info->blkno) ? 2 : 1; ! 1549: u_info->blkno -= count; ! 1550: cyexecute(SPAC_FM, 1, 0, CW_REV, unit, 10, FALSE); ! 1551: if(!u_info->eof) ! 1552: return FALSE; ! 1553: u_info->eof = FALSE; ! 1554: request->b_blkno = u_info->blkno + 1; ! 1555: } ! 1556: if(request->b_blkno > u_info->blkno) { ! 1557: if((u_info->cleanup != cyno_op) || u_info->eof || u_info->eot) { ! 1558: request->b_resid = request->b_bcount; ! 1559: request->b_error = ENXIO, request->b_flags |= B_ERROR; ! 1560: longjmp(&c_info->environ); ! 1561: } ! 1562: u_info->blkno++; ! 1563: cyexecute(SPAC_FM, 1, 0, 0, unit, 10, FALSE); ! 1564: return FALSE; ! 1565: } ! 1566: return TRUE; ! 1567: } ! 1568: ! 1569: ! 1570: /* ! 1571: */ ! 1572: ! 1573: cywrite_eov(request, ctlr_queue) ! 1574: register struct buf *request; ! 1575: register struct buf *ctlr_queue; ! 1576: { ! 1577: extern int cyno_op(); ! 1578: register int unit = CYUNIT(request->b_dev); ! 1579: register unit_tab *u_info = &unit_info[CYUNIT(unit)]; ! 1580: ! 1581: if(u_info->cleanup != cyno_op) { ! 1582: (*u_info->cleanup)(unit, DONT_MAINTAIN_POSITION); ! 1583: cyexecute(SPACE, 2, 0, CW_REV, unit, 10, FALSE); ! 1584: cyexecute(SPACE, 1, 0, 0, unit, 10, FALSE); ! 1585: unit_info[unit].cleanup = cyno_op; ! 1586: u_info->blkno = 0; ! 1587: } ! 1588: cydone(ctlr_queue); ! 1589: } ! 1590: ! 1591: ! 1592: /* ! 1593: ** Do nothing ! 1594: */ ! 1595: ! 1596: cyno_op(unit, action) ! 1597: int unit, action; ! 1598: { ! 1599: } ! 1600: ! 1601: ! 1602: /* ! 1603: ** Write 0 file marks to tape ! 1604: */ ! 1605: ! 1606: cywrite_0_fm(unit, action) ! 1607: int unit, action; ! 1608: { ! 1609: unit_info[unit].cleanup = cyno_op; ! 1610: } ! 1611: ! 1612: ! 1613: /* ! 1614: ** Write 1 file mark to tape ! 1615: */ ! 1616: ! 1617: cywrite_1_fm(unit, action) ! 1618: int unit, action; ! 1619: { ! 1620: cyexecute(WRIT_FM, 1, 0, 0, unit, 5, FALSE); ! 1621: if(action == MAINTAIN_POSITION) { ! 1622: cyexecute(SPACE, 2, 0, CW_REV, unit, 10, FALSE); ! 1623: cyexecute(SPACE, 1, 0, 0, unit, 10, FALSE); ! 1624: } ! 1625: unit_info[unit].cleanup = cyno_op; ! 1626: } ! 1627: ! 1628: ! 1629: /* ! 1630: ** Write 2 file marks to tape ! 1631: */ ! 1632: ! 1633: cywrite_2_fm(unit, action) ! 1634: int unit, action; ! 1635: { ! 1636: cyexecute(WRIT_FM, 1, 0, 0, unit, 5, FALSE); ! 1637: cyexecute(WRIT_FM, 1, 0, 0, unit, 5, FALSE); ! 1638: if(action == MAINTAIN_POSITION) { ! 1639: cyexecute(SPACE, 3, 0, CW_REV, unit, 10, FALSE); ! 1640: cyexecute(SPACE, 1, 0, 0, unit, 2, FALSE); ! 1641: } ! 1642: unit_info[unit].cleanup = cyno_op; ! 1643: } ! 1644: ! 1645: ! 1646: /* ! 1647: ** Cyexecute is used to start all commands to the controller. We ! 1648: ** do all common code here before starting. ! 1649: */ ! 1650: ! 1651: cyexecute(command, count, addr, control_flags, unit, time, interupt_routine) ! 1652: register int command; ! 1653: int count, addr, control_flags, unit, time, interupt_routine; ! 1654: { ! 1655: extern int cytimeout(); ! 1656: extern int cy_normal_path(); ! 1657: register int priority; ! 1658: register int ctlr = cydinfo[unit]->ui_ctlr; ! 1659: register unit_tab *u_info = &unit_info[unit]; ! 1660: register ctlr_tab *c_info = &ctlr_info[ctlr]; ! 1661: register struct buf *request = u_info->u_queue.av_forw; ! 1662: ! 1663: c_info->tpb.cmd = command; ! 1664: c_info->tpb.control = u_info->control_proto | control_flags; ! 1665: c_info->tpb.status = c_info->tpb.count = (short)0; ! 1666: load_mbus_addr((char *)addr, &c_info->tpb.data_ptr); ! 1667: switch(command) { ! 1668: case READ_BU : ! 1669: case READ_TA : ! 1670: case WRIT_BU : ! 1671: case WRIT_TA : ! 1672: c_info->tpb.size = MULTIBUS_SHORT((short)count); ! 1673: c_info->tpb.rec_over = (short)0; ! 1674: break; ! 1675: default: ! 1676: c_info->tpb.size = (short)0; ! 1677: c_info->tpb.rec_over = MULTIBUS_SHORT((short)count); ! 1678: break; ! 1679: } ! 1680: load_mbus_addr((char *)0, c_info->tpb.link_ptr); ! 1681: if(!interupt_routine) ! 1682: c_info->last = c_info->tpb; ! 1683: /* ! 1684: gag! but it the last possible moment to wait ! 1685: for this controller to get out of it's own way..... ! 1686: */ ! 1687: uncache(&c_info->ccb.gate); ! 1688: while(c_info->ccb.gate == GATE_CLOSED) ! 1689: uncache(&c_info->ccb.gate); ! 1690: load_mbus_addr(&c_info->tpb, c_info->ccb.tpb_ptr); ! 1691: c_info->ccb.ccw = NORMAL_INTERUPT; ! 1692: c_info->ccb.gate = GATE_CLOSED; ! 1693: if(!interupt_routine) ! 1694: c_info->interupt_path = cy_normal_path; ! 1695: timeout(cytimeout, ctlr, time*60); ! 1696: priority = spl3(); ! 1697: CY_ATTENTION(cyminfo[ctlr]->um_addr); ! 1698: if(!interupt_routine) { ! 1699: sleep(c_info, PRIBIO+3); ! 1700: splx(priority); ! 1701: if(request->b_flags & B_ERROR) { ! 1702: if((command == READ_BU) || (command == READ_TA) || ! 1703: (command == WRIT_BU) || (command == WRIT_TA)) ! 1704: end_transfer(request, c_info->rawbuf, ! 1705: c_info->map,c_info->utl); ! 1706: longjmp(&c_info->environ); ! 1707: } ! 1708: return; ! 1709: } ! 1710: splx(priority); ! 1711: } ! 1712: ! 1713: ! 1714: /* ! 1715: ** cytimeout is the interupt timeout routine. We assume that a ! 1716: ** particular command has gone astray, so we completely reset the controller, ! 1717: ** and call the interupt routine to help us clean up. Before the interupt ! 1718: ** routine is called we jam a controller timeout value in the status register ! 1719: ** to fake out the calling routines. ! 1720: */ ! 1721: ! 1722: cytimeout(ctlr) ! 1723: register int ctlr; ! 1724: { ! 1725: register int priority = spl3(); ! 1726: register char *ctlr_vaddr = cyminfo[ctlr]->um_addr; ! 1727: register int tmp_stat; ! 1728: ! 1729: uncache(&ctlr_info[ctlr].tpb.status); ! 1730: tmp_stat = ctlr_info[ctlr].tpb.status; ! 1731: CY_RESET(ctlr_vaddr); ! 1732: cy_init_controller(ctlr_vaddr, ctlr, 0); ! 1733: splx(priority); ! 1734: ctlr_info[ctlr].tpb = ctlr_info[ctlr].last; ! 1735: ctlr_info[ctlr].tpb.status = (tmp_stat & ~CS_ERm) | CS_OL | ER_TIMOUT; ! 1736: cyintr(ctlr); ! 1737: } ! 1738: ! 1739: /* ! 1740: ** Cyintr is the interupt routine for the Tapemaster controller. ! 1741: ** ! 1742: ** Due to controller problems, the first thing we have to do is turn ! 1743: ** off the Tapemaster interupting mechanism. If we don't we will be flooded ! 1744: ** with bogus interupts and the system will spend all it's time processing ! 1745: ** them. To Turn the interupts off we issue a NOOP command with the 'turn ! 1746: ** off interupts' code in the ccb. ! 1747: ** ! 1748: ** take note that since this command TURNS OFF the interupts it ! 1749: ** itself CANNOT interupt... This means that polling must be done ! 1750: ** at sometime to make sure that tis command is completed. The polling ! 1751: ** is done before the next command is issued to reduce polling (halting ! 1752: ** UNIX) time. ! 1753: ** ! 1754: ** After we turn off interupts we uncache all the values in the tpb ! 1755: ** and call the correct processing routine. This routine can be for normal ! 1756: ** interupts or for interupts generated during a retry operation. ! 1757: */ ! 1758: ! 1759: cyintr(ctlr) ! 1760: register int ctlr; ! 1761: { ! 1762: extern int cytimeout(); ! 1763: register ctlr_tab *c_info = &ctlr_info[ctlr]; ! 1764: ! 1765: untimeout(cytimeout, ctlr); ! 1766: /* turn off interupts for the stupid controller */ ! 1767: c_info->ccb.ccw = CLEAR_INTERUPT; ! 1768: c_info->noop.cmd = NO_OP; ! 1769: c_info->noop.control = (short)0; ! 1770: load_mbus_addr(&c_info->noop, c_info->ccb.tpb_ptr); ! 1771: c_info->ccb.gate = GATE_CLOSED; ! 1772: CY_ATTENTION(cyminfo[ctlr]->um_addr); ! 1773: uncache_tpb(c_info); ! 1774: (*c_info->interupt_path)(ctlr); ! 1775: } ! 1776: ! 1777: ! 1778: /* ! 1779: ** This is the portion of the interupt routine that processes all ! 1780: ** normal cases i.e. non retry cases. We check the operations status ! 1781: ** if it is retryable we set the interupt path to the retry routines and ! 1782: ** start the backward spaceing. when the spacing is done the retry logic ! 1783: ** will be called and this routine will be skipped entirely. ! 1784: ** ! 1785: ** If the command is ok or not retryable we set the status accordingly ! 1786: ** and wakeup cyexecute to continue processing. ! 1787: */ ! 1788: ! 1789: cy_normal_path(ctlr) ! 1790: register int ctlr; ! 1791: { ! 1792: extern int cy_retry_path(); ! 1793: extern int cy_extended_gap_path(); ! 1794: register int error; ! 1795: register struct buf *ctlr_queue = &cyminfo[ctlr]->um_tab; ! 1796: register struct buf *unit_queue = ctlr_queue->b_forw; ! 1797: register struct buf *request = unit_queue->av_forw; ! 1798: register int unit = CYUNIT(request->b_dev); ! 1799: register unit_tab *u_info = &unit_info[unit]; ! 1800: register ctlr_tab *c_info = &ctlr_info[ctlr]; ! 1801: ! 1802: if (error = cydecode_error(unit, c_info->tpb.status)) { ! 1803: if(error != FATAL) { ! 1804: if (error == RETRY) ! 1805: c_info->interupt_path = cy_retry_path; ! 1806: else ! 1807: c_info->interupt_path = cy_extended_gap_path; ! 1808: cyexecute(SPACE, 2, 0, CW_REV, unit, 5, TRUE); ! 1809: return; ! 1810: } ! 1811: } ! 1812: request->b_resid=request->b_bcount-MULTIBUS_SHORT(c_info->tpb.count); ! 1813: u_info->error_count = 0; ! 1814: u_info->last_resid = request->b_resid; ! 1815: u_info->last_status = c_info->tpb.status; ! 1816: u_info->last_control = c_info->tpb.control; ! 1817: if (error == FATAL) ! 1818: request->b_flags |= B_ERROR, request->b_error = EIO; ! 1819: wakeup(c_info); ! 1820: } ! 1821: ! 1822: ! 1823: /* ! 1824: ** Cy_retry_path finishes up the retry sequence for the tape. ! 1825: ** If we were going in the reverse direction it means that we have to ! 1826: ** space forward to correctly position ourselfs in back of the tape gap ! 1827: ** instead of in front of it. If we were going forward it means that ! 1828: ** we are positioned correctly and we can actually restart the instruction ! 1829: ** that failed before. ! 1830: */ ! 1831: ! 1832: cy_retry_path(ctlr) ! 1833: register int ctlr; ! 1834: { ! 1835: extern int cy_do_again_path(); ! 1836: register struct buf *ctlr_queue = &cyminfo[ctlr]->um_tab; ! 1837: register struct buf *unit_queue = ctlr_queue->b_forw; ! 1838: register struct buf *request = unit_queue->av_forw; ! 1839: register int unit = CYUNIT(request->b_dev); ! 1840: register unit_tab *u_info = &unit_info[unit]; ! 1841: register ctlr_tab *c_info = &ctlr_info[ctlr]; ! 1842: ! 1843: if(!(c_info->tpb.status & CS_OL)) { ! 1844: c_info->interupt_path = cy_normal_path; ! 1845: cy_normal_path(ctlr); ! 1846: return; ! 1847: } ! 1848: if(c_info->tpb.control & CW_REV) { ! 1849: if(!(c_info->tpb.status & CS_LP)) { ! 1850: c_info->interupt_path = cy_do_again_path; ! 1851: cyexecute(SPACE, 1, 0, 0, unit, 5, TRUE); ! 1852: return; ! 1853: } ! 1854: cy_do_again_path(ctlr); ! 1855: } ! 1856: } ! 1857: ! 1858: ! 1859: /* ! 1860: ** ! 1861: */ ! 1862: ! 1863: cy_extended_gap_path(ctlr) ! 1864: register int ctlr; ! 1865: { ! 1866: extern int cy_do_again_path(); ! 1867: register ctlr_tab *c_info = &ctlr_info[ctlr]; ! 1868: register struct buf *ctlr_queue = &cyminfo[ctlr]->um_tab; ! 1869: register struct buf *unit_queue = ctlr_queue->b_forw; ! 1870: register struct buf *request = unit_queue->av_forw; ! 1871: register int unit = CYUNIT(request->b_dev); ! 1872: ! 1873: if(!(c_info->tpb.status & CS_OL)) { ! 1874: c_info->interupt_path = cy_normal_path; ! 1875: cy_normal_path(ctlr); ! 1876: return; ! 1877: } ! 1878: if(c_info->tpb.control & CW_REV) { ! 1879: if(!(c_info->tpb.status & CS_LP)) { ! 1880: cyexecute(SPACE, 1, 0, 0, unit, 5, TRUE); ! 1881: return; ! 1882: } ! 1883: } ! 1884: c_info->interupt_path = cy_do_again_path; ! 1885: cyexecute(ERASE_F, unit_info[unit].error_count, 0, 0, unit, 5, TRUE); ! 1886: } ! 1887: ! 1888: ! 1889: /* ! 1890: ** ! 1891: */ ! 1892: ! 1893: cy_do_again_path(ctlr) ! 1894: register int ctlr; ! 1895: { ! 1896: extern int cy_normal_path(); ! 1897: register ctlr_tab *c_info = &ctlr_info[ctlr]; ! 1898: ! 1899: if(!(c_info->tpb.status & CS_OL)) { ! 1900: c_info->interupt_path = cy_normal_path; ! 1901: cy_normal_path(ctlr); ! 1902: return; ! 1903: } ! 1904: c_info->tpb = c_info->last; ! 1905: uncache(&c_info->ccb.gate); ! 1906: while(c_info->ccb.gate == GATE_CLOSED) ! 1907: uncache(&c_info->ccb.gate); ! 1908: load_mbus_addr(&c_info->tpb, c_info->ccb.tpb_ptr); ! 1909: c_info->ccb.ccw = NORMAL_INTERUPT; ! 1910: c_info->ccb.gate = GATE_CLOSED; ! 1911: c_info->interupt_path = cy_normal_path; ! 1912: CY_ATTENTION(cyminfo[ctlr]->um_addr); ! 1913: } ! 1914: ! 1915: ! 1916: /* ! 1917: ** for each longword in the tpb we call uncache to purge it from ! 1918: ** the cache. This is done so that we can correctly access tpb data ! 1919: ** that was placed there by the controller. ! 1920: */ ! 1921: ! 1922: uncache_tpb(c_info) ! 1923: ctlr_tab *c_info; ! 1924: { ! 1925: register long *ptr = (long *)&c_info->tpb; ! 1926: register int i; ! 1927: ! 1928: for(i=0; i<((sizeof(fmt_tpb)+sizeof(long)-1)/sizeof(long)); i++) ! 1929: uncache(ptr++); ! 1930: } ! 1931: ! 1932: ! 1933: /* ! 1934: ** Cyprint_error is the common printing routine for all messages ! 1935: ** that need to print the tape status along with it. This is so we ! 1936: ** we can save space, have consistant messages, and we can send the messages ! 1937: ** to the correct places. ! 1938: */ ! 1939: ! 1940: cyprint_err(message, unit, status) ! 1941: register char *message; ! 1942: register int unit, status; ! 1943: { ! 1944: status &= 0xffff; ! 1945: printf("cy%d: %s! Status = %x\n", unit, message, status); ! 1946: } ! 1947: ! 1948: /* ! 1949: ** Decode the error to determine whether the previous command was ! 1950: ** ok, retryable, or fatal and return the value. If it was a hardware ! 1951: ** problem we print the message to the console, otherwise we print it ! 1952: ** to the user's terminal later when execute returns. ! 1953: */ ! 1954: ! 1955: cydecode_error(unit, status) ! 1956: register int unit, status; ! 1957: { ! 1958: register unit_tab *u_info = &unit_info[unit]; ! 1959: register ctlr_tab *c_info = &ctlr_info[cydinfo[unit]->ui_ctlr]; ! 1960: int ctlr = cydinfo[unit]->ui_ctlr; ! 1961: ! 1962: if(!(status & CS_OL) && (c_info->tpb.cmd != OFF_UNL)) { ! 1963: u_info->message = "Drive is not on-line"; ! 1964: cyprint_err(u_info->message, unit, status); ! 1965: return FATAL; ! 1966: } ! 1967: u_info->bot = ((status & CS_LP) != 0); ! 1968: u_info->eof = ((status & CS_FM) != 0); ! 1969: switch(status & CS_ERm) { ! 1970: case ER_EOT: ! 1971: if(c_info->tpb.control & CW_REV) { ! 1972: u_info->bot = TRUE; ! 1973: u_info->eot = FALSE; ! 1974: } ! 1975: else if(!u_info->eot){ ! 1976: u_info->message = "End of tape"; ! 1977: u_info->bot = FALSE; ! 1978: u_info->eot = TRUE; ! 1979: } ! 1980: case 0 : ! 1981: case ER_FM: ! 1982: case ER_NOSTRM: ! 1983: return NOERROR; ! 1984: case ER_TIMOUT: ! 1985: case ER_TIMOUT1: ! 1986: case ER_TIMOUT2: ! 1987: case ER_TIMOUT3: ! 1988: case ER_TIMOUT4: ! 1989: u_info->message = "Drive timed out during transfer"; ! 1990: cyprint_err(u_info->message, unit, status); ! 1991: return FATAL; ! 1992: case ER_NEX: ! 1993: u_info->message = ! 1994: "Controller referenced non-existant system memory"; ! 1995: cyprint_err(u_info->message, unit, status); ! 1996: return FATAL; ! 1997: case ER_DIAG: ! 1998: case ER_JUMPER: ! 1999: u_info->message = "Controller diagnostics failed"; ! 2000: cyprint_err(u_info->message, unit, status); ! 2001: return FATAL; ! 2002: case ER_STROBE: ! 2003: if (c_info->tpb.cmd == READ_BU) { ! 2004: c_info->last.cmd = READ_TA; ! 2005: return RETRY; ! 2006: } ! 2007: if(c_info->tpb.cmd == READ_TA) ! 2008: return NOERROR; ! 2009: u_info->message = "Unsatisfactory media found"; ! 2010: return FATAL; ! 2011: case ER_FIFO: ! 2012: case ER_NOTRDY: ! 2013: u_info->error_count = 1; ! 2014: return RETRY; ! 2015: case ER_PROT: ! 2016: u_info->message = "Tape is write protected"; ! 2017: return FATAL; ! 2018: case ER_CHKSUM: ! 2019: u_info->message = "Checksum error in controller proms"; ! 2020: cyprint_err(u_info->message, unit, status); ! 2021: return FATAL; ! 2022: case ER_HARD: ! 2023: u_info->error_count++; ! 2024: if((c_info->tpb.cmd == WRIT_TA) || ! 2025: (c_info->tpb.cmd == WRIT_BU) || ! 2026: (c_info->tpb.cmd == WRIT_FM)) { ! 2027: u_info->bad_count++; ! 2028: return EXTEND; ! 2029: } ! 2030: u_info->message = "Unrecoverable media error during read"; ! 2031: return FATAL; ! 2032: case ER_PARITY: ! 2033: if(++u_info->error_count < 8) ! 2034: return RETRY; ! 2035: u_info->message = "Unrecoverable tape parity error"; ! 2036: return FATAL; ! 2037: case ER_BLANK: ! 2038: u_info->message="Blank tape found (data expected)"; ! 2039: return FATAL; ! 2040: case ER_HDWERR: ! 2041: default: ! 2042: u_info->message = "Unrecoverble hardware error"; ! 2043: cyprint_err(u_info->message, unit, status); ! 2044: return FATAL; ! 2045: } ! 2046: } ! 2047: ! 2048: ! 2049: /* ! 2050: ** Raw read interface to unix. Since all the checking is done at a ! 2051: ** lower level we don't check anything here and we simply return the results. ! 2052: */ ! 2053: ! 2054: cyread(dev, uio) ! 2055: register dev_t dev; ! 2056: register struct uio *uio; ! 2057: { ! 2058: register int unit = CYUNIT(dev); ! 2059: register unit_tab *u_info = &unit_info[unit]; ! 2060: ! 2061: return physio(cystrategy, &u_info->rawbp, dev, B_READ, cyminsize, uio); ! 2062: } ! 2063: ! 2064: ! 2065: /* ! 2066: ** Raw write interface to unix. Since all the checking is done at a ! 2067: ** lower level we don't check anything here and we simply return the results. ! 2068: */ ! 2069: ! 2070: cywrite(dev, uio) ! 2071: register dev_t dev; ! 2072: register struct uio *uio; ! 2073: { ! 2074: register int unit = CYUNIT(dev); ! 2075: register unit_tab *u_info = &unit_info[unit]; ! 2076: ! 2077: return physio(cystrategy,&u_info->rawbp, dev, B_WRITE, cyminsize, uio); ! 2078: } ! 2079: ! 2080: /* ! 2081: ** Cyioctl is called by UNIX every time an ioctl call is made by a user ! 2082: ** program. We don't really do much here except call cycmd to process the ! 2083: ** ioctl command. We don't decode the ioctl type here because our internal ! 2084: ** jump table accessed by start is ordered by the ioctl number passes here. ! 2085: ** ! 2086: ** The only special processing is in the status command. This is because ! 2087: ** we actually return various data to the user's program with only that ! 2088: ** command. ! 2089: */ ! 2090: ! 2091: cyioctl(dev, command, data, flag) ! 2092: register dev_t dev; ! 2093: register int command; ! 2094: register struct mtop *data; ! 2095: register int flag; ! 2096: { ! 2097: if(command == MTIOCTOP) ! 2098: if((unsigned)(data->mt_op <= DO_WAIT)) ! 2099: return cycmd(dev, data->mt_op, data->mt_count); ! 2100: else ! 2101: return EIO; ! 2102: else if(command == MTIOCGET) { ! 2103: register unit_tab *u_info = &unit_info[CYUNIT(dev)]; ! 2104: ! 2105: ((struct mtget *)data)->mt_type = MT_ISCY; ! 2106: ((struct mtget *)data)->mt_dsreg = u_info->last_control; ! 2107: ((struct mtget *)data)->mt_erreg = u_info->last_status; ! 2108: ((struct mtget *)data)->mt_resid = u_info->last_resid; ! 2109: ((struct mtget *)data)->mt_fileno = u_info->file_number; ! 2110: ((struct mtget *)data)->mt_blkno = u_info->blkno; ! 2111: cycmd(dev, DO_STAT, 1); ! 2112: return NOERROR; ! 2113: } ! 2114: return ENXIO; ! 2115: } ! 2116: ! 2117: /* ! 2118: ** Cydump is called during a system crash to dump all of main memory. ! 2119: ** We don't do any special checking here except we will exit early if ! 2120: ** an i/o error occurs. The other point is we poll for completion of each ! 2121: ** command since we don't want to do any special processing, we are ! 2122: ** the only process running anyway, and possibly the cpu interupt's ! 2123: ** were not working anyway. (what if sombody stepped on low core?) ! 2124: */ ! 2125: ! 2126: cydump(dev) ! 2127: register dev_t dev; ! 2128: { ! 2129: register int unit = CYUNIT(dev); ! 2130: register int ctlr = cydinfo[unit]->ui_ctlr; ! 2131: register unit_tab *u_info = &unit_info[unit]; ! 2132: register ctlr_tab *c_info = &ctlr_info[ctlr]; ! 2133: register int blk_siz; ! 2134: register int num = maxfree; ! 2135: register int start = 0x800; ! 2136: ! 2137: if ((unit >= NCY) || cydinfo[unit]) ! 2138: return(ENXIO); ! 2139: u_info->control_proto = CW_LOCK | CW_25ips | CW_16bits; ! 2140: if (cywait(&c_info->ccb)) ! 2141: return(EFAULT); ! 2142: while (num > 0) { ! 2143: blk_siz = num > TBUFSIZ ? TBUFSIZ : num; ! 2144: bcopy(start*NBPG, c_info->rawbuf, blk_siz*NBPG); ! 2145: c_info->tpb.cmd = WRIT_TA; ! 2146: c_info->tpb.control = u_info->control_proto; ! 2147: c_info->tpb.status = 0; ! 2148: c_info->tpb.size = MULTIBUS_SHORT(blk_siz*NBPG); ! 2149: load_mbus_addr((char *)0, c_info->tpb.link_ptr); ! 2150: load_mbus_addr(c_info->rawbuf,&(c_info->tpb.data_ptr)); ! 2151: load_mbus_addr(&c_info->tpb, c_info->ccb.tpb_ptr); ! 2152: c_info->ccb.gate = GATE_CLOSED; ! 2153: CY_ATTENTION(cyminfo[ctlr]->um_addr); ! 2154: start += blk_siz; ! 2155: num -= blk_siz; ! 2156: if (cywait(&c_info->ccb)) ! 2157: return(EFAULT); ! 2158: uncache(&c_info->tpb); ! 2159: if (c_info->tpb.status&CS_ERm) /* error */ ! 2160: return (EIO); ! 2161: } ! 2162: for(num=0; num<2; num++) { ! 2163: c_info->tpb.cmd = WRIT_FM; ! 2164: c_info->tpb.control = u_info->control_proto; ! 2165: c_info->tpb.status = c_info->tpb.size = 0; ! 2166: c_info->tpb.count = MULTIBUS_SHORT(1); ! 2167: load_mbus_addr((char *)0, c_info->tpb.link_ptr); ! 2168: load_mbus_addr(c_info->rawbuf,&(c_info->tpb.data_ptr)); ! 2169: load_mbus_addr(&c_info->tpb, c_info->ccb.tpb_ptr); ! 2170: c_info->ccb.gate = GATE_CLOSED; ! 2171: CY_ATTENTION(cyminfo[ctlr]->um_addr); ! 2172: if (cywait(&c_info->ccb)) ! 2173: return(EFAULT); ! 2174: uncache(&c_info->tpb); ! 2175: if (c_info->tpb.status&CS_ERm) /* error */ ! 2176: return (EIO); ! 2177: } ! 2178: c_info->tpb.cmd = REWD_OV; ! 2179: c_info->tpb.control = u_info->control_proto; ! 2180: c_info->tpb.status = c_info->tpb.size = 0; ! 2181: c_info->tpb.count = MULTIBUS_SHORT(1); ! 2182: load_mbus_addr((char *)0, c_info->tpb.link_ptr); ! 2183: load_mbus_addr(c_info->rawbuf,&(c_info->tpb.data_ptr)); ! 2184: load_mbus_addr(&c_info->tpb, c_info->ccb.tpb_ptr); ! 2185: c_info->ccb.gate = GATE_CLOSED; ! 2186: CY_ATTENTION(cyminfo[ctlr]->um_addr); ! 2187: if (cywait(&c_info->ccb)) ! 2188: return EFAULT; ! 2189: uncache(&c_info->tpb); ! 2190: return 0; ! 2191: } ! 2192: ! 2193: ! 2194: /* ! 2195: ** Poll until the controller is ready. ! 2196: */ ! 2197: ! 2198: cywait(ccb_ptr) ! 2199: register fmt_ccb *ccb_ptr; ! 2200: { ! 2201: register int cnt = 5000; ! 2202: ! 2203: uncache(&ccb_ptr->gate); ! 2204: while ((cnt-- > 0) && (ccb_ptr->gate == GATE_CLOSED)) { ! 2205: DELAY(1000); ! 2206: uncache(&ccb_ptr->gate); ! 2207: } ! 2208: return cnt <= 0; ! 2209: } ! 2210: ! 2211: ! 2212: /* ! 2213: ** Load_mbus_addr is used to load a 20 bit pointer into the ! 2214: ** Tapemaster registers. Take note of all the strange convolutions ! 2215: ** this controller forces us through to get the job done. ! 2216: */ ! 2217: ! 2218: load_mbus_addr(in, out) ! 2219: char *in; ! 2220: short *out; ! 2221: { ! 2222: register int tmp_in = (int)in; ! 2223: register char *out_ptr = (char *)out; ! 2224: ! 2225: *out_ptr++ = (char)(tmp_in & 0xff); ! 2226: *out_ptr++ = (char)((tmp_in >> 8) & 0xff); ! 2227: *out_ptr++ = (char)0; ! 2228: *out_ptr++ = (char)((tmp_in & 0xf0000) >> 12); ! 2229: } ! 2230: ! 2231: ! 2232: /* ! 2233: ** CYMINSIZE s supposed to adjust the buffer size for any raw i/o. ! 2234: ** since tapes can not read the tail end of partial blocks we ignore ! 2235: ** this request and strategy will return an appropriate error message later. ! 2236: ** ! 2237: ** If this is not done UNIX will lose data that is on the tape. ! 2238: */ ! 2239: ! 2240: unsigned cyminsize(request) ! 2241: register struct buf *request; ! 2242: { ! 2243: if(request->b_bcount > MAX_BLOCKSIZE) ! 2244: request->b_bcount = MAX_BLOCKSIZE; ! 2245: } ! 2246: ! 2247: ! 2248: /* ! 2249: ** cyreset is used to unconditionally reset all controllers to ! 2250: ** their initial state. ! 2251: */ ! 2252: ! 2253: cyreset(vba) ! 2254: register int vba; ! 2255: { ! 2256: register int ctlr; ! 2257: register caddr_t ctlr_vaddr; ! 2258: ! 2259: for(ctlr = 0; ctlr<NCY; ctlr++) ! 2260: if(cyminfo[ctlr]) ! 2261: if(cyminfo[ctlr]->um_vbanum == vba) { ! 2262: ctlr_vaddr = cyminfo[ctlr]->um_addr; ! 2263: CY_RESET(ctlr_vaddr); ! 2264: if(!cy_init_controller(ctlr_vaddr, ctlr, 0)) { ! 2265: printf("cy: controller #%d failed to reset!\n", ctlr); ! 2266: cyminfo[ctlr] = NULL; ! 2267: } ! 2268: } ! 2269: } ! 2270: ! 2271: ! 2272: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.