Annotation of sys/arch/hp300/stand/common/ct.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: ct.c,v 1.5 2006/08/17 06:31:10 miod Exp $ */
! 2: /* $NetBSD: ct.c,v 1.9 1996/10/14 07:29:57 thorpej Exp $ */
! 3:
! 4: /*
! 5: * Copyright (c) 1982, 1990, 1993
! 6: * The Regents of the University of California. All rights reserved.
! 7: *
! 8: * Redistribution and use in source and binary forms, with or without
! 9: * modification, are permitted provided that the following conditions
! 10: * are met:
! 11: * 1. Redistributions of source code must retain the above copyright
! 12: * notice, this list of conditions and the following disclaimer.
! 13: * 2. Redistributions in binary form must reproduce the above copyright
! 14: * notice, this list of conditions and the following disclaimer in the
! 15: * documentation and/or other materials provided with the distribution.
! 16: * 3. Neither the name of the University nor the names of its contributors
! 17: * may be used to endorse or promote products derived from this software
! 18: * without specific prior written permission.
! 19: *
! 20: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
! 21: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 22: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 23: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
! 24: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 25: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 26: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 27: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 28: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 29: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 30: * SUCH DAMAGE.
! 31: *
! 32: * @(#)ct.c 8.1 (Berkeley) 7/15/93
! 33: */
! 34:
! 35: /*
! 36: * CS80 tape driver
! 37: */
! 38: #include <sys/param.h>
! 39:
! 40: #include <hp300/dev/ctreg.h>
! 41:
! 42: #include <lib/libsa/stand.h>
! 43:
! 44: #include "samachdep.h"
! 45: #include "hpibvar.h"
! 46:
! 47: struct ct_iocmd ct_ioc;
! 48: struct ct_rscmd ct_rsc;
! 49: struct ct_stat ct_stat;
! 50: struct ct_ssmcmd ct_ssmc;
! 51:
! 52: struct ct_softc {
! 53: int sc_ctlr;
! 54: int sc_unit;
! 55: char sc_retry;
! 56: char sc_alive;
! 57: short sc_punit;
! 58: int sc_blkno;
! 59: } ct_softc[NHPIB][NCT];
! 60:
! 61: #define CTRETRY 5
! 62: #define MTFSF 10
! 63: #define MTREW 11
! 64:
! 65: int ctclose(struct open_file *);
! 66: int cterror(int, int);
! 67: int ctident(int, int);
! 68: int ctinit(int, int);
! 69: int ctopen(struct open_file *, int, int, int);
! 70: int ctpunit(int, int, int *);
! 71: int ctstrategy(void *, int, daddr_t, size_t, void *, size_t *);
! 72:
! 73: char ctio_buf[MAXBSIZE];
! 74:
! 75: struct ctinfo {
! 76: short hwid;
! 77: short punit;
! 78: } ctinfo[] = {
! 79: { CT7946ID, 1 },
! 80: { CT7912PID, 1 },
! 81: { CT7914PID, 1 },
! 82: { CT9144ID, 0 },
! 83: { CT9145ID, 0 }
! 84: };
! 85: int nctinfo = sizeof(ctinfo) / sizeof(ctinfo[0]);
! 86:
! 87: int
! 88: ctinit(int ctlr, int unit)
! 89: {
! 90: struct ct_softc *rs = &ct_softc[ctlr][unit];
! 91: u_char stat;
! 92:
! 93: if (hpibrecv(ctlr, unit, C_QSTAT, &stat, 1) != 1 || stat)
! 94: return (0);
! 95: if (ctident(ctlr, unit) < 0)
! 96: return (0);
! 97: bzero(&ct_ssmc, sizeof(ct_ssmc));
! 98: ct_ssmc.unit = C_SUNIT(rs->sc_punit);
! 99: ct_ssmc.cmd = C_SSM;
! 100: ct_ssmc.fefm = FEF_MASK;
! 101: ct_ssmc.refm = REF_MASK;
! 102: ct_ssmc.aefm = AEF_MASK;
! 103: ct_ssmc.iefm = IEF_MASK;
! 104: hpibsend(ctlr, unit, C_CMD, &ct_ssmc, sizeof(ct_ssmc));
! 105: hpibswait(ctlr, unit);
! 106: hpibrecv(ctlr, unit, C_QSTAT, &stat, 1);
! 107: rs->sc_alive = 1;
! 108: return (1);
! 109: }
! 110:
! 111: int
! 112: ctident(int ctlr, int unit)
! 113: {
! 114: struct cs80_describe desc;
! 115: u_char stat, cmd[3];
! 116: char name[7];
! 117: int id, i;
! 118:
! 119: id = hpibid(ctlr, unit);
! 120: if ((id & 0x200) == 0)
! 121: return(-1);
! 122: for (i = 0; i < nctinfo; i++)
! 123: if (id == ctinfo[i].hwid)
! 124: break;
! 125: if (i == nctinfo)
! 126: return(-1);
! 127: ct_softc[ctlr][unit].sc_punit = ctinfo[i].punit;
! 128: id = i;
! 129:
! 130: /*
! 131: * Collect device description.
! 132: * Right now we only need this to differentiate 7945 from 7946.
! 133: * Note that we always issue the describe command to unit 0.
! 134: */
! 135: cmd[0] = C_SUNIT(0);
! 136: cmd[1] = C_SVOL(0);
! 137: cmd[2] = C_DESC;
! 138: hpibsend(ctlr, unit, C_CMD, cmd, sizeof(cmd));
! 139: hpibrecv(ctlr, unit, C_EXEC, &desc, sizeof(desc));
! 140: hpibrecv(ctlr, unit, C_QSTAT, &stat, sizeof(stat));
! 141: bzero(name, sizeof(name));
! 142: if (!stat) {
! 143: int n = desc.d_name;
! 144: for (i = 5; i >= 0; i--) {
! 145: name[i] = (n & 0xf) + '0';
! 146: n >>= 4;
! 147: }
! 148: }
! 149: switch (ctinfo[id].hwid) {
! 150: case CT7946ID:
! 151: if (bcmp(name, "079450", 6) == 0)
! 152: id = -1; /* not really a 7946 */
! 153: break;
! 154: default:
! 155: break;
! 156: }
! 157: return(id);
! 158: }
! 159:
! 160: int
! 161: ctpunit(int ctlr, int slave, int *punit)
! 162: {
! 163: struct ct_softc *rs;
! 164:
! 165: if (ctlr >= NHPIB || hpibalive(ctlr) == 0)
! 166: return(EADAPT);
! 167: if (slave >= NCT)
! 168: return(ECTLR);
! 169: rs = &ct_softc[ctlr][slave];
! 170:
! 171: if (rs->sc_alive == 0)
! 172: return(ENXIO);
! 173:
! 174: *punit = rs->sc_punit;
! 175: return (0);
! 176: }
! 177:
! 178: int
! 179: ctopen(struct open_file *f, int ctlr, int unit, int part)
! 180: {
! 181: struct ct_softc *rs;
! 182: int skip;
! 183: size_t resid;
! 184:
! 185: if (ctlr >= NHPIB || hpibalive(ctlr) == 0)
! 186: return(EADAPT);
! 187: if (unit >= NCT)
! 188: return(ECTLR);
! 189: rs = &ct_softc[ctlr][unit];
! 190: rs->sc_blkno = 0;
! 191: rs->sc_unit = unit;
! 192: rs->sc_ctlr = ctlr;
! 193: if (rs->sc_alive == 0)
! 194: if (ctinit(ctlr, unit) == 0)
! 195: return(ENXIO);
! 196: f->f_devdata = (void *)rs;
! 197: ctstrategy(f->f_devdata, MTREW, 0, 0, ctio_buf, &resid);
! 198: skip = part;
! 199: while (skip--)
! 200: ctstrategy(f->f_devdata, MTFSF, 0, 0, ctio_buf, &resid);
! 201: return(0);
! 202: }
! 203:
! 204: int
! 205: ctclose(struct open_file *f)
! 206: {
! 207: size_t resid;
! 208:
! 209: ctstrategy(f->f_devdata, MTREW, 0, 0, ctio_buf, &resid);
! 210: return (0);
! 211: }
! 212:
! 213: int
! 214: ctstrategy(void *devdata, int func, daddr_t dblk, size_t size, void *v_buf,
! 215: size_t *rsize)
! 216: {
! 217: struct ct_softc *rs = devdata;
! 218: char *buf = v_buf;
! 219: int ctlr = rs->sc_ctlr;
! 220: int unit = rs->sc_unit;
! 221: char stat;
! 222:
! 223: if (size == 0 && (func == F_READ || func == F_WRITE))
! 224: return(0);
! 225:
! 226: rs->sc_retry = 0;
! 227: bzero(&ct_ioc, sizeof(ct_ioc));
! 228: ct_ioc.unit = C_SUNIT(rs->sc_punit);
! 229: ct_ioc.saddr = C_SADDR;
! 230: ct_ioc.nop2 = C_NOP;
! 231: ct_ioc.slen = C_SLEN;
! 232: ct_ioc.nop3 = C_NOP;
! 233: top:
! 234: if (func == F_READ) {
! 235: ct_ioc.cmd = C_READ;
! 236: ct_ioc.addr = rs->sc_blkno;
! 237: ct_ioc.len = size;
! 238: }
! 239: else if (func == F_WRITE) {
! 240: ct_ioc.cmd = C_WRITE;
! 241: ct_ioc.addr = rs->sc_blkno;
! 242: ct_ioc.len = size;
! 243: }
! 244: else if (func == MTFSF) {
! 245: ct_ioc.cmd = C_READ;
! 246: ct_ioc.addr = rs->sc_blkno;
! 247: ct_ioc.len = size = MAXBSIZE;
! 248: }
! 249: else {
! 250: ct_ioc.cmd = C_READ;
! 251: ct_ioc.addr = 0;
! 252: ct_ioc.len = 0;
! 253: rs->sc_blkno = 0;
! 254: size = 0;
! 255: }
! 256: retry:
! 257: hpibsend(ctlr, unit, C_CMD, &ct_ioc, sizeof(ct_ioc));
! 258: if (func != MTREW) {
! 259: hpibswait(ctlr, unit);
! 260: hpibgo(ctlr, unit, C_EXEC, buf, size,
! 261: func != F_WRITE ? F_READ : F_WRITE);
! 262: hpibswait(ctlr, unit);
! 263: } else {
! 264: while (hpibswait(ctlr, unit) < 0)
! 265: ;
! 266: }
! 267: hpibrecv(ctlr, unit, C_QSTAT, &stat, 1);
! 268: if (stat) {
! 269: stat = cterror(ctlr, unit);
! 270: if (stat == 0)
! 271: return (-1);
! 272: if (stat == 2)
! 273: return (0);
! 274: if (++rs->sc_retry > CTRETRY)
! 275: return (-1);
! 276: goto retry;
! 277: }
! 278: rs->sc_blkno += CTBTOK(size);
! 279: if (func == MTFSF)
! 280: goto top;
! 281: *rsize = size;
! 282:
! 283: return(0);
! 284: }
! 285:
! 286: int
! 287: cterror(int ctlr, int unit)
! 288: {
! 289: struct ct_softc *rs = &ct_softc[ctlr][unit];
! 290: char stat;
! 291:
! 292: bzero(&ct_rsc, sizeof(ct_rsc));
! 293: bzero(&ct_stat, sizeof(ct_stat));
! 294: ct_rsc.unit = C_SUNIT(rs->sc_punit);
! 295: ct_rsc.cmd = C_STATUS;
! 296: hpibsend(ctlr, unit, C_CMD, &ct_rsc, sizeof(ct_rsc));
! 297: hpibrecv(ctlr, unit, C_EXEC, &ct_stat, sizeof(ct_stat));
! 298: hpibrecv(ctlr, unit, C_QSTAT, &stat, 1);
! 299: if (stat) {
! 300: printf("ct%d: request status fail %d\n", unit, stat);
! 301: return(0);
! 302: }
! 303: if (ct_stat.c_aef & AEF_EOF) {
! 304: /* 9145 drives don't increment block number at EOF */
! 305: if ((ct_stat.c_blk - rs->sc_blkno) == 0)
! 306: rs->sc_blkno++;
! 307: else
! 308: rs->sc_blkno = ct_stat.c_blk;
! 309: return (2);
! 310: }
! 311: printf("ct%d err: vu 0x%x, pend 0x%x, bn%ld", unit,
! 312: ct_stat.c_vu, ct_stat.c_pend, ct_stat.c_blk);
! 313: printf(", R 0x%x F 0x%x A 0x%x I 0x%x\n", ct_stat.c_ref,
! 314: ct_stat.c_fef, ct_stat.c_aef, ct_stat.c_ief);
! 315: return (1);
! 316: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to ct.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / hp300 / stand / common