2.11BSD/sys/pdpstand/ra.c
/*
* Copyright (c) 1986 Regents of the University of California.
* All rights reserved. The Berkeley software License Agreement
* specifies the terms and conditions for redistribution.
*
* @(#)ra.c 2.8 (2.11BSD GTE) 1998/1/30
*/
/*
* MSCP disk device driver (rx23, rx33, rx50, rd??, ra??, rz??)
*/
#include "../h/param.h"
#include "../machine/mscp.h"
#include "../pdpuba/rareg.h"
#include "saio.h"
#define NRA 2
#define RA_SMASK (RA_STEP4|RA_STEP3|RA_STEP2|RA_STEP1)
struct radevice *RAcsr[NRA + 1] =
{
(struct radevice *)0172150,
(struct radevice *)0,
(struct radevice *)-1
};
/*
* RA Communications Area
*/
struct rdca {
short ca_xxx1; /* unused */
char ca_xxx2; /* unused */
char ca_bdp; /* BDP to purge */
short ca_cmdint; /* command queue transition interrupt flag */
short ca_rspint; /* response queue transition interrupt flag */
short ca_rspl; /* response descriptors */
short ca_rsph;
short ca_cmdl; /* command descriptors */
short ca_cmdh;
};
#define ca_ringbase ca_rspl
#define RA_OWN 0x8000 /* RQ owns this descriptor */
#define RA_INT 0x4000 /* allow interrupt on ring transition */
static struct ra {
struct rdca ra_ca;
struct mscp ra_rsp;
struct mscp ra_cmd;
} rd[NRA];
static u_char rainit[NRA];
static int mx();
/*
* This contains the volume size in sectors of units which have been
* brought online. This value is used at default label generation time
* along with the results of a 'get unit status' command to compute the
* "geometry" of the drive.
*/
static long raonline[NRA][8];
raopen(io)
register struct iob *io;
{
register struct radevice *raaddr;
register struct ra *racom;
struct disklabel *lp = &io->i_label;
int i, ctlr, unit, bae, lo16;
ctlr = io->i_ctlr;
unit = io->i_unit;
if (genopen(NRA, io) < 0)
return(-1);
raaddr = RAcsr[ctlr];
racom = &rd[ctlr];
if (rainit[ctlr] == 0) {
again: raaddr->raip = 0;
if (ra_step(raaddr, RA_STEP1, 1))
goto again;
raaddr->rasa = RA_ERR | (0154/4);
if (ra_step(raaddr, RA_STEP2, 2))
goto again;
iomapadr(&racom->ra_ca.ca_ringbase, &bae, &lo16);
raaddr->rasa = lo16;
if (ra_step(raaddr, RA_STEP3, 3))
goto again;
raaddr->rasa = bae;
if (ra_step(raaddr, RA_STEP4, 4))
goto again;
raaddr->rasa = RA_GO;
if (racmd(M_OP_STCON, io) < 0) {
printf("%s STCON err\n", devname(io));
return(-1);
}
rainit[ctlr] = 1;
}
if (raonline[ctlr][unit] == 0)
if (ramount(io) == -1)
return(-1);
if (devlabel(io, READLABEL) == -1)
return(-1);
io->i_boff = lp->d_partitions[io->i_part].p_offset;
return(0);
}
raclose(io)
register struct iob *io;
{
raonline[io->i_ctlr][io->i_unit] = 0;
return(0);
}
ramount(io)
register struct iob *io;
{
register int ctlr = io->i_ctlr;
register int unit = io->i_unit;
if (racmd(M_OP_ONLIN, io) < 0) {
printf("%s !online\n", devname(io));
return(-1);
}
raonline[ctlr][unit] = rd[ctlr].ra_rsp.m_uslow +
((long)(rd[ctlr].ra_rsp.m_ushigh) << 16);
return(0);
}
racmd(op, io)
int op;
struct iob *io;
{
register struct mscp *mp;
int ctlr = io->i_ctlr;
int unit = io->i_unit;
register struct ra *racom = &rd[ctlr];
struct radevice *csr = RAcsr[ctlr];
int i, bae, lo16;
racom->ra_cmd.m_opcode = op;
racom->ra_cmd.m_unit = unit;
racom->ra_cmd.m_cntflgs = 0;
racom->ra_rsp.m_header.mscp_msglen = sizeof(struct mscp);
racom->ra_cmd.m_header.mscp_msglen = sizeof(struct mscp);
iomapadr(&racom->ra_rsp.m_cmdref, &bae, &lo16);
racom->ra_ca.ca_rspl = lo16;
racom->ra_ca.ca_rsph = RA_OWN | bae;
iomapadr(&racom->ra_cmd.m_cmdref, &bae, &lo16);
racom->ra_ca.ca_cmdl = lo16;
racom->ra_ca.ca_cmdh = RA_OWN | bae;
i = csr->raip;
mp = &racom->ra_rsp;
while (1) {
while (racom->ra_ca.ca_cmdh & RA_OWN) {
delay(200); /* SA access delay */
if (csr->rasa & (RA_ERR|RA_SMASK))
goto fail;
}
while (racom->ra_ca.ca_rsph & RA_OWN) {
delay(200); /* SA access delay */
if (csr->rasa & (RA_ERR|RA_SMASK))
goto fail;
}
racom->ra_ca.ca_cmdint = 0;
racom->ra_ca.ca_rspint = 0;
if (mp->m_opcode == (op | M_OP_END))
break;
printf("%s rsp %x op %x ignored\n", devname(io),
mp->m_header.mscp_credits & 0xf0, mp->m_opcode);
racom->ra_ca.ca_rsph |= RA_OWN;
}
if ((mp->m_status & M_ST_MASK) != M_ST_SUCC) {
printf("%s err op=%x sts=%x\n", devname(io),
mp->m_opcode, mp->m_status);
return(-1);
}
return(0);
fail:
printf("%s rasa=%x\n", devname(io), csr->rasa);
}
rastrategy(io, func)
register struct iob *io;
int func;
{
register struct mscp *mp;
struct ra *racom;
int bae, lo16, i;
i = deveovchk(io); /* check for end of volume/partition */
if (i <= 0)
return(i);
racom = &rd[io->i_ctlr];
mp = &racom->ra_cmd;
iomapadr(io->i_ma, &bae, &lo16);
mp->m_lbn_l = loint(io->i_bn);
mp->m_lbn_h = hiint(io->i_bn);
mp->m_bytecnt = io->i_cc;
mp->m_buf_l = lo16;
mp->m_buf_h = bae;
if (racmd(func == READ ? M_OP_READ : M_OP_WRITE, io) < 0)
return(-1);
return(io->i_cc);
}
ra_step(csr, mask, step)
register struct radevice *csr;
int mask, step;
{
register int cnt;
for (cnt = 0; (csr->rasa & mask) == 0; )
{
delay(2000);
cnt++;
if (cnt < 5000)
continue;
printf("ra(%o) fail step %d. retrying\n",csr,step);
return(1);
}
return(0);
}
/*
* This routine is called by the general 'devlabel' routine out of conf.c
* and is used by the standalone disklabel program to initialize the
* default disklabel. The MSCP driver does not need geometry info but
* it is almost trivial (because the drive has already been brought online by
* 'raopen') to fetch the required information with a 'get unit status'
* command.
*/
ralabel(io)
struct iob *io;
{
register struct disklabel *lp = &io->i_label;
register char *cp, *dp;
daddr_t nblks = raonline[io->i_ctlr][io->i_unit];
struct mscp *mp = &rd[io->i_ctlr].ra_rsp;
int nameid, numid;
lp->d_type = DTYPE_MSCP;
lp->d_partitions[0].p_size = nblks; /* span the drive with 'a' */
/* lp->d_secperunit = nblks; /* size of entire volume */
if (racmd(M_OP_GTUNT, io) != 0)
{
printf("%s GTUNT failed\n", devname(io));
return(-1);
}
/*
* Yes it's a lot of code but since the standalone utilities (at least 'restor')
* are likely going to end up split I/D anyhow why not get the information.
*
* sectors/track
* tracks/group * group/cyl = tracks/cyl
* sectors/track * tracks/cyl = sectors/cyl
* sectors / sectors/cyl = cyl
*/
lp->d_nsectors = mp->m_track;
lp->d_ntracks = mp->m_group * mp->m_cylinder;
lp->d_secpercyl = lp->d_nsectors * lp->d_ntracks;
lp->d_ncylinders = nblks / lp->d_secpercyl;
nameid = (((loint(mp->m_mediaid) & 0x3f) << 9) |
((hiint(mp->m_mediaid) >> 7) & 0x1ff));
numid = hiint(mp->m_mediaid) & 0x7f;
/*
* Next put 'RA81' or 'RD54', etc into the typename field.
*/
cp = lp->d_typename;
*cp++ = mx(nameid, 2);
*cp++ = mx(nameid, 1);
dp = itoa(numid);
while (*cp++ = *dp++)
;
*cp = mx(nameid, 0);
if (*cp != ' ')
cp++;
*cp = '\0';
return(0);
}
/*
* this is a routine rather than a macro to save space - shifting, etc
* generates a lot of code.
*/
static
mx(l, i)
int l, i;
{
register int c;
c = (l >> (5 * i)) & 0x1f;
if (c == 0)
c = ' ' - '@';
return(c + '@');
}