github.com/Arquivotheca.SunOS-4.1.4
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
ff309bfe1c8e554728af4b8a4e9cee4d026a7e35
Arquivotheca.SunOS-4.1.4/sys/sundev/id.c
seta75D ff309bfe1c Init
2021-10-11 18:37:13 -03:00

4501 lines
113 KiB
C
Raw Blame History

#ident "@(#)id.c 1.1 94/10/31 SMI"
/*
* Copyright (c) 1989 by Sun Microsystems, Inc.
*/
/*
* IPI disk driver.
*
* Handles the following string controllers and disks:
* Sun Panther VME-based IPI-2 String Controller
* CDC MPI PA8R2A IPI-2 Disk
* CDC MPI/CM-3 String Controller
*/
#include <sys/types.h>
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/dk.h>
#include <sys/buf.h>
#include <sys/conf.h>
#include <sys/user.h>
#include <sys/map.h>
#include <sys/vmmac.h>
#include <sys/uio.h>
#include <sys/kernel.h>
#include <sys/dkbad.h>
#include <sys/file.h>
#include <sys/debug.h>
#include <sys/syslog.h>
#include <machine/psl.h>
#include <machine/mmu.h>
#include <machine/cpu.h>
#include <sun/dkio.h>
#include <sun/autoconf.h>
#include <sundev/mbvar.h>
#include <sundev/ipi_driver.h>
#include <sundev/ipi3.h>
#include <sundev/idvar.h>
#include <sundev/ipi_error.h>
#include <vm/hat.h>
#include <vm/seg.h>
#include <vm/as.h>
#include <values.h> /* for MAXINT */
#define DEBUG
#define alloc(type, count) ((type *)kmem_zalloc((count)*sizeof (type)))
static struct id_ctlr **id_ctlr; /* pointer to ctlr pointer array */
static int nidc; /* maximum controller number plus 1 */
#define NIDC_EXTEND 8 /* amount to extend pointer array by */
static struct id_unit **id_unit; /* pointer to unit pointer array */
static int nid;
#define NID_EXTEND 8 /* number of units to extend by */
static int id_debug = 0; /* debugging code */
static int id_print_attr;
static int id_watch_enable = 0; /* enable watchdog for unit status */
#define MULT_RBUF 0 /* set when physio supports multiple raw buffers */
#ifdef MULT_MAJOR
static u_char bmajor_lookup[NMAJOR]; /* index of block major device */
static u_char cmajor_lookup[NMAJOR]; /* index of character major device */
static u_char cmajor_trans[NMAJOR]; /* blk maj num corresponding to char */
#endif /* MULT_MAJOR */
#define ALIGN(x, i) (((u_long)x + (u_long)i) & ~(u_long)(i - 1))
#define NBLKS(n, un) ((u_int)(n) >> (un)->un_log_bshift)
#define MAX_CMDLEN 64
#define MAX_RESPLEN 256
/*
* Time limits in seconds.
*/
#define ID_TIMEOUT 20 /* time limit on commands (in seconds) */
#define ID_REC_TIMEOUT 16 /* time limit on recovery commands (seconds) */
#define ID_DUMP_TIMEOUT 16 /* time limit on ISP-80 dump */
#define ID_IDLE_TIME 10 /* wait time for ctlr to go idle */
#define ID_RST_TIMEOUT 45 /* wait time for controller reset */
/*
* Maximum number of commands that can be outstanding to controllers which
* do not sort to attempt to optimize seek distance.
*/
#define MAX_UNSORTED 4 /* maximum outstanding cmds if no seek alg */
/*
* ID_MAX_PARMS = maximum number of attribute parameters that shall be
* requested per attribute command. (The controller may have a lower
* restriction.)
*/
#define ID_MAX_PARMS 16
#define ID_RESP_PER_CTLR 4 /* allocated responses per ctrl */
/*
* Maximum byte count for an I/O operation.
*/
#define ID_MAXPHYS (63 * 1024)
/*
* Definitions for watchdog routines
*/
#define ID_WATCH_TIME 17 /* seconds between watchdog runs */
#define ID_MAX_IDLE (2*ID_WATCH_TIME)
/* maximum idle time for online device */
static char id_watch_started;
static void id_watch();
static void id_watch_intr();
static void id_missing_req();
static int id_recover();
static int id_recover_start();
static void id_recover_intr();
static void id_recover_ctlr();
#define b_cylin b_resid /* cylinder number for disksort */
/*
* Autoconfiguration data.
*/
static int idprobe(), idslave();
static void idintr();
static void idasync();
static int idrestart();
static int idstart();
static struct mb_ctlr **idcinfo;
struct mb_driver idcdriver = {
idprobe, idslave, NULL, NULL, NULL, NULL,
1, "id", NULL, "idc", NULL, /* mdr_cinfo = idcinfo set by idprobe */
MDR_BIODMA
};
/*
* Attribute tables and functions.
*/
static int id_attr_vendor();
static int id_ctlr_conf();
static int id_ctlr_reconf();
static int id_set_ctlr_reconf();
static int id_ctlr_fat_attr();
static struct ipi_resp_table vendor_id_table[] = {
/* parm-id minimum-len function */
ATTR_VENDOR, 28, id_attr_vendor,
0, 0, NULL,
};
static struct ipi_resp_table ctlr_conf_table[] = {
/* parm-id minimum-len function */
ATTR_ADDR_CONF, sizeof (struct addr_conf_parm), id_ctlr_conf,
ATTR_SLVCNF_BIT, sizeof (struct reconf_bs_parm), id_ctlr_reconf,
ATTR_FAC_ATTACH, 0, id_ctlr_fat_attr,
0, 0, NULL
};
static struct ipi_resp_table ctlr_set_conf_table[] = {
/* parm-id minimum-len function */
ATTR_SLVCNF_BIT, sizeof (struct reconf_bs_parm), id_set_ctlr_reconf,
0, 0, NULL
};
static int id_attr_physdk();
static int id_attr_physdk_cm3();
static int id_phys_bsize();
static int id_log_bsize();
static int id_attr_nblks();
static struct ipi_resp_table attach_resp_table[] = {
/* parm-id minimum-len function */
ATTR_PHYSDK, sizeof (struct physdk_parm), id_attr_physdk,
ATTR_PHYS_BSIZE, sizeof (struct physbsize_parm), id_phys_bsize,
ATTR_LOG_BSIZE, sizeof (struct datbsize_parm), id_log_bsize,
ATTR_LOG_GEOM, sizeof (struct numdatblks_parm), id_attr_nblks,
0, 0, NULL
};
static int id_respx();
static int id_deflist_parmlen();
static struct ipi_resp_table id_deflist_table[] = {
/* parm-id minimum-len function */
RESP_EXTENT, sizeof (struct respx_parm), id_respx,
ATTR_PARMLEN, sizeof (struct parmlen_parm), id_deflist_parmlen,
0, 0, NULL
};
static int id_format();
static int id_rdwr_deflist();
static int id_ioctl_cmd();
static int id_error();
static void id_printerr();
static void id_retry();
static void id_q_retry();
static void id_cmd_intr();
static int id_send_cmd();
static void id_build_rdwr();
static int id_kmem_realloc();
static void id_update_map();
/*
* Table for handling response.
*/
struct ipi_err_table {
char et_byte; /* byte in parameter (ID is byte 0) */
u_char et_mask; /* mask to apply or parameter ID */
u_long et_flags; /* error code */
char *et_msg; /* message to print */
};
#define et_parmid et_mask /* mask doubles as parameter ID for byte 0 */
/*
* Constant used to determine equivalent facility parameters from
* the slave parameter ID. The facility ID is always 0x10 more.
*/
#define IPI_FAC_PARM 0x10
/*
* Macros to initialize table. Used by IPI_ERR_TABLE_INIT
*/
#define IPI_ERR_PARM(sid, fid, flags, msg) \
{ 0, (sid), (flags), (msg) },
#define IPI_ERR_BIT(byte, bit, flags, msg) \
{ (byte), 1<<(bit), (flags), (msg) },
static struct ipi_err_table ipi_err_table[] = {
IPI_ERR_TABLE_INIT()
{ 0, 0, 0, NULL }
};
static struct ipi_err_table ipi_cond_table[] = {
IPI_COND_TABLE_INIT()
{ 0, 0, 0, NULL }
};
static struct opcode_name {
u_char opcode;
char *name;
} opcode_name[] = {
{ IP_NOP, "no-op", },
{ IP_ATTRIBUTES, "Attributes" },
{ IP_REPORT_STAT, "Report Status" },
{ IP_READ, "read" },
{ IP_WRITE, "write" },
{ IP_FORMAT, "format" },
{ IP_READ_DEFLIST, "read defects list" },
{ IP_WRITE_DEFLIST, "write defect list" },
{ IP_REALLOC, "reallocate" },
{ IP_ALLOC_RESTOR, "allocate restore" },
{ IP_DIAG_CTL, "diag ctl" },
{ 0xff, "async rupt" },
{ 0, NULL } /* table end */
};
/*
* Variables for write checking (read-back).
*/
#define ID_WCHK_BUFL (64*1024) /* length of buffer for read-back */
static struct buf *id_wchk_buf; /* pointer to buffer for read-back */
static void id_alloc_wchk(); /* allocate read-back buffer */
static void id_readback(); /* issue command for read-back */
long dk_hexunit; /* mask for dk numbers using hex unit number */
/* XXX - duplicates line in sys/dk.h */
extern char * strncpy();
/*
* Determine existence of a controller. Called at boot time only.
*/
static
idprobe(reg, ctlr)
u_short *reg; /* IPI device (channel/slave/fac) number */
int ctlr; /* slave (string controller) number */
{
struct id_ctlr *c;
int unit;
int fac;
int csf = (int)reg; /* IPI device (channel/slave/fac) number */
#if MULT_MAJOR
/*
* Must initialize major number mapping even if no devices exist,
* since open routines could still be called.
*/
id_major_map_init();
#endif
if (IPI_FAC(csf) != IPI_NO_ADDR) {
printf("idc%d: configured with bad IPI address %x\n",
ctlr, csf);
return (0);
}
/*
* Call ipi_device to be sure channel is configured.
* It will be called again in id_init_ctlr(), so some args not needed.
*/
if (ipi_device(csf, 0, 0, (void (*)())NULL, (void (*)())NULL,
(caddr_t)NULL))
return (0); /* channel not present */
/*
* Make sure we have enough controller pointers.
*/
if (ctlr >= nidc) {
if (id_kmem_realloc((caddr_t *) &id_ctlr,
(u_int)nidc * sizeof (struct id_ctlr),
(u_int)(ctlr+NIDC_EXTEND)
* sizeof (struct id_ctlr)))
return (0);
if (id_kmem_realloc((caddr_t *) &idcinfo,
(u_int)nidc * sizeof (struct mb_ctlr *),
(u_int)(ctlr+NIDC_EXTEND)
* sizeof (struct mb_ctlr *)))
return (0);
idcdriver.mdr_cinfo = idcinfo;
nidc = ctlr + NIDC_EXTEND;
}
/*
* Allocate controller structure.
*/
if ((c = id_ctlr[ctlr]) != NULL)
return (0); /* already allocated */
if ((c = alloc(struct id_ctlr, 1)) == NULL)
return (0); /* no memory */
id_ctlr[ctlr] = c;
c->c_flags |= IE_INIT_STAT; /* the status is unknown */
c->c_fac_flags = (1 << IDC_NUNIT) - 1; /* assume all facilities */
c->c_ipi_addr = csf;
/*
* Initialize controller by reading Vendor-ID, attributes.
*/
if (id_init_ctlr(csf, ctlr, ID_SYNCH)) {
/*
* It's there. Configure all online drives on this controller.
*/
unit = ID_MAKE_UNIT(IPI_CHAN(csf), IPI_SLAVE(csf), 0);
for (fac = 0; fac < IDC_NUNIT; fac++, unit++)
if (c->c_fac_flags & (1 << fac))
(void) id_findslave(unit, c, ID_SYNCH);
}
return (IPI_NSLAVE);
}
/*
* Initialize controller if it is present.
* Called through idprobe at boot and by idopen.
* Returns non-zero if controller is present.
*/
static
id_init_ctlr(reg, ctlr, mode)
int reg; /* IPI device (channel/slave/fac) number */
int ctlr; /* slave (string controller) number */
int mode; /* ID_SYNCH or ID_ASYNCWAIT */
{
register struct id_ctlr *c;
struct mb_ctlr *mc;
struct mb_driver *mdr;
ASSERT(mode != ID_ASYNCH);
c = id_ctlr[ctlr];
c->c_ctype = DKC_UNKNOWN;
c->c_max_q = 1; /* temporarily limit to one cmd at a time */
c->c_max_q_len = MAXINT;
c->c_max_parms = 1;
c->c_ctlr = ctlr;
c->c_ipi_addr = reg;
/*
* Search for mb_ctlr structure. mdr_cinfo isn't setup at probe time.
* This could be eliminated later with an autoconf change. XXX
*/
for (mc = mbcinit; mdr = mc->mc_driver; mc++) {
if (mdr == &idcdriver && mc->mc_ctlr == ctlr)
break;
}
if (mdr) {
c->c_intpri = mc->mc_intpri;
}
if (ipi_device(reg, (int)c->c_intpri, 0, idasync,
id_recover_ctlr, (caddr_t)c))
return (0); /* channel not present */
c->c_recover.rec_history = 0;
c->c_recover.rec_state = IDR_RST_CTLR1;
c->c_recover.rec_substate = 0;
if (mode == ID_SYNCH)
c->c_recover.rec_flags = IP_SYNC | IP_NO_RETRY;
else
c->c_recover.rec_flags = IP_NO_RETRY;
(void) id_recover(c, (struct id_unit *)NULL);
if (mode == ID_ASYNCHWAIT)
while (c->c_flags & IE_RECOVER)
(void) sleep((caddr_t)c, PRIBIO);
if (c->c_recover.rec_state != IDR_NORMAL)
return (0);
/*
* Allocate enough command and response packets.
*
* BSA Bug ID 1115859
* Use c->c_max_q + 4 below to allocate a few more empty q's
* than maximum I/O's a board can handle so that if board dies
* with all possible q's outstanding, id_recover logic can still
* allocate some q's for a recover/reset. Also, second call to
* ipi_alloc() removed because it always turns out to be a NOP.
*/
if (ipi_alloc(reg, c->c_max_q + 4, (int)c->c_rw_cmd_len) == 0)
return (0);
(void) ipi_timeout(reg, ID_TIMEOUT);
return (IPI_NSLAVE); /* number of slaves */
}
/*
* Inspect vendor ID parameter, and set controller type.
*/
/* ARGSUSED */
static int
id_attr_vendor(q, parm_id, parm, len, cp)
struct ipiq *q;
int parm_id; /* parameter ID (0x50) */
u_char *parm; /* parameter */
int len; /* length of parameter */
caddr_t cp; /* pointer id_ctlr structure */
{
register struct vendor_parm *vp;
register struct id_ctlr *c = (struct id_ctlr *)cp;
vp = (struct vendor_parm *) parm;
/*
* Set command packet length for controllers which don't require
* the transfer notification parameter.
*/
c->c_rw_cmd_len = sizeof (struct ipi_rdwr_cmd) - sizeof (u_short);
c->c_max_parms = ID_MAX_PARMS;
/*
* Set controller type based on manufacturer and model.
*/
if (strncmp(vp->manuf, "MPI/CM-3", 8) == 0) {
c->c_ctype = DKC_CDC_9057;
c->c_flags |= ID_CTLR_VERIFY;
c->c_max_parms = 1; /* XXX - debug */
} else if (strcmp(vp->manuf, "IntelliStor") == 0 &&
strcmp(vp->model, "Model 00") == 0 &&
strcmp((char *)vp->rev, "R001") == 0)
{
c->c_ctype = DKC_FJ_M1060; /* FJ/Intellistor */
c->c_flags |= ID_CTLR_VERIFY;
} else if (strncmp(vp->manuf, "SUNMICRO", 8) == 0 &&
strncmp(vp->model, "PANTHER", 7) == 0)
{
c->c_ctype = DKC_SUN_IPI1; /* Panther */
/*
* Set flag indicating this controller has enough
* sense to schedule requests based on head position.
*/
c->c_flags |= ID_SEEK_ALG;
c->c_rw_cmd_len = sizeof (struct ipi_rdwr_cmdx)
- sizeof (u_short);
c->c_max_parms = 1;
/*
* Early versions of Panther don't support the slave
* reconfiguration parameter.
*/
if (vp->rev[3] == 0)
c->c_flags |= ID_NO_RECONF;
} else {
c->c_ctype = DKC_UNKNOWN;
printf("idc%d: unknown ctlr vendor id: manuf '%s' model '%s'\n",
c->c_ctlr, vp->manuf, vp->model);
}
}
/*
* Handle addressee configuration parameter for controller.
*/
/* ARGSUSED */
static int
id_ctlr_conf(q, parm_id, parm, len, cp)
struct ipiq *q;
int parm_id; /* parameter ID (0x65) */
u_char *parm; /* parameter */
int len; /* length of parameter */
caddr_t cp; /* pointer id_ctlr structure */
{
register struct id_ctlr *c = (struct id_ctlr *)cp;
register struct addr_conf_parm *acp = (struct addr_conf_parm *) parm;
c->c_max_cmdlen = acp->ac_max_cmdlen;
c->c_max_resplen = acp->ac_max_resplen;
c->c_max_q = (acp->ac_max_queue > 0) ? acp->ac_max_queue : MAXSHORT;
c->c_max_q_len = (acp->ac_cmdbufsize > 0) ? acp->ac_cmdbufsize : MAXINT;
}
/*
* Handle slave reconfiguration (bit fields) parameter for controller.
*/
/* ARGSUSED */
static int
id_ctlr_reconf(q, parm_id, parm, len, cp)
struct ipiq *q;
int parm_id; /* parameter ID (0x6e) */
u_char *parm; /* parameter */
int len; /* length of parameter */
caddr_t cp; /* pointer id_ctlr structure */
{
register struct id_ctlr *c = (struct id_ctlr *)cp;
register struct reconf_bs_parm *rp = (struct reconf_bs_parm *) parm;
if (rp->sr_seek_alg)
c->c_flags |= ID_SEEK_ALG;
c->c_reconf_bs_parm = *rp;
}
/*
* Handle setting of slave reconfiguration (bit fields) parameter for ctlr.
*/
/* ARGSUSED */
static int
id_set_ctlr_reconf(q, parm_id, parm, len, cp)
struct ipiq *q;
int parm_id; /* parameter ID (0x6e) */
u_char *parm; /* parameter */
int len; /* length of parameter */
caddr_t cp; /* pointer id_ctlr structure */
{
register struct id_ctlr *c = (struct id_ctlr *)cp;
register struct reconf_bs_parm *rp;
rp = &c->c_reconf_bs_parm; /* point to copy in ctlr struct */
rp->sr_inh_resp_succ = 0;
rp->sr_inh_ext_substat = 0;
rp->sr_tnp_req = 1;
rp->sr_inh_slv_msg = 0; /* enable slave messages */
rp->sr_dis_cl1x = 0; /* enable class 1 transitions */
*(struct reconf_bs_parm *)parm = *rp; /* set parm */
return (0);
}
/*
* Handle facilities attached parameter for controller.
*/
/* ARGSUSED */
static int
id_ctlr_fat_attr(q, parm_id, parm, len, cp)
struct ipiq *q;
int parm_id; /* parameter ID (0x6e) */
u_char *parm; /* parameter */
int len; /* length of parameter */
caddr_t cp; /* pointer id_ctlr structure */
{
struct id_ctlr *c = (struct id_ctlr *)cp;
struct fat_parm *fp = (struct fat_parm *)parm;
int flags = 0;
for (; len >= sizeof (*fp); fp++, len -= sizeof (*fp))
flags |= 1 << fp->fa_addr;
c->c_fac_flags = flags;
}
/*
* Slave routine.
* Just return zero since the controller probe configures everything.
*/
/* ARGSUSED */
static
idslave(md, reg)
struct mb_device *md;
caddr_t reg; /* IPI address */
{
return (0);
}
/*
* Initialize unit by taking status and reading label via recovery procedure.
*/
static
id_init_unit(un, mode)
struct id_unit *un;
int mode;
{
if (un->un_lp == NULL &&
(un->un_lp=(struct dk_label *)kmem_zalloc(DEV_BSIZE)) == NULL)
{
printf("id%3x: out of memory for label info\n", un->un_unit);
return;
}
/*
* reset most flags.
*/
un->un_flags = (un->un_flags & IE_INIT_STAT) | IE_RECOVER;
un->un_recover.rec_history = 0;
un->un_recover.rec_state = IDR_STAT_UNIT;
un->un_recover.rec_substate = 0;
if (mode == ID_SYNCH)
un->un_recover.rec_flags = IP_SYNC;
else
un->un_recover.rec_flags = 0;
(void) id_recover(un->un_ctlr, un);
if (mode == ID_ASYNCHWAIT)
while (un->un_flags & IE_RECOVER)
(void) sleep((caddr_t)un, PRIBIO);
}
static
id_findslave(unit, c, mode)
int unit;
struct id_ctlr *c;
int mode;
{
struct id_unit *un;
struct mb_device *md;
int ctlr; /* controller number */
int fac; /* facility number */
int csf; /* IPI channel/slave/facility address */
extern int dkn; /* disk index for iostats */
ctlr = c->c_ctlr;
/*
* Make sure we have enough unit pointers.
*/
if (unit >= nid) {
if (id_kmem_realloc((caddr_t *)&id_unit,
(u_int)nid * sizeof (struct id_unit *),
((u_int)unit + NID_EXTEND)
* sizeof (struct id_unit *)))
return (0);
nid = unit + NID_EXTEND;
}
/*
* Allocate unit structure.
*/
if ((un = id_unit[unit]) == NULL) {
if ((un = alloc(struct id_unit, 1)) == NULL)
return (0); /* no memory */
id_unit[unit] = un;
un->un_unit = ID_CSF_PRINT(unit);
}
fac = ID_FAC(unit);
csf = ID_CSF(unit);
if (c->c_unit[fac] != NULL)
return (0); /* unit already configured */
un->un_ipi_addr = csf;
un->un_flags |= IE_INIT_STAT; /* suppress offline messages */
c->c_unit[fac] = un;
un->un_ctlr = c;
/*
* Setup number for I/O stats. Must do before reading label.
*/
if (dkn < DK_NDRIVE)
un->un_dk = dkn++;
else
un->un_dk = -1;
/*
* Get attributes and label.
*/
id_init_unit(un, mode);
if (!(un->un_flags & ID_UN_PRESENT)) {
c->c_unit[fac] = NULL;
un->un_ipi_addr = -1;
un->un_ctlr = NULL;
id_unit[unit] = NULL;
/*
* Give back dk number if no other driver took one.
*/
if (dkn == un->un_dk)
dkn--;
kmem_free((caddr_t)un, sizeof (struct id_unit));
return (0);
}
if (un->un_dk >= 0)
dk_hexunit |= 1 << un->un_dk;
un->un_flags |= ID_ATTACHED;
/*
* We found an online disk. If it has
* never been attached before, we simulate
* the autoconf code and set up the necessary
* data.
*/
for (md = mbdinit; md->md_driver; md++) {
if (md->md_driver == &idcdriver && md->md_unit == unit) {
md->md_alive = 1;
md->md_ctlr = ctlr;
if ((md->md_mc = idcinfo[ctlr]) != NULL) {
md->md_hd = md->md_mc->mc_mh;
md->md_addr = md->md_mc->mc_addr;
}
md->md_dk = un->un_dk;
#ifdef sun4m
(void) add_ipi_drives(md, md->md_driver);
#endif sun4m
break;
}
}
/*
* Print the found message and attach the
* disk to the system.
*/
printf("id%3x at idc%d facility %x\n", un->un_unit, ctlr, ID_FAC(unit));
return (1);
}
/*
* Inspect Physical disk configuration parameter - set unit geometry.
*/
/* ARGSUSED */
static int
id_attr_physdk(q, parm_id, parm, len, unp)
struct ipiq *q;
int parm_id; /* parameter ID (0x5f) */
u_char *parm; /* parameter */
int len; /* length of parameter */
caddr_t unp; /* pointer to id_unit structure */
{
register struct id_unit *un = (struct id_unit *)unp;
register struct physdk_parm *pp = (struct physdk_parm *)parm;
register struct dk_geom *g = &un->un_g;
if (un->un_ctlr->c_ctype == DKC_CDC_9057)
return (id_attr_physdk_cm3(q, parm_id, parm, len, unp));
g->dkg_pcyl = pp->pp_last_cyl + 1; /* number of physical cyls */
g->dkg_ncyl = pp->pp_last_cyl; /* allow one alternate */
g->dkg_acyl = 1;
/* alternate cylinders */
g->dkg_bcyl = 0; /* beginning cylinder */
g->dkg_nhead = pp->pp_nheads; /* tracks per cylinder */
/*
* rot/min = 60 sec/min * 1000000 usec/sec / usec/rot
* but try not to divide by zero.
*/
if (pp->pp_rotper > 0)
g->dkg_rpm = 60 * 1000000 / pp->pp_rotper;
else
g->dkg_rpm = 3600; /* reasonable default */
return (0);
}
/*
* Inspect Physical disk configuration parameter - set unit geometry.
* This version just for CDC CM-3 which has non-standard layout.
*/
/* ARGSUSED */
static int
id_attr_physdk_cm3(q, parm_id, parm, len, unp)
struct ipiq *q;
int parm_id; /* parameter ID (0x5f) */
u_char *parm; /* parameter */
int len; /* length of parameter */
caddr_t unp; /* pointer to id_unit structure */
{
register struct id_unit *un = (struct id_unit *)unp;
register struct physdk_parm_cm3 *pp = (struct physdk_parm_cm3 *)parm;
register struct dk_geom *g = &un->un_g;
g->dkg_pcyl = pp->pp_last_cyl + 1; /* number of physical cyls */
g->dkg_ncyl = pp->pp_last_cyl; /* allow one alternate */
g->dkg_acyl = 1;
/* alternate cylinders */
g->dkg_bcyl = 0; /* beginning cylinder */
g->dkg_nhead = pp->pp_nheads; /* tracks per cylinder */
/*
* rot/min = 60 sec/min * 1000000 usec/sec / usec/rot
* but try not to divide by zero.
*/
if (pp->pp_rotper > 0)
g->dkg_rpm = 60 * 1000000 / pp->pp_rotper;
else
g->dkg_rpm = 3600; /* reasonable default */
return (0);
}
/*
* Inspect Logical Geometry parameter - get logical blocks per track.
* The geometry should be already set from the physical disk configuration
* parameter, so doublecheck with this parameter.
*/
/* ARGSUSED */
static int
id_attr_nblks(q, parm_id, parm, len, unp)
struct ipiq *q;
int parm_id; /* parameter ID (0x5f) */
u_char *parm; /* parameter */
int len; /* length of parameter */
caddr_t unp; /* pointer to id_unit structure */
{
register struct id_unit *un = (struct id_unit *)unp;
register struct numdatblks_parm *pp = (struct numdatblks_parm *)parm;
register struct dk_geom *g = &un->un_g;
int i;
int unit = un->un_unit;
g->dkg_nsect = pp->bpertrk; /* number of blocks per track */
un->un_first_block = pp->strtadr;
if (pp->strtadr != 0) {
printf("id%3x: warning: starting block address nonzero: %d\n",
unit, pp->strtadr);
}
if (pp->bpertrk == 0) {
printf("id%3x: zero blocks per track\n", unit);
return;
}
i = pp->bpercyl / pp->bpertrk; /* tracks per cylinder */
if (i != g->dkg_nhead) {
printf(
"id%3x: inconsistent geometry: blk/cyl %d blk/trk %d heads %d\n",
unit, pp->bpercyl, pp->bpertrk,
g->dkg_nhead);
}
if (pp->bpercyl == 0) {
printf("id%3x: zero blocks per cylinder\n", unit);
return;
}
i = pp->bperpart / pp->bpercyl; /* cylinder count */
if (i > g->dkg_pcyl) {
printf(
"id%3x: inconsistent geometry: tot blks %d blks/cyl %d pcyl %d\n",
unit, pp->bperpart, pp->bpercyl, g->dkg_pcyl);
g->dkg_pcyl = MIN(i, g->dkg_ncyl);
g->dkg_ncyl = g->dkg_pcyl - g->dkg_acyl;
printf("id%3x: setting pcyl %d ncyl %d acyl %d\n",
unit, g->dkg_pcyl, g->dkg_ncyl, g->dkg_acyl);
}
}
/*
* Handle parameter: Size of disk physical blocks.
*/
/* ARGSUSED */
static int
id_phys_bsize(q, parm_id, parm, len, unp)
struct ipiq *q;
int parm_id; /* parameter ID (0x5f) */
u_char *parm; /* parameter */
int len; /* length of parameter */
caddr_t unp; /* pointer to id_unit structure */
{
register struct id_unit *un = (struct id_unit *)unp;
register struct physbsize_parm *pp = (struct physbsize_parm *)parm;
if ((un->un_phys_bsize = pp->pblksize) > 0)
un->un_flags |= ID_FORMATTED;
}
/*
* Handle parameter: Size of disk logical blocks.
*/
/* ARGSUSED */
static int
id_log_bsize(q, parm_id, parm, len, unp)
struct ipiq *q;
int parm_id; /* parameter ID (0x5f) */
u_char *parm; /* parameter */
int len; /* length of parameter */
caddr_t unp; /* pointer to id_unit structure */
{
register struct id_unit *un = (struct id_unit *)unp;
register struct datbsize_parm *pp = (struct datbsize_parm *)parm;
int i;
un->un_log_bsize = pp->dblksize;
for (i = DEV_BSHIFT; i < NBBY * NBPW; i++) {
if (un->un_log_bsize == (1 << i)) {
un->un_log_bshift = i;
break;
}
}
if (i == NBBY * NBPW) {
printf("id%3x: invalid logical block size %d\n",
un->un_unit, un->un_log_bsize);
}
}
/*
* Open routines.
*
* The block and character devices use diferent open routines so that
* the multiple major number support can work.
*/
idbopen(dev, flag)
dev_t dev;
int flag;
{
return (idopen(ID_BMINOR(dev), flag, 0));
}
idcopen(dev, flag)
dev_t dev;
int flag;
{
return (idopen(ID_CMINOR(dev), flag, 1));
}
static
idopen(minor_dev, flag, char_dev)
u_int minor_dev;
int flag;
int char_dev; /* non-zero if called by character device */
{
int unit;
int ctlr;
int csf; /* IPI address */
register struct id_ctlr *c;
register struct id_unit *un;
int s;
un = NULL;
if ((unit = ID_UNIT(minor_dev)) < nid)
un = id_unit[unit];
/*
* If this drive wasn't found by auto configuration or a previous
* open, see if it has become available since then.
*/
if (un == NULL || !(un->un_flags & ID_UN_PRESENT)) {
/*
* Disable IPI interrupts.
*
* This is minor overkill, since all we really need to do
* is lock out disk interrupts while we are doing disk
* commands. However, there is no easy way to tell what
* the disk priority is at this point. Since this situation
* only occurs once at disk spin-up, the extra lock-out
* shouldn't hurt very much.
*/
s = spl_ipi();
/*
* Search for an existing controller.
*/
csf = ID_CTLR_CSF(unit); /* controller's address */
for (ctlr = 0; ctlr < nidc; ctlr++) {
if ((c = id_ctlr[ctlr]) && c->c_ipi_addr == csf &&
((c->c_flags & ID_C_PRESENT) ||
id_init_ctlr(csf, ctlr, ID_ASYNCHWAIT)))
break;
}
/*
* If a controller was found. Try to initialize unit.
*/
if (ctlr < nidc && c && id_findslave(unit, c, ID_ASYNCHWAIT)) {
un = id_unit[unit];
}
(void) splx(s);
}
/*
* By the time we get here the disk is marked present if it exists
* at all. We simply check to be sure the partition being opened
* is nonzero in size. If a raw partition is opened with the
* nodelay flag, we let it succeed even if the size is zero. This
* allows ioctls to later set the geometry and partitions.
*/
if (un && (un->un_flags & ID_UN_PRESENT) &&
(un->un_flags & ID_ATTACHED) &&
IE_STAT_PRESENT(un->un_flags) &&
IE_STAT_PRESENT(un->un_ctlr->c_flags))
{
/*
* If this is the first open, schedule the watchdog routine.
*/
if (!id_watch_started) {
id_watch_started = 1;
id_watch();
}
if (un->un_lpart[ID_LPART(minor_dev)].un_map.dkl_nblk > 0)
return (0);
if (char_dev && (flag & (FNDELAY | FNBIO)))
return (0);
}
return (ENXIO);
}
int (*idstrategy_tstpoint)();
idstrategy(bp)
register struct buf *bp;
{
register int unit; /* unit number */
register struct id_unit *un; /* unit structure */
register struct id_ctlr *c; /* controller struct */
register struct dk_geom *g; /* geometry pointer */
register struct diskhd *dp; /* queue header*/
daddr_t blkno; /* block number */
register struct dk_map *lp; /* logical partition */
int s;
if (idstrategy_tstpoint != NULL) {
if ((*idstrategy_tstpoint)(bp)) {
return;
}
}
if ((unit = ID_BUNIT(bp->b_dev)) >= nid || (un=id_unit[unit]) == NULL) {
bp->b_error = ENXIO;
bp->b_flags |= B_ERROR;
iodone(bp);
return;
}
c = un->un_ctlr;
g = &un->un_g;
lp = &un->un_lpart[ID_LPART(bp->b_dev)].un_map;
if (!(un->un_flags & ID_ATTACHED) || !IE_STAT_PRESENT(un->un_flags) ||
!IE_STAT_PRESENT(c->c_flags))
{
bp->b_error = ENXIO;
bp->b_flags |= B_ERROR;
iodone(bp);
} else if ((blkno = dkblock(bp)) >= lp->dkl_nblk || lp->dkl_nblk == 0) {
if ((blkno != lp->dkl_nblk) || (bp->b_flags & B_READ) == 0) {
bp->b_error = EINVAL;
bp->b_flags |= B_ERROR;
}
bp->b_resid = bp->b_bcount; /* generate EOF return */
iodone(bp);
} else if (un->un_log_bsize == 0) {
iodone(bp);
} else if (bp->b_bcount < un->un_log_bsize) {
bp->b_error = EINVAL; /* not reading a full block */
bp->b_flags |= B_ERROR;
iodone(bp);
} else {
bp->b_cylin = blkno / (g->dkg_nsect * g->dkg_nhead) +
lp->dkl_cylno + g->dkg_bcyl;
/*
* If the operation is off the end of the disk, it's an error.
* This really shouldn't happen since we checked the block
* number against the end of the partition, but the label
* might be wrong.
*/
if (bp->b_cylin >= g->dkg_ncyl) {
bp->b_flags |= B_ERROR;
iodone(bp);
return;
}
/*
* While playing with queues, lock out interrupts.
* If there are already requests queued for this disk,
* sort the new request into the list.
* Then call idstart to send the command if possible.
*/
dp = &un->un_bufs;
s = spl_ipi();
if (dp->b_actf) {
disksort(dp, bp);
} else {
bp->av_forw = NULL;
dp->b_actf = dp->b_actl = bp;
}
(void) idstart(un);
(void) splx(s);
}
}
int idstart_busy; /* statistics */
/*
* This routine starts an operation for a specific unit. It is used only
* in the normal asynchronous case, and is only called if the controller
* is not known to be busy. It is OK to call this routine even if there
* are no outstanding operations, so it is called whenever the unit
* becomes free.
*
* It is used by idintr() and idstrategy(). It is always called
* at disk interrupt priority.
*/
static int
idstart(un)
register struct id_unit *un;
{
register struct diskhd *dp = &un->un_bufs;
register struct buf *bp;
register struct ipiq *q;
register struct id_ctlr *c = un->un_ctlr;
int dk;
daddr_t blkno;
int nblks;
struct un_lpart *lp; /* logical partition */
struct ipiq *rbq; /* read-back request */
while (((q = un->un_wait_q) != NULL || (bp = dp->b_actf) != NULL) &&
IE_STAT_READY(un->un_flags) &&
IE_STAT_READY(c->c_flags) &&
!(un->un_flags & ID_LOCKED))
{
if (c->c_cmd_q >= c->c_max_q ||
c->c_cmd_q_len + c->c_rw_cmd_len >= c->c_max_q_len) {
c->c_flags |= ID_CTLR_WAIT;
idstart_busy++;
break;
}
/*
* First check for a queue already setup but waiting for a
* writeback. If none, setup DMA and get command block.
*/
if (q != NULL) {
un->un_wait_q = NULL;
bp = q->q_buf;
} else if ((q = ipi_setup(un->un_ipi_addr, bp,
c->c_rw_cmd_len, MAX_RESPLEN,
idrestart, 0)) == NULL)
{
if (bp->b_flags & B_ERROR) {
dp->b_actf = bp->av_forw;
if (dp->b_actl == bp)
dp->b_actl = NULL;
iodone(bp);
continue;
}
return (DVMA_RUNOUT); /* setup failed */
}
/*
* If writing and write checking is on for the partition,
* set a flag so that read-back will occur.
* Also, be sure that read-back buffer is setup.
* If it isn't possible to allocate a queue for readback,
* put the write ipiq on a list for later.
* If the controller is capable of doing readback by itself,
* set both IP_WCHK and IP_WCHK_READ to tell id_build_rdwr(),
* to add the verify parameter.
*/
q_related(q) = NULL;
rbq = NULL;
if ((bp->b_flags & B_READ) == 0 &&
(un->un_wchkmap & (1 << ID_LPART(bp->b_dev)))) {
if (c->c_flags & ID_CTLR_VERIFY) {
q->q_flag |= IP_WCHK | IP_WCHK_READ;
} else {
if ((rbq = ipi_setup(un->un_ipi_addr,
id_wchk_buf, c->c_rw_cmd_len,
MAX_RESPLEN, idrestart, 0)) == NULL)
{
if (id_wchk_buf->b_flags & B_ERROR) {
id_printerr(q, "idstart: error setting up readback");
id_wchk_buf->b_flags &=
~B_ERROR;
bp->b_flags |= B_ERROR;
dp->b_actf = bp->av_forw;
if (dp->b_actl == bp)
dp->b_actl = NULL;
iodone(bp);
continue;
}
/*
* Put write request on queue until read
* request can be setup.
*/
q->q_next = NULL;
un->un_wait_q = q;
return (DVMA_RUNOUT); /* setup failed */
}
q_related(rbq) = q;
q_related(q) = rbq;
q->q_flag |= IP_WCHK;
}
}
/*
* Take the buffer off the queue for this disk.
*/
dp->b_actf = bp->av_forw;
if (dp->b_actl == bp)
dp->b_actl = NULL;
/*
* If the transfer size would take it past the end of the
* partition, trim it down. Also trim it down to a multiple
* of the block size.
*/
blkno = dkblock(bp);
lp = &un->un_lpart[ID_LPART(bp->b_dev)];
nblks = NBLKS(bp->b_bcount, un);
if (blkno + nblks > lp->un_map.dkl_nblk)
nblks = lp->un_map.dkl_nblk - blkno;
bp->b_resid = bp->b_bcount - (nblks << un->un_log_bshift);
/*
* Map block number within partition to real block number.
*/
blkno += lp->un_blkno;
q->q_errblk = (int)blkno;
/*
* Build the IPI command packet.
*/
id_build_rdwr(q, un, blkno, nblks); /* form command */
/*
* Build readback command if needed.
*/
if (rbq != NULL)
id_build_rdwr(rbq, un, blkno, nblks);
/*
* Update counts of outstanding commands.
*/
un->un_cmd_q++;
c->c_cmd_q++;
c->c_cmd_q_len += c->c_rw_cmd_len;
/*
* Send command.
*/
ipi_start(q, (long)0, idintr);
/*
* Update iostat statistics.
*/
if ((dk = un->un_dk) >= 0) {
dk_busy |= 1 << dk;
dk_seek[dk]++;
dk_xfer[dk]++;
if (bp->b_flags & B_READ)
dk_read[dk]++;
dk_wds[dk] += bp->b_bcount >> 6;
}
}
/*
* If the unit or controller has gone away, give errors for all
* queued bufs.
*/
if (!IE_STAT_PRESENT(c->c_flags) || !IE_STAT_PRESENT(un->un_flags)) {
while ((bp = dp->b_actf) != NULL) {
dp->b_actf = bp->av_forw;
if (dp->b_actl == bp)
dp->b_actl = NULL;
bp->b_error = ENXIO;
bp->b_flags |= B_ERROR;
iodone(bp);
}
}
return (0);
}
/*
* Call idstart for any disks that have queued requests.
* Used as a callback routine from ipi_setup. Called when
* resources become available.
*
* Returns non-zero if any commands could not be restarted.
*/
struct id_restart_trace {
int un;
int res;
caddr_t arg;
int filler;
};
#define ID_RESTART_NTRACE 1024
struct id_restart_trace id_restart_trace[ID_RESTART_NTRACE];
struct id_restart_trace *id_restart_ptr = id_restart_trace;
static int
idrestart(arg)
caddr_t arg; /* controller pointer or NULL for all controllers */
{
struct id_unit *un;
struct id_ctlr *c = (struct id_ctlr *)arg;
register int s;
register int stat = 0;
int unit;
static int next_unit;
s = spl_ipi();
unit = next_unit;
do {
if (++unit >= nid)
unit = 0;
if ((un = id_unit[unit]) && (c == NULL || un->un_ctlr == c) &&
(un->un_bufs.b_actf || un->un_wait_q)) {
stat = idstart(un);
id_restart_ptr->un = un->un_unit;
id_restart_ptr->res = stat;
id_restart_ptr->arg = arg;
id_restart_ptr++;
if (id_restart_ptr >=
&id_restart_trace[ID_RESTART_NTRACE])
id_restart_ptr = id_restart_trace;
if (stat != 0 && c == NULL)
break;
}
} while (unit != next_unit);
next_unit = unit;
(void) splx(s);
return (stat);
}
/*
* Build a read/write command for request. Ipi_setup has already been called.
*/
static void
id_build_rdwr(q, un, blkno, nblks)
struct ipiq *q; /* setup request */
struct id_unit *un; /* unit structure */
daddr_t blkno; /* absolute block number */
int nblks; /* length in blocks */
{
register struct ipi3header *ip;
union packet {
u_char *pp; /* pointer to next packet byte */
u_long *lp; /* pointer parm len, id, and pad) */
struct cmdx_parm *cxp; /* pointer to command extent parm */
} pu;
q->q_dev = (caddr_t)un;
q->q_dma_len = nblks << un->un_log_bshift;
/*
* Form IPI-3 Command packet.
*/
ip = (struct ipi3header *)q->q_cmd;
if (q->q_buf->b_flags & B_READ) {
ip->hdr_opcode = IP_READ;
} else {
ip->hdr_opcode = IP_WRITE;
}
ip->hdr_mods = IP_OM_BLOCK;
/*
* fill in command extent (block count and block address).
*/
pu.pp = (u_char *)ip + sizeof (struct ipi3header);
*pu.lp++ = (sizeof (struct cmdx_parm)+1) << 8 | CMD_EXTENT;
pu.cxp->cx_count = nblks;
pu.cxp->cx_addr = blkno;
pu.pp += sizeof (struct cmdx_parm);
/*
* Add Transfer parameter if a verify is requested.
* Form the three bytes (plus pad byte) in one word.
* The combination of IP_WCHK and IP_WCHK_READ flags is used to
* indicate that this is desired, and these flags are cleared
* after the parameter is added.
*/
if ((q->q_flag & (IP_WCHK | IP_WCHK_READ)) == (IP_WCHK | IP_WCHK_READ))
{
*pu.lp++ = 2 << 16 | XFER_PARM << 8 | XFER_VERIFY;
q->q_flag &= ~(IP_WCHK | IP_WCHK_READ);
}
/*
* Fill in the transfer notification parameter if needed.
* Note that this may leave pu.pp non-word-aligned.
*/
if (q->q_tnp_len == sizeof (caddr_t)) {
*pu.lp++ = (sizeof (caddr_t)+1) << 8 | XFER_NOTIFY;
*pu.lp++ = * (u_long *) q->q_tnp;
} else if (q->q_tnp_len > 0) {
*pu.pp++ = q->q_tnp_len + 1; /* parameter length */
*pu.pp++ = XFER_NOTIFY; /* parameter ID */
bcopy(q->q_tnp, (caddr_t)pu.pp, q->q_tnp_len);
pu.pp += q->q_tnp_len;
}
/*
* Form packet length based on where the pointer ended up.
*/
ip->hdr_pktlen = (pu.pp - (u_char *)ip) - sizeof (ip->hdr_pktlen);
}
/*
* Main Interrupt handler - used only for commands issued by idstart().
*/
static void
idintr(q)
register struct ipiq *q;
{
register struct id_unit *un;
register struct id_ctlr *c;
register struct buf *bp;
int started = 0;
int done = 0;
int flags;
int dk;
int s;
if (q) {
bp = q->q_buf;
c = (struct id_ctlr *)q->q_ctlr;
if ((un = (struct id_unit *)q->q_dev) == NULL) {
printf("idintr: bad rupt. NULL q_dev q %x.\n", q);
id_printerr(q, "idintr: bad rupt NULL q_dev\n");
return;
}
/*
* Check for missing interrupt indication before decrementing
* queue counts, since this isn't a completion.
*/
if (q->q_result == IP_MISSING) {
id_missing_req(q);
return;
}
if (--un->un_cmd_q == 0 && (un->un_flags & ID_WANTED))
wakeup((caddr_t)un);
c->c_cmd_q--;
c->c_cmd_q_len -= c->c_rw_cmd_len;
if (c->c_cmd_q_len < 0) {
id_printerr(q, "idintr: neg c_cmd_q_len");
c->c_cmd_q_len = 0;
}
switch (q->q_result) {
case IP_SUCCESS:
/*
* If successful, start any waiting commands right away.
*/
if ((q->q_flag & IP_WCHK) == 0) {
s = spl_ipi();
(void) idstart(un);
(void) splx(s);
started = 1;
}
done = 1;
break;
case IP_ERROR:
case IP_COMPLETE:
flags = id_error_parse(q, ipi_err_table,
id_error, c, un, 0);
done = 1;
if ((flags & IE_RETRY)) {
id_q_retry(q);
done = 0;
} else if ((flags & IE_CMD) == 0) { /* non fatal */
q->q_result = IP_SUCCESS;
} else if (bp) {
bp->b_flags |= B_ERROR;
}
break;
case IP_RETRY:
id_q_retry(q);
break;
default:
if (bp)
bp->b_flags |= B_ERROR;
done = 1;
break;
}
if (done) {
/*
* If a read back must be done on this buffer,
* start it now, and delay the completion of the
* write request until the readback completes.
*/
if ((q->q_flag & IP_WCHK) &&
q->q_result == IP_SUCCESS) {
id_readback(q);
} else if (q->q_flag & IP_WCHK_READ) {
struct ipiq *rbq = q;
/*
* This is the completion of a read-back.
*/
q = q_related(q);
bp = q->q_buf;
if (rbq->q_result == IP_SUCCESS) {
ipi_free(rbq);
ipi_free(q);
if (bp)
iodone(bp);
} else if (rbq->q_result == IP_RETRY_FAILED) {
ipi_free(rbq);
ipi_free(q);
if (bp) {
bp->b_flags |= B_ERROR;
iodone(bp);
}
} else {
id_printerr(q,
"readback failed. retrying write");
id_q_retry(q);
}
} else {
/*
* Normal (non-readback) completion.
*
* Since ipi_free may do cache flushes to make
* CPU and I/O caches consistent, must do it
* before calling iodone().
*/
ipi_free(q);
if (bp)
iodone(bp);
}
}
if (c->c_flags & ID_CTLR_WAIT) {
c->c_flags &= ~ID_CTLR_WAIT;
(void)idrestart((caddr_t)c);
} else if (!started) {
s = spl_ipi();
(void) idstart(un);
(void) splx(s);
}
un->un_idle_time = 0;
/*
* If nothing queued or running on unit, mark it not busy
* for iostats.
*/
if (un->un_cmd_q == 0 && (dk = un->un_dk) >= 0 &&
un->un_bufs.b_actf == NULL)
dk_busy &= ~(1 << dk);
}
}
/*
* Send IPI command.
*
* Mode selects whether driver should wait by polling or sleeping or not
* wait at all. Returns non-zero on error or poll timeout.
*/
static int
id_send_cmd(q, flags, mode)
struct ipiq *q;
long flags;
int mode;
{
struct id_unit *un;
struct id_ctlr *c;
if ((un = (struct id_unit *)q->q_dev) != NULL) {
if (!IE_STAT_READY(un->un_flags)) {
return (ENXIO);
}
un->un_cmd_q++;
}
if ((c = (struct id_ctlr *)q->q_ctlr) != NULL) {
if (!IE_STAT_READY(c->c_flags)) {
if (un)
un->un_cmd_q--;
return (ENXIO);
}
c->c_cmd_q++;
c->c_cmd_q_len += q->q_cmd->hdr_pktlen + sizeof (u_short);
}
switch (mode) {
case ID_SYNCH:
ipi_start(q, flags | IP_SYNC, id_cmd_intr);
if (ipi_poll(q, (long)ID_POLL_TIMEOUT) == 0) {
id_printerr(q, "poll timeout");
return (EIO);
}
break;
case ID_ASYNCHWAIT:
ipi_start(q, flags | IP_WAKEUP, id_cmd_intr);
while (q->q_result == IP_INPROGRESS || q->q_result == IP_RETRY)
(void) sleep((caddr_t)q, PRIBIO);
break;
case ID_ASYNCH:
ipi_start(q, flags, id_cmd_intr);
break;
}
return (0);
}
/*
* Auxilliary Interrupt handler - used for commands not issued via idstart().
*
* NOTE: This interface doesn't return sys/errno.h type error codes in the
* buffer. It uses the codes defined in idvar.h instead. Since this
* is used only by id_ioctl_cmd and related routines, this is OK.
*/
static void
id_cmd_intr(q)
register struct ipiq *q;
{
register struct id_unit *un;
register struct id_ctlr *c;
register struct buf *bp;
int err;
int flags;
int len;
if (q) {
/*
* Check for missing interrupt indication before decrementing
* queue counts, since this isn't a completion.
*/
if (q->q_result == IP_MISSING) {
id_missing_req(q);
return;
}
err = IDE_NOERROR;
bp = q->q_buf;
c = (struct id_ctlr *)q->q_ctlr;
if ((un = (struct id_unit *)q->q_dev) != NULL &&
--un->un_cmd_q == 0 &&
(un->un_flags & ID_WANTED))
wakeup((caddr_t)un);
c->c_cmd_q--;
if ((len = q->q_cmd->hdr_pktlen) > 0)
c->c_cmd_q_len -= len + sizeof (u_short);
if (c->c_cmd_q_len < 0) {
id_printerr(q, "id_cmd_intr: ctlr cmd_q_len negative");
c->c_cmd_q_len = 0;
}
switch (q->q_result) {
case IP_SUCCESS:
if (q->q_retry)
err = IDE_RETRIED; /* not an error */
/* XXX - need to know more about the error that caused retry. */
break;
case IP_ERROR:
case IP_COMPLETE:
flags = id_error_parse(q, ipi_err_table, id_error,
c, un, 0);
if ((flags & IE_CMD) == 0 &&
(q->q_flag & IP_DIAGNOSE) == 0)
{
q->q_result = IP_SUCCESS;
}
if (flags & IE_CORR) {
err = IDE_CORR;
} else if (flags & IE_UNCORR) {
err = IDE_UNCORR;
} else {
err = IDE_FATAL;
}
break;
case IP_RETRY:
id_q_retry(q);
return; /* don't do wakeup */
default:
err = IDE_FATAL;
break;
}
if (err && bp) {
bp->b_flags |= B_ERROR;
bp->b_error = err;
}
if (c->c_flags & ID_CTLR_WAIT) {
c->c_flags &= ~ID_CTLR_WAIT;
(void)idrestart((caddr_t)c);
}
if (q->q_flag & IP_WAKEUP)
wakeup((caddr_t)q);
if (un) {
un->un_idle_time = 0;
}
}
}
/*
* Asynchronous interrupt handler
*/
static void
idasync(q)
register struct ipiq *q; /* interrupt info */
{
register int fac;
register struct id_ctlr *c; /* device structure */
struct id_unit *un;
struct id_unit new_unit; /* temporary unit structure */
c = (struct id_ctlr *)q->q_ctlr;
if ((fac = q->q_resp->hdr_facility) != IPI_NO_ADDR && fac < IDC_NUNIT) {
un = c->c_unit[fac];
/*
* If the unit structure wasn't allocated, this might be
* a new device coming on-line. Use a temporary unit
* structure to make the messages come out right. The real
* unit structure will be allocated when the disk is opened.
*/
if (un == NULL) {
bzero((caddr_t)&new_unit, sizeof (new_unit));
un = &new_unit;
un->un_ipi_addr = q->q_csf;
un->un_unit = IPI_CHAN(q->q_csf) << 8 |
IPI_SLAVE(q->q_csf) << 4 | fac;
un->un_ctlr = c;
un->un_dk = -1;
c->c_unit[fac] = un;
}
q->q_dev = (caddr_t)un;
(void) id_error_parse(q, ipi_err_table, id_error, c, un, 0);
if (un == &new_unit) {
q->q_dev = NULL;
c->c_unit[fac] = NULL;
}
} else
(void) id_error_parse(q, ipi_err_table, id_error, c,
(struct id_unit *)NULL, 0);
}
/*
* Error handler for all kinds of interrupts. Called through id_error_parse.
* Handles asynchronous interrupts also.
*/
static int
id_error(q, c, un, code, flags, msg, parm)
struct ipiq *q; /* request containing response */
struct id_ctlr *c; /* controller */
struct id_unit *un; /* unit - may be NULL */
int code; /* error result/action code */
int flags; /* error flags */
char *msg; /* message */
u_char *parm; /* raw parameter (incl ID/len) */
{
int new_flags = 0;
u_int old_stat;
u_int *fp; /* flags pointer */
u_int change_mask; /* online/offline status change */
if ((flags & (IE_MSG | IE_PRINT)) && !(q->q_flag & IP_SILENT))
printf("%s. ", msg);
if ((flags & IE_FAC) && un == NULL) {
printf("idc%d: facility status for unknown unit\n", c->c_ctlr);
new_flags |= IE_PRINT;
}
switch (code) {
case 0: /* nothing */
break;
case IE_RESP_EXTENT: /* response extent parameter */
(void) id_respx(q, 0, (struct respx_parm *)(parm + 2), 0,
q->q_buf);
break;
case IE_MESSAGE: /* for microcode messages */
{
struct msg_ucode_parm *p;
char m, *cp;
int i;
p = (struct msg_ucode_parm *)&parm[2];
if (p->mu_flags & IPMU_FAIL_MSG)
printf("idc%d: ctlr failure fru %x message: '",
p->mu_u.mu_m.mu_fru, c->c_ctlr);
else
printf("idc%d: ctlr message: '", c->c_ctlr);
cp = p->mu_u.mu_m.mu_msg; /* first char of msg */
i = parm[0] + 1 - (cp - (char *)parm); /* msg len */
while (i-- > 0) {
m = *cp++;
printf("%c", m == '\n' ? ' ' : m);
}
printf("'\n");
}
break;
case IE_STAT_OFF: /* unit or controller went offline */
case IE_STAT_ON: /* unit or controller went online */
change_mask = (flags & IE_STAT_MASK);
if (flags & IE_FAC) {
if (un)
fp = &un->un_flags;
else
break;
} else {
fp = &c->c_flags;
}
old_stat = *fp;
if (code == IE_STAT_OFF)
*fp &= ~change_mask;
else
*fp |= change_mask;
/*
* Print a message if the status has changed and a message
* hasn't been already printed due to the flags settings.
* However, don't print this message if the unit/ctlr flags
* or the passed-in flags indicate that this is the
* initial status for the unit/ctlr.
*/
if (!((flags | old_stat) & IE_INIT_STAT) &&
old_stat != *fp && !(flags & (IE_MSG | IE_PRINT)))
{
id_printerr(q, msg);
}
break;
case IE_IML: /* reload slave */
id_printerr(q, "id_error: slave IML not supported"); /* XXX */
new_flags |= IE_RETRY; /* retry request */
break;
case IE_RESET: /* reset slave */
id_printerr(q, "id_error: slave reset not supported"); /* XXX */
new_flags |= IE_RETRY; /* retry request */
break;
case IE_QUEUE_FULL: /* buffer limits exceeded */
id_printerr(q, "id_error: full queue: not handled"); /* XXX */
new_flags |= IE_RETRY; /* retry request */
break;
case IE_READ_LOG: /* log full */
id_printerr(q, "id_error: log read not supported"); /* XXX */
new_flags |= IE_RETRY; /* retry request */
break;
case IE_ABORTED: /* command aborted */
id_printerr(q, "id_error: aborted command not supported"); /* XXX */
new_flags |= IE_DUMP | IE_CMD; /* dump cmd/resp */
break;
default:
break;
}
return (new_flags);
}
int
idsize(dev)
dev_t dev;
{
int unit;
register struct id_unit *un;
/*
* Call open in case the device wasn't configured yet.
*/
if (idbopen(dev, 0))
return (-1);
if ((unit = ID_BUNIT(dev)) >= nid || (un = id_unit[unit]) == NULL ||
!(un->un_flags & ID_ATTACHED))
return (-1);
return ((int)un->un_lpart[ID_LPART(dev)].un_map.dkl_nblk);
}
/*
* Perform logical disk section mapping.
* Map logical block number into physical block number.
*/
static daddr_t
id_map(minor_dev, blkno, nblk)
u_int minor_dev;
daddr_t blkno, nblk;
{
register struct id_unit *un = id_unit[ID_UNIT(minor_dev)];
register struct un_lpart *lp;
if (un == NULL || !(un->un_flags & ID_UN_PRESENT))
return (-1);
lp = &un->un_lpart[ID_LPART(minor_dev)];
if (blkno >= lp->un_map.dkl_nblk || (blkno+nblk) > lp->un_map.dkl_nblk)
return (-1);
/*
* Offset into the correct partition.
*/
return (blkno + lp->un_blkno);
}
/*
* This routine dumps memory to the disk. It assumes that the memory has
* already been mapped into mainbus space. It is called at disk interrupt
* priority when the system is in trouble.
*/
iddump(dev, addr, blkno, nblk)
dev_t dev;
caddr_t addr;
daddr_t blkno, nblk;
{
int unit;
register struct id_unit *un;
struct ipiq *q;
int errno = 0;
daddr_t rblkno; /* real block number */
struct buf dbuf;
/*
* Check to make sure the operation makes sense.
*/
if ((unit = ID_BUNIT(dev)) >= nid || (un = id_unit[unit]) == NULL ||
!(un->un_flags & ID_UN_PRESENT))
return (ENXIO);
bzero((caddr_t)&dbuf, sizeof (dbuf));
dbuf.b_un.b_addr = (caddr_t)addr;
dbuf.b_flags = B_BUSY;
dbuf.b_bcount = nblk * DEV_BSIZE;
if (un->un_log_bsize != DEV_BSIZE) {
blkno = (blkno * DEV_BSIZE) >> un->un_log_bshift;
nblk = (nblk * DEV_BSIZE) >> un->un_log_bshift;
}
if ((rblkno = id_map(ID_BMINOR(dev), blkno, nblk)) < 0)
return (EINVAL);
rblkno += un->un_first_block; /* usually zero */
if ((q = ipi_setup(un->un_ipi_addr, &dbuf, un->un_ctlr->c_rw_cmd_len,
MAX_RESPLEN, IPI_NULL, IP_NO_DMA_SETUP)) == NULL)
return (EIO);
/*
* Construct IPI-3 packet.
*/
id_build_rdwr(q, un, rblkno, (int)nblk);
/*
* Send command.
*/
if (id_send_cmd(q, (long)0, ID_SYNCH) || q->q_result != IP_SUCCESS)
errno = EIO;
ipi_free(q);
return (errno);
}
static void
id_minphys(bp)
struct buf *bp;
{
if (bp->b_bcount > ID_MAXPHYS)
bp->b_bcount = ID_MAXPHYS;
}
#if !MULT_RBUF
static caddr_t physio_bufs;
#endif
/*
* Do a raw read using the unit's raw I/O buffer.
* Called from cdevsw() at normal priority.
*/
int
idread(dev, uio)
dev_t dev;
struct uio *uio;
{
register int unit = ID_CUNIT(dev);
#if !MULT_RBUF
struct buf *bp;
int err;
#endif
if (unit >= nid)
return (ENXIO);
if ((uio->uio_fmode & FSETBLK) == 0 &&
uio->uio_offset % DEV_BSIZE != 0)
return (EINVAL);
#if MULT_RBUF
return (physio(idstrategy, NULL, ID_BLKDEV(dev), B_READ,
id_minphys, uio));
#else
bp = (struct buf *)
kmem_fast_zalloc(&physio_bufs, sizeof (struct buf), 1);
bp->b_flags = 0;
err = physio(idstrategy, bp, ID_BLKDEV(dev), B_READ, id_minphys, uio);
kmem_fast_free(&physio_bufs, (caddr_t)bp);
return (err);
#endif
}
/*
* Do a raw write using the special per unit buffer.
* Called from cdevsw() at normal priority.
*/
int
idwrite(dev, uio)
dev_t dev;
struct uio *uio;
{
register int unit = ID_CUNIT(dev);
#if !MULT_RBUF
struct buf *bp;
int err;
#endif
if (unit >= nid)
return (ENXIO);
if ((uio->uio_fmode & FSETBLK) == 0 &&
uio->uio_offset % DEV_BSIZE != 0)
return (EINVAL);
#if MULT_RBUF
return (physio(idstrategy, NULL, ID_BLKDEV(dev), B_WRITE,
id_minphys, uio));
#else
bp = (struct buf *)
kmem_fast_zalloc(&physio_bufs, sizeof (struct buf), 1);
bp->b_flags = 0;
err = physio(idstrategy, bp, ID_BLKDEV(dev), B_WRITE, id_minphys, uio);
kmem_fast_free(&physio_bufs, (caddr_t)bp);
return (err);
#endif
}
/*
* This routine implements the ioctl calls for the disk.
* It is called from the device switch at normal priority.
*/
/* ARGSUSED */
idioctl(dev, cmd, data, flag)
dev_t dev;
int cmd, flag;
caddr_t data;
{
register struct id_unit *un = id_unit[ID_CUNIT(dev)];
struct id_ctlr *c;
register union id_ptr { /* union for usages of third arg */
struct dk_info *inf;
struct dk_conf *conf;
struct dk_type *typ;
struct dk_cmd *com;
struct dk_diag *diag;
struct dk_geom *geom;
struct dk_map *map;
int *wchk;
caddr_t data;
} p;
int i, s, err;
p.data = data; /* set union to fourth argument */
err = 0; /* no error */
if (un == NULL)
return (ENXIO);
c = un->un_ctlr;
switch (cmd) {
/*
* Return info concerning the controller.
*/
case DKIOCINFO:
p.inf->dki_ctlr = i = c->c_ipi_addr;
p.inf->dki_unit = IPI_SLAVE(i);
p.inf->dki_ctype = c->c_ctype;
#define ID_DKI_FLAGS (DKI_FMTCYL | DKI_HEXUNIT)
p.inf->dki_flags = ID_DKI_FLAGS;
break;
/*
* Return configuration info
*/
case DKIOCGCONF:
(void) strncpy(p.conf->dkc_cname, idcdriver.mdr_cname,
DK_DEVLEN);
p.conf->dkc_ctype = c->c_ctype;
p.conf->dkc_flags = ID_DKI_FLAGS;
p.conf->dkc_cnum = c->c_ctlr;
p.conf->dkc_addr = i = un->un_ipi_addr;
p.conf->dkc_slave = IPI_FAC(i);
p.conf->dkc_unit = ID_CUNIT(dev);
p.conf->dkc_space = idcinfo[c->c_ctlr]->mc_space;
p.conf->dkc_prio = c->c_intpri;
p.conf->dkc_vec = 0;
(void) strncpy(p.conf->dkc_dname, idcdriver.mdr_dname,
DK_DEVLEN);
break;
/*
* Return drive info
*/
case DKIOCGTYPE:
p.typ->dkt_drtype = 0; /* drive type not used */
p.typ->dkt_hsect = un->un_g.dkg_nsect;
p.typ->dkt_promrev = 0;
p.typ->dkt_drstat = 0;
break;
/*
* Set drive info -- only affects drive type.
* This doesn't make sense for IPI disks. The disk
* identifies itself. Ignore without returning error.
*/
case DKIOCSTYPE:
break;
/*
* Return the geometry of the specified unit.
*/
case DKIOCGGEOM:
*p.geom = un->un_g;
break;
/*
* Set the geometry of the specified unit.
* Currently only the number of cylinders is expected to change from
* what was given in the label or attributes.
*/
case DKIOCSGEOM:
s = spl_ipi();
un->un_g = *p.geom; /* set geometry */
id_update_map(un); /* fix partition table - just in case */
(void) splx(s);
break;
/*
* Return the map for the specified logical partition.
*/
case DKIOCGPART:
*p.map = un->un_lpart[ID_LPART(dev)].un_map;
break;
/*
* Set the map for the specified logical partition.
* We raise the priority just to make sure an interrupt
* doesn't come in while the map is half updated.
*/
case DKIOCSPART:
s = spl_ipi();
un->un_lpart[ID_LPART(dev)].un_map = *p.map;
id_update_map(un);
(void) splx(s);
break;
/*
* Return the map for all logical partitions.
*/
case DKIOCGAPART:
for (i = 0; i < ID_NLPART; i++)
p.map[i] = un->un_lpart[i].un_map;
break;
/*
* Set the map for all logical partitions. We raise
* the priority just to make sure an interrupt doesn't
* come in while the map is half updated.
*/
case DKIOCSAPART:
s = spl_ipi();
for (i = 0; i < ID_NLPART; i++)
un->un_lpart[i].un_map = p.map[i];
id_update_map(un);
(void) splx(s);
break;
/*
* Generic IPI command
*/
case DKIOCSCMD:
err = id_ioctl_cmd(un, p.com);
break;
/*
* Get diagnostics
*/
case DKIOCGDIAG:
*p.diag = un->un_diag;
break;
/*
* Handle Write Check: turn on or off verification (per partition).
*/
case DKIOCWCHK:
if (!suser())
return (u.u_error);
if (un->un_lpart[ID_LPART(dev)].un_map.dkl_nblk == 0)
return (ENXIO);
i = *p.wchk;
s = spl_ipi();
*p.wchk = ((un->un_wchkmap & (1<<ID_LPART(dev))) != 0);
if (i) {
un->un_wchkmap |= (1 << ID_LPART(dev));
(void) splx(s);
id_alloc_wchk();
log(LOG_INFO, "id%3x%c: write check enabled\n",
un->un_unit, 'a' + ID_LPART(dev));
} else {
un->un_wchkmap &= ~(1 << ID_LPART(dev));
(void) splx(s);
log(LOG_INFO, "id%3x%c: write check disabled\n",
un->un_unit, 'a' + ID_LPART(dev));
}
break;
default:
err = ENOTTY;
break;
}
return (err);
}
/*
* IPI commands via ioctl interface.
*/
static int
id_ioctl_cmd(un, com)
struct id_unit *un;
struct dk_cmd *com;
{
int s;
int flags = 0;
long ipi_flags;
u_char opcode;
int opmod;
int err = 0;
struct buf *bp = NULL;
faultcode_t fault_err;
if (id_debug)
printf("id_ioctl_cmd: cmd %x flags %x blkno %x secnt %x bufaddr %x buflen %x\n",
com->dkc_cmd, com->dkc_flags, com->dkc_blkno, com->dkc_secnt,
com->dkc_bufaddr, com->dkc_buflen); /* XXX - debug */
opcode = com->dkc_cmd; /* IPI-3 opcode */
opmod = com->dkc_cmd >> 8; /* opcode modifiers */
/*
* Check the parameters.
*/
switch (opcode) {
case IP_READ:
flags |= B_READ;
case IP_WRITE:
if (com->dkc_buflen != (com->dkc_secnt << un->un_log_bshift))
return (EINVAL);
break;
case IP_READ_DEFLIST:
flags |= B_READ;
/* fallthrough */
case IP_WRITE_DEFLIST:
if (com->dkc_buflen == 0)
return (EINVAL);
break;
case IP_FORMAT:
case IP_REALLOC:
if (com->dkc_buflen != 0)
return (EINVAL);
break;
default:
return (EINVAL);
}
/*
* Don't allow more than max at once.
*/
if (com->dkc_buflen > ID_MAXBUFSIZE)
return (EINVAL);
s = spl_ipi();
/*
* If this command wants exclusive use of the drive, or if there
* is another exclusive user, wait for it.
*/
while (un->un_flags & ID_LOCKED) {
un->un_flags |= ID_WANTED;
(void) sleep((caddr_t)un, PZERO+1); /* interruptible sleep */
un->un_flags &= ~ID_WANTED;
}
if (com->dkc_flags & DK_ISOLATE) {
un->un_flags |= ID_LOCKED; /* prevent further commands. */
while (un->un_cmd_q != 0) {
un->un_flags |= ID_WANTED;
(void) sleep((caddr_t)un, PRIBIO);
un->un_flags &= ~ID_WANTED;
}
}
/*
* If this command moves data, we need to map
* the user buffer into DVMA or IPI space.
*/
if (com->dkc_buflen > 0) {
/*
* Get a raw I/O buf.
*/
bp = alloc(struct buf, 1);
if (bp == NULL) {
err = ENOMEM;
goto errout;
}
bp->b_flags = B_BUSY | B_PHYS | flags;
bp->b_un.b_addr = com->dkc_bufaddr;
bp->b_bcount = com->dkc_buflen;
bp->b_resid = 0;
bp->b_blkno = com->dkc_blkno;
bp->b_proc = u.u_procp;
u.u_procp->p_flag |= SPHYSIO;
/*
* Fault lock the address range of the buffer.
*/
fault_err = as_fault(u.u_procp->p_as,
bp->b_un.b_addr, (u_int)bp->b_bcount,
F_SOFTLOCK, (flags & B_READ) ? S_READ : S_WRITE);
if (fault_err) {
if (FC_CODE(fault_err) == FC_OBJERR)
err = FC_ERRNO(fault_err);
else
err = EFAULT;
} else if (buscheck(bp) < 0) {
err = EFAULT;
}
}
/*
* Set IPI layer flags.
*/
ipi_flags = 0;
if (com->dkc_flags & DK_DIAGNOSE)
ipi_flags |= IP_DIAGNOSE;
if (com->dkc_flags & DK_SILENT)
ipi_flags |= IP_SILENT;
/*
* Execute the command.
*/
if (err == 0) {
switch (opcode) {
case IP_FORMAT:
err = id_format(un, com->dkc_blkno, com->dkc_secnt,
opmod);
break;
case IP_READ:
case IP_WRITE:
err = id_rdwr(un, bp, com->dkc_blkno, ipi_flags);
break;
case IP_READ_DEFLIST:
case IP_WRITE_DEFLIST:
err = id_rdwr_deflist(un, bp, opmod);
break;
case IP_REALLOC:
err = id_realloc(un, com->dkc_blkno, com->dkc_secnt,
opmod);
break;
case IP_ATTRIBUTES:
default:
err = EINVAL;
break;
}
}
/*
* Release memory and DVMA resources.
*/
if (com->dkc_buflen > 0 && fault_err == 0) {
(void) as_fault(u.u_procp->p_as, bp->b_un.b_addr,
(u_int)bp->b_bcount, F_SOFTUNLOCK,
(flags & B_READ) ? S_READ : S_WRITE);
}
errout:
if (err && (com->dkc_flags & DK_DIAGNOSE)) {
un->un_diag.dkd_errcmd = com->dkc_cmd;
if (bp && (bp->b_flags & B_ERROR)) {
un->un_diag.dkd_errsect = bp->b_blkno;
un->un_diag.dkd_severe = IDE_SEV(bp->b_error);
un->un_diag.dkd_errno = bp->b_error;
} else {
un->un_diag.dkd_errsect = com->dkc_blkno;
un->un_diag.dkd_severe = DK_FATAL;
un->un_diag.dkd_errno = IDE_FATAL;
}
}
if (id_debug && err) { /* XXX */
printf("id_ioctl_cmd: id%3x err %d (0x%x)\n", un->un_unit, err, err);
}
if (bp)
kmem_free((caddr_t)bp, sizeof (struct buf));
/*
* If we locked it, unlock it.
*/
if (com->dkc_flags & DK_ISOLATE) {
un->un_flags &= ~ID_LOCKED; /* prevent further commands. */
if (un->un_flags & ID_WANTED)
wakeup((caddr_t)un);
}
(void) splx(s);
return (err);
}
/*
* This routine verifies that the block read is indeed a disk label.
*/
static
islabel(unit, l)
u_int unit;
register struct dk_label *l;
{
if (l->dkl_magic != DKL_MAGIC)
return (0);
if (!ck_cksum(l)) {
printf("id%3x: corrupt label\n", unit);
return (0);
}
return (1);
}
/*
* This routine checks the checksum of the disk label.
* It is used by islabel().
*/
static
ck_cksum(l)
register struct dk_label *l;
{
register short *sp, sum = 0;
register short count = sizeof (struct dk_label)/sizeof (short);
sp = (short *)l;
while (count--)
sum ^= *sp++;
return (sum ? 0 : 1);
}
/*
* This routine puts the label information into the various parts of
* the unit structure. It is always called at disk interrupt priority.
*/
static
uselabel(un, l)
register struct id_unit *un;
register struct dk_label *l;
{
register struct dk_geom *g = &un->un_g;
int i, intrlv;
/*
* Print out the disk description.
*/
if (l->dkl_magic == DKL_MAGIC)
printf("id%3x: <%s>\n", un->un_unit, l->dkl_asciilabel);
/*
* Check the label geometry against the geometry values read
* from the physical disk configuration attribute parameter.
* If they don't match, take the ones from the label, since they
* affect conversion of the partition starting cylinder to block number.
*/
g->dkg_acyl = g->dkg_pcyl - g->dkg_ncyl; /* for checking */
if (l->dkl_ncyl > g->dkg_ncyl || l->dkl_pcyl > g->dkg_pcyl ||
l->dkl_acyl < g->dkg_acyl ||
g->dkg_nhead != l->dkl_nhead ||
g->dkg_nsect != l->dkl_nsect ||
g->dkg_rpm != l->dkl_rpm) {
printf(
"id%3x: warning: label doesn't match IPI attribute info\n",
un->un_unit);
printf(
"id%3x: label ncyl %d pcyl %d acyl %d head %d sect %d rpm %d\n",
un->un_unit, l->dkl_ncyl, l->dkl_pcyl, l->dkl_acyl,
l->dkl_nhead, l->dkl_nsect, l->dkl_rpm);
printf(
"id%3x: geom ncyl %d pcyl %d acyl %d head %d sect %d rpm %d\n",
un->un_unit, g->dkg_ncyl, g->dkg_pcyl, g->dkg_acyl,
g->dkg_nhead, g->dkg_nsect, g->dkg_rpm);
}
g->dkg_intrlv = l->dkl_intrlv;
g->dkg_nhead = l->dkl_nhead;
g->dkg_nsect = l->dkl_nsect;
g->dkg_rpm = l->dkl_rpm;
g->dkg_ncyl = l->dkl_ncyl;
g->dkg_pcyl = l->dkl_pcyl;
g->dkg_acyl = l->dkl_acyl;
/*
* Fill in the logical partition map.
*/
for (i = 0; i < NDKMAP; i++)
un->un_lpart[i].un_map = l->dkl_map[i];
id_update_map(un); /* update map with geometry info */
/*
* Set up data for iostat.
*/
if (un->un_dk >= 0) {
intrlv = g->dkg_intrlv;
if (intrlv <= 0 || intrlv >= g->dkg_nsect)
intrlv = 1;
dk_bps[un->un_dk] = (60 << un->un_log_bshift)
* g->dkg_nsect / intrlv;
}
un->un_flags |= ID_LABEL_VALID;
}
/*
* Read or write disk data.
*
* The block number is absolute: no patrition mapping is needed.
*
* Returns non-zero error number on failure.
* Calls iodone on buffer when fininshed.
*/
/* ARGUSED */
static
id_rdwr(un, bp, block, ipi_flags)
register struct id_unit *un; /* unit structure pointer */
register struct buf *bp; /* buffer info */
daddr_t block; /* starting physical block number */
long ipi_flags;
{
struct ipiq *q;
int errno = 0; /* error return code */
int nblks;
if ((q = ipi_setup(un->un_ipi_addr, bp, un->un_ctlr->c_rw_cmd_len,
MAX_RESPLEN, IPI_SLEEP, (int)ipi_flags)) == NULL)
return (EIO);
nblks = NBLKS(bp->b_bcount, un);
q->q_errblk = (long)block;
/*
* Construct IPI-3 packet.
*/
id_build_rdwr(q, un, block, nblks);
/*
* Send command.
*/
if ((errno = id_send_cmd(q, (long)IP_ABS_BLOCK, ID_ASYNCHWAIT)) == 0 &&
q->q_result != IP_SUCCESS)
{
bp->b_blkno = (daddr_t)q->q_errblk;
errno = EIO;
}
ipi_free(q);
return (errno);
}
/*
* Format disk.
* If first_block is less than zero, format entire disk.
*/
static
id_format(un, first_block, nblocks, opmod)
register struct id_unit *un; /* unit structure pointer */
daddr_t first_block; /* first block number */
int nblocks; /* block count, all if < 0 */
int opmod; /* opcode modifier */
{
struct ipiq *q;
int errno = 0; /* error return code */
int blk_per_cyl;
struct ipi3header *ip;
int i;
char *cp;
/*
* If a block number range is specified, make sure it is
* on a cylinder boundary.
*/
if (nblocks > 0 || first_block != 0) {
blk_per_cyl = un->un_g.dkg_nsect;
if ((first_block % blk_per_cyl) || (nblocks % blk_per_cyl))
return (EINVAL);
}
if ((q = ipi_setup(un->un_ipi_addr, (struct buf *)NULL, sizeof (*ip),
MAX_RESPLEN, IPI_SLEEP, 0)) == NULL)
return (EIO);
/*
* Form IPI-3 Command packet.
*/
ip = q->q_cmd;
ip->hdr_opcode = IP_FORMAT;
ip->hdr_mods = opmod | IP_OM_BLOCK;
cp = (char *)(ip + 1); /* point past header */
/*
* Insert block size parameter, if used.
*/
if ((un->un_ctlr->c_flags & ID_NO_BLK_SIZE) == 0) {
for (i = (int)(cp + 2); (i % sizeof (long)) != 0; i++)
*cp++ = 0; /* pad */
*cp++ = sizeof (struct bsize_parm) + 1; /* parm + id */
*cp++ = BSIZE_PARM;
((struct bsize_parm *) cp)->blk_size = DEV_BSIZE;
cp += sizeof (struct bsize_parm);
}
/*
* Insert extent parameter, if needed.
*/
if (nblocks > 0 || first_block != 0) {
for (i = (int)(cp + 2); (i % sizeof (long)) != 0; i++)
*cp++ = 0; /* pad */
*cp++ = sizeof (struct cmdx_parm) + 1; /* parm + id */
*cp++ = CMD_EXTENT;
((struct cmdx_parm *) cp)->cx_count = nblocks;
((struct cmdx_parm *) cp)->cx_addr = first_block;
cp += sizeof (struct cmdx_parm);
}
ip->hdr_pktlen = (cp - (char *)ip) - sizeof (ip->hdr_pktlen);
q->q_dev = (caddr_t)un;
q->q_time = 0; /* no timeout */
/*
* Send command.
*/
if ((errno = id_send_cmd(q, (long)IP_ABS_BLOCK, ID_ASYNCHWAIT)) == 0) {
if (q->q_result != IP_SUCCESS) {
printf("id%3x: id_format failed. result %x\n",
un->un_unit, q->q_result);
errno = EIO;
}
}
ipi_free(q);
return (errno);
}
/*
* Read or write defect list.
*/
static
id_rdwr_deflist(un, bp, opmod)
register struct id_unit *un; /* unit structure pointer */
register struct buf *bp; /* buffer */
int opmod; /* opcode modifier */
{
struct ipiq *q;
int errno = 0; /* error return code */
struct ipi3header *ip;
int i;
char *cp;
if ((q = ipi_setup(un->un_ipi_addr, bp, sizeof (*ip),
MAX_RESPLEN, IPI_SLEEP, 0)) == NULL)
return (EIO);
/*
* Form IPI-3 Command packet.
*/
ip = q->q_cmd;
ip->hdr_opcode =
(bp->b_flags & B_READ) ? IP_READ_DEFLIST : IP_WRITE_DEFLIST;
ip->hdr_mods = opmod;
cp = (char *)(ip + 1); /* point past header */
/*
* Add Transfer notification if required.
*/
if (q->q_tnp_len == sizeof (caddr_t)) {
for (i = (int)(cp + 2); (i % sizeof (caddr_t)) != 0; i++)
*cp++ = 0; /* pad */
*cp++ = sizeof (caddr_t) + 1;
*cp++ = XFER_NOTIFY;
* ((caddr_t *) cp)++ = * (caddr_t *) q->q_tnp;
} else if (q->q_tnp_len > 0) {
*cp++ = q->q_tnp_len + 1;
*cp++ = XFER_NOTIFY;
bcopy(q->q_tnp, cp, q->q_tnp_len);
cp += q->q_tnp_len;
}
/*
* Insert Request Parameters as Data Parameter.
*/
*cp++ = 3; /* parameter length */
*cp++ = ATTR_REQPARM; /* request parm parameter */
if (un->un_ctlr->c_ctype == DKC_SUN_IPI1)
*cp++ = RESP_AS_NDATA;
else
*cp++ = RESP_AS_DATA; /* parms as data */
*cp++ = DEFLIST_TRACK; /* track defects list parm */
/*
* Add command extent parameter for controllers that need it.
*/
if (un->un_ctlr->c_ctype == DKC_SUN_IPI1) {
for (i = (int)(cp + 2); (i % sizeof (long)) != 0; i++)
*cp++ = 0; /* pad */
*cp++ = sizeof (struct cmdx_parm) + 1; /* len including ID */
*cp++ = CMD_EXTENT;
((struct cmdx_parm *) cp)->cx_count = bp->b_bcount;
((struct cmdx_parm *) cp)->cx_addr = 0;
cp += sizeof (struct cmdx_parm);
}
ip->hdr_pktlen = (cp - (char *)ip) - sizeof (ip->hdr_pktlen);
q->q_dev = (caddr_t)un;
bp->b_resid = bp->b_bcount;
/*
* Send command.
*/
if ((errno = id_send_cmd(q,
(long)IP_RESP_SUCCESS | IP_ABS_BLOCK | IP_BYTE_EXT,
ID_ASYNCHWAIT)) == 0)
{
if (q->q_result != IP_SUCCESS) {
bp->b_blkno = (daddr_t)q->q_errblk;
printf("id%3x: id_rdwr_deflist failed. result %x\n",
un->un_unit, q->q_result);
errno = EIO;
} else if (q->q_resp) {
/*
* Handle response extent or parameter length parameter.
* This will set the residual count in the buffer.
*/
ipi_parse_resp(q, id_deflist_table, (caddr_t)bp);
}
}
ipi_free(q);
return (errno);
}
/*
* Handle response extent parameter from read/write defect list.
*/
/* ARGSUSED */
static int
id_respx(q, id, rp, len, bp)
struct ipiq *q; /* request */
int id; /* parameter ID - not used */
struct respx_parm *rp; /* parameter */
int len; /* parameter length - not used */
struct buf *bp; /* buffer */
{
struct id_unit *un;
if (bp != NULL) {
q->q_errblk = rp->rx_addr;
if (q->q_flag & IP_BYTE_EXT) {
bp->b_resid = rp->rx_resid;
} else if ((un = (struct id_unit *)q->q_dev) != NULL) {
bp->b_resid = rp->rx_resid << un->un_log_bshift;
}
}
return (0);
}
/*
* Handle parameter length parameter from read/write defect list.
*/
/* ARGSUSED */
static int
id_deflist_parmlen(q, id, rp, len, bp)
struct ipiq *q; /* request */
int id; /* parameter ID - not used */
struct parmlen_parm *rp; /* parameter */
int len; /* parameter length - not used */
struct buf *bp; /* buffer */
{
bp->b_resid = bp->b_bcount - rp->parmlen;
return (0);
}
/*
* Reallocate a defective block.
*/
static
id_realloc(un, first_block, nblocks, opmod)
register struct id_unit *un; /* unit structure pointer */
daddr_t first_block; /* first block number */
int nblocks; /* block count, all if < 0 */
int opmod; /* opcode modifier */
{
struct ipiq *q;
int errno = 0; /* error return code */
struct ipi3header *ip;
int i;
char *cp;
if (nblocks <= 0)
return (EINVAL);
if ((q = ipi_setup(un->un_ipi_addr, (struct buf *)NULL,
sizeof (*ip) + sizeof (struct cmdx_parm) +
sizeof (long), MAX_RESPLEN, IPI_SLEEP, 0)) == NULL)
return (EIO);
/*
* Form IPI-3 Command packet.
*/
ip = q->q_cmd;
ip->hdr_opcode = IP_REALLOC;
ip->hdr_mods = opmod | IP_OM_BLOCK;
cp = (char *)(ip + 1); /* point past header */
/*
* Insert extent parameter, if needed.
*/
if (nblocks > 0 || first_block != 0) {
for (i = (int)(cp + 2); (i % sizeof (long)) != 0; i++)
*cp++ = 0; /* pad */
*cp++ = sizeof (struct cmdx_parm) + 1; /* parm + id */
*cp++ = CMD_EXTENT;
((struct cmdx_parm *) cp)->cx_count = nblocks;
((struct cmdx_parm *) cp)->cx_addr = first_block;
cp += sizeof (struct cmdx_parm);
}
ip->hdr_pktlen = (cp - (char *)ip) - sizeof (ip->hdr_pktlen);
q->q_dev = (caddr_t)un;
/*
* Send command.
*/
if ((errno = id_send_cmd(q, (long)IP_ABS_BLOCK, ID_ASYNCHWAIT)) == 0) {
if (q->q_result != IP_SUCCESS) {
printf("id%3x: id_realloc failed. result %x\n",
un->un_unit, q->q_result);
errno = EIO;
}
}
ipi_free(q);
return (errno);
}
/*
* Build attribute command.
* Used only during recovery. Leaves the number of parameters read
* in c->c_rec_data or un->un_rec_data. (XXX - ugly side-effect).
*/
static struct ipiq *
id_build_attr_cmd(c, un, rt, callback)
struct id_ctlr *c; /* controller */
struct id_unit *un; /* unit (may be NULL) */
register struct ipi_resp_table *rt; /* response table */
int (*callback)(); /* callback routine for ipi_setup */
{
register struct ipi_resp_table *rtp; /* response table pointer */
struct ipiq *q;
int nparms; /* number of parameter IDs */
u_char parms[ID_MAX_PARMS];
u_char *cp;
int addr; /* IPI device address */
struct ipi3header *ip;
u_char *pp; /* parameter pointer */
int len; /* command length */
cp = parms;
nparms = 0;
for (rtp = rt; rtp->rt_parm_id != 0 && nparms < c->c_max_parms; rtp++) {
if (rtp->rt_parm_id == ATTR_SLVCNF_BIT &&
(c->c_flags & ID_NO_RECONF))
continue;
*cp++ = rtp->rt_parm_id;
nparms++;
}
if (un) {
un->un_recover.rec_data = rtp - rt;
addr = un->un_ipi_addr;
} else {
c->c_recover.rec_data = rtp - rt;
addr = c->c_ipi_addr;
}
if (nparms <= 0)
return (NULL);
/*
* Figure length of command packet from table size.
* Doing this linearly is very cheap, since the tables are always short.
* Length is header + parm len, id, flags, + one for each attribute id.
*/
len = sizeof (struct ipi3header) + 3 + nparms;
if ((q = ipi_setup(addr, (struct buf *)NULL, len, MAX_RESPLEN,
callback, 0)) == NULL)
return (q);
/*
* Form IPI-3 Command packet.
*/
ip = (struct ipi3header *)q->q_cmd;
bzero ((caddr_t)ip, (u_int)len);
ip->hdr_opcode = IP_ATTRIBUTES;
ip->hdr_mods = IP_OM_REPORT;
/*
* Build request parameters parameter.
*/
pp = cp = (u_char *)(ip + 1); /* point to start of parameters */
cp++; /* skip parameter length */
*cp++ = ATTR_REQPARM; /* request parm parameter */
*cp++ = RESP_AS_PKT; /* parameters in response */
/*
* Insert parameter IDs into request parm parameter.
*/
bcopy((caddr_t)parms, (caddr_t)cp, (u_int)nparms);
cp += nparms;
/*
* Set parameter length and packet length.
*/
*pp = (cp - pp) - sizeof (*pp);
ip->hdr_pktlen = (cp - (u_char *)ip) - sizeof (ip->hdr_pktlen);
if (ip->hdr_pktlen + 2 != len)
printf("id_build_attr_cmd: miscalculated len %d pktlen %d",
len, ip->hdr_pktlen);
q->q_dev = (caddr_t)un; /* may be NULL */
return (q);
}
/*
* Build set attribute command.
* Used only during recovery. Leaves the number of parameters read
* in c->c_rec_data or un->un_rec_data. (XXX - ugly side-effect).
*/
static struct ipiq *
id_build_set_attr_cmd(c, un, rtp, callback)
struct id_ctlr *c; /* controller */
struct id_unit *un; /* unit (may be NULL) */
register struct ipi_resp_table *rtp; /* response table */
int (*callback)(); /* callback routine for ipi_setup */
{
struct ipiq *q;
u_char *cp;
int addr; /* IPI device address */
struct ipi3header *ip;
int len; /* command length */
int nparms; /* number of parameters */
caddr_t arg; /* arg to parameter function */
if (rtp->rt_parm_id)
nparms = 1;
else
nparms = 0;
if (un) {
un->un_recover.rec_data = nparms;
addr = un->un_ipi_addr;
arg = (caddr_t)un;
} else {
c->c_recover.rec_data = nparms;
addr = c->c_ipi_addr;
arg = (caddr_t)c;
}
if (nparms <= 0)
return (NULL);
/*
* Figure length of command packet from parameter size.
* Length is header + parm len, id, flags, + one for each attribute id.
*/
len = sizeof (struct ipi3header) + 3 + rtp->rt_min_len;
if ((q = ipi_setup(addr, (struct buf *)NULL, len, MAX_RESPLEN,
callback, 0)) == NULL)
return (q);
/*
* Form IPI-3 Command packet.
*/
ip = (struct ipi3header *)q->q_cmd;
bzero ((caddr_t)ip, (u_int)len);
ip->hdr_opcode = IP_ATTRIBUTES;
ip->hdr_mods = IP_OM_LOAD;
/*
* Insert parameter ID into request parm parameter.
*/
cp = (u_char *)(ip + 1);
while (((int)cp + 2) % sizeof (long) != 0)
*cp++ = 0; /* pad for alignment */
*cp++ = rtp->rt_min_len + 1; /* length (including ID byte) */
*cp++ = rtp->rt_parm_id; /* parameter ID */
(*rtp->rt_func)(q, rtp->rt_parm_id, cp, rtp->rt_min_len, arg);
cp += rtp->rt_min_len;
/*
* Set parameter length and packet length.
*/
ip->hdr_pktlen = (cp - (u_char *)ip) - sizeof (ip->hdr_pktlen);
q->q_dev = (caddr_t)un; /* may be NULL */
return (q);
}
/*
* This routine prints out an error message with the appropriate device
* or controller number and the block number if known. The message may
* be NULL, in which case no newline is printed.
*/
static void
id_printerr(q, msg)
struct ipiq *q;
char *msg;
{
register struct buf *bp;
register struct id_unit *un;
register struct opcode_name *np;
struct un_lpart *lp;
if (q->q_flag & IP_SILENT)
return;
if ((un = (struct id_unit *)q->q_dev) != NULL) {
if ((bp = q->q_buf) != NULL) {
if ((un->un_flags & ID_LABEL_VALID) &&
!(q->q_flag & IP_ABS_BLOCK))
{
lp = &un->un_lpart[ID_LPART(bp->b_dev)];
printf("id%3x%c: block %d", un->un_unit,
ID_LPART(bp->b_dev) + 'a',
q->q_errblk - lp->un_blkno);
printf(" (%d abs)", q->q_errblk);
} else {
printf("id%3x: block %d", un->un_unit,
q->q_errblk);
}
} else {
printf("id%3x", un->un_unit);
}
} else if (q->q_ctlr) {
printf("idc%d", ((struct id_ctlr *)(q->q_ctlr))->c_ctlr);
} else {
printf("id at ipi %x", q->q_csf);
}
for (np = opcode_name; np->name; np++) {
if (np->opcode == q->q_cmd->hdr_opcode) {
printf(": %s: ", np->name);
break;
}
}
if (np->name == NULL)
printf(": op %x: ", q->q_cmd->hdr_opcode);
if (msg)
printf("%s\n", msg);
}
#ifdef MULT_MAJOR
/*
* Establish maps for translating multiple major number into unit number.
*/
id_major_map_init()
{
extern int nblkdev, nchrdev;
register int i;
register int cmajor;
register int bmajor;
register struct cdevsw *cdp;
register struct bdevsw *bdp;
static char init_done;
if (init_done)
return;
init_done = 1;
for (i = 0; i < NMAJOR; i++) {
bmajor_lookup[i] = cmajor_lookup[i] =
cmajor_trans[i] = NO_MAJOR;
}
/*
* setup cmajor_lookup[major(dev)] to be set number.
*/
cmajor = 0;
for (cdp = cdevsw, i = 0; i < nchrdev; cdp++, i++) {
if (cdp->d_open == idcopen) {
cmajor_lookup[i] = cmajor++;
}
}
/*
* setup bmajor_lookup[major(dev)] to be set number.
*/
bmajor = 0;
for (bdp = bdevsw, i = 0; i < nblkdev; bdp++, i++) {
if (bdp->d_open == idbopen) {
bmajor_lookup[i] = bmajor++;
}
}
if (cmajor != bmajor || cmajor <= 0) {
printf("id_major_map_init: error: cmajor %d bmajor %d\n",
cmajor, bmajor);
panic("id_major_map_init: blk/chr major count mismatch");
}
/*
* setup cmajor_trans[cmajor(i)] to be block major number.
*/
for (cmajor = 0; cmajor < nchrdev; cmajor++) {
if (cmajor_lookup[cmajor] == NO_MAJOR)
continue;
for (bmajor = 0; bmajor < nblkdev; bmajor++) {
if (bmajor_lookup[bmajor] == cmajor_lookup[cmajor]) {
cmajor_trans[cmajor] = bmajor;
break;
}
}
if (bmajor == nblkdev) {
printf("id_major_map_init: major %d\n", cmajor);
panic("id_major_map_init: no blk dev for chr dev");
}
}
/*
* check bmajor lookup for completeness.
*/
for (bmajor = 0; bmajor < nblkdev; bmajor++) {
if (bmajor_lookup[bmajor] == NO_MAJOR)
continue;
for (cmajor = 0; cmajor < nchrdev; cmajor++) {
if (bmajor_lookup[bmajor] == cmajor_lookup[cmajor]) {
if (cmajor_trans[cmajor] != bmajor) {
printf("id_major_map_init: cmaj %d bmaj %d trans %d\n",
cmajor, bmajor,
cmajor_trans[cmajor]);
panic("id_major_map_init: bad trans");
}
break;
}
}
if (cmajor == nchrdev) {
printf("id_major_map_init: blk major %d ", bmajor);
panic("id_major_map_init: no chr dev for blk dev");
}
}
}
#endif /* MULT_MAJOR */
/*
* Watchdog for idle controllers or devices that have gone away.
*/
static void
id_watch()
{
struct id_unit **unp;
struct id_unit *un;
struct id_ctlr *c;
struct ipiq *q;
if (id_watch_enable == 0) /* patchable enable/disable */
goto resched;
for (unp = id_unit; unp != NULL && unp < &id_unit[nid]; unp++) {
if ((un = *unp) == NULL)
continue;
/*
* If the unit isn't idle, assume the command timeout
* will trigger if the device goes offline.
*/
if (un->un_cmd_q > 0) {
un->un_idle_time = 0;
continue;
}
/*
* If the unit is idle, add the interval since we last
* checked to the idle time. This exaggerates a bit.
*/
un->un_idle_time += ID_WATCH_TIME;
/*
* If the unit has been idle for too long, issue a REPORT
* STATUS command.
*/
if (un->un_idle_time > ID_MAX_IDLE) {
c = un->un_ctlr;
if (!IE_STAT_READY(un->un_flags) ||
!IE_STAT_READY(c->c_flags))
continue;
q = ipi_setup(un->un_ipi_addr, (struct buf *)NULL,
sizeof (struct ipi3header), MAX_RESPLEN,
IPI_NULL, 0);
if (q == NULL)
continue;
q->q_cmd->hdr_opcode = IP_REPORT_STAT;
q->q_cmd->hdr_mods = IP_OM_CONDITION;
q->q_cmd->hdr_pktlen = IPI_HDRLEN;
q->q_dev = (caddr_t)un;
q->q_time = ID_REC_TIMEOUT;
un->un_cmd_q++;
c->c_cmd_q++;
c->c_cmd_q_len += sizeof (struct ipi3header);
ipi_start(q, (long)IP_RESP_SUCCESS, id_watch_intr);
un->un_idle_time = 0;
}
}
resched:
timeout((int (*)())id_watch, (caddr_t)NULL, ID_WATCH_TIME*hz);
}
/*
* Interrupt handler for watchdog.
*/
static void
id_watch_intr(q)
struct ipiq *q;
{
if (q) {
id_cmd_intr(q);
switch (q->q_result) {
case IP_SUCCESS:
(void) id_error_parse(q, ipi_cond_table, id_error,
(struct id_ctlr *)q->q_ctlr,
(struct id_unit *)q->q_dev, IE_FAC);
ipi_free(q);
break;
case IP_MISSING:
id_missing_req(q);
break;
default:
ipi_free(q);
break;
}
}
}
/*
* Walk the table for each parameter in the response given.
* If any action should be taken, take it by calling the function given.
*
* Remember, speed is not important here. Robustness and code size are.
*/
static int
id_error_parse(q, err_table, fcn, c, un, flags)
register struct ipiq *q; /* request with response */
struct ipi_err_table *err_table;
int (*fcn)(); /* function to handle errors */
struct id_ctlr *c;
struct id_unit *un;
register int flags; /* initial error flags */
{
register struct ipi_err_table *etp; /* error table pointer */
register struct ipi3resp *rp;
register u_char *cp;
struct { /* parameter unpacking buffer */
long align; /* to force alignment */
u_char pad[2]; /* to maintain alignment for buf */
u_char len; /* parameter length */
u_char id; /* parameter ID */
u_char buf[254]; /* rest of parameter (after len/ID) */
} parm;
u_char *pp; /* parameter pointer */
int id; /* parameter id */
int plen; /* parameter length */
int rlen; /* response length */
int pflags; /* flags on parameter */
int bflags; /* flags on bit */
int result; /* result for current check */
int dryrun; /* set during dry run */
/*
* The table is read twice, once to see if any print flags are set and
* again to do the real work.
*/
dryrun = 1;
loop:
if ((rp = q->q_resp) == NULL) {
id_printerr(q, "id_error_parse: no response where expected");
return (IE_CMD);
}
rlen = rp->hdr_pktlen + sizeof (rp->hdr_pktlen)
- sizeof (struct ipi3resp);
cp = (u_char *)rp + sizeof (struct ipi3resp);
for (; rlen > 0; cp += plen) {
if ((plen = cp[0] + 1) > rlen)
break;
rlen -= plen;
if (plen <= 1)
continue; /* padding byte */
/*
* Find parameter ID in the table.
*/
id = cp[1];
pflags = 0;
for (etp = err_table; etp->et_mask; etp++) {
if (etp->et_byte != 0)
continue;
if (etp->et_parmid == id)
break;
if (etp->et_parmid + IPI_FAC_PARM == id) {
pflags |= IE_FAC;
break;
}
}
/*
* If parameter not found in table, skip it.
*/
if (etp->et_mask == 0)
continue;
/*
* Check (and fix) alignment if the parameter contains more
* than just the length and parameter ID.
*/
pp = cp;
if (plen > 2 && (((int)cp + 2) % sizeof (long)) != 0) {
pp = &parm.len;
bcopy((caddr_t)cp, (caddr_t)pp, (u_int)plen);
}
/*
* Set flags according to flags found in ID entry.
*/
pflags |= etp->et_flags & ~IE_MASK | flags;
flags |= pflags & IE_RESP_MASK;
result = etp->et_flags & IE_MASK;
if (!dryrun || (pflags & IE_FIRST_PASS)) {
if (pflags & (IE_MSG | IE_PRINT))
id_printerr(q, (char *)NULL);
/*
* run handler for parameter.
*/
flags |= (*fcn)(q, c, un, result, pflags,
etp->et_msg, pp);
}
/*
* Test each condition mentioned in the table until
* the next parameter ID entry.
*/
bflags = 0; /* in case no bit matches */
while ((++etp)->et_byte) {
if (etp->et_byte + 1 < plen &&
(etp->et_mask & cp[etp->et_byte + 1]))
{
bflags = etp->et_flags & ~IE_MASK | pflags;
flags |= bflags & IE_RESP_MASK;
result = etp->et_flags & IE_MASK;
if (!dryrun) {
if ((bflags ^ pflags) & IE_MSG)
id_printerr(q, (char *)NULL);
/*
* run handler for this match.
*/
flags |= (*fcn)(q, c, un, result,
bflags, etp->et_msg, pp);
}
}
}
if (!dryrun && ((pflags | bflags) & (IE_MSG | IE_PRINT)) &&
!(q->q_flag & IP_SILENT))
printf("\n");
}
if (dryrun) {
dryrun = 0;
goto loop;
}
if ((flags & IE_DUMP) && (!(q->q_flag & IP_SILENT) || id_debug)) {
ipi_print_cmd(IPI_CHAN(q->q_csf), q->q_cmd, "command in error");
ipi_print_resp(IPI_CHAN(q->q_csf), rp, "response of error");
}
return (flags);
}
/*
* Missing interrupt recovery.
*
* When an IPI command fails to give a completion response in the allotted
* time, this routine is called.
*
* The recovery method:
*
* The point of probable failure is determined by attempting to communicate
* with the nearest component first and working out on the channel until
* the problem area is determined.
*
* First, a NOP command is sent to the channel adaptor board. If that times
* out, the channel board is reset, the controllers reset, and all outstanding
* I/O is re-issued.
*
* XXX - a method to test whether one controller or an entire channel is bad
* must be developed.
*
* If the channel board is OK, a NO-Op command is issued to the particular
* slave device. If that times out, the controller is reset and all
* outstanding I/O is re-issued.
*
* If the slave is OK, the command is aborted and re-issued. After a number
* of retries, the command is considered to have failed and an error is issued.
*
* Alternate Reverse order method:
*
* This is not currently used, but could be a better way of doing things.
*
* If not an Abort command, issue an Abort command in case the hang up is
* in the disk or string controller. Mark the controller so that no other
* commands will be issued to the controller until the abort comes back.
*
* If an Abort command fails or times out, reset the slave. If that times out,
* reset the channel and all the slaves on it. If that times out,
* reset the entire board (all channels).
*
* Some controllers may not be able to accept aborts for individual commands.
* Handle these by escalating to doing a reset of the controller.
*
* After abort/reset processing, re-issue any commands that were outstanding
* but hadn't completed.
*
* Always called with interrupts masked.
*
* If q has IP_SYNC flag set, will not return until recovery completed or
* failure has occurred. Otherwise, just starts recovery. The interrupts
* generated will continue the recovery.
*/
static void
id_missing_req(q)
register struct ipiq *q;
{
register struct id_ctlr *c;
int s;
if ((c = (struct id_ctlr *)q->q_ctlr) == NULL) {
id_printerr(q, "missing rupt. q_ctlr NULL");
return;
}
/*
* If recovery is already in progress, return.
*/
if (c->c_flags & IE_RECOVER) {
id_printerr(q, "missing interrupt - recovery in progress");
return;
} else {
id_printerr(q, "missing interrupt - attempting recovery");
}
/*
* Setup controller in recovery mode.
*/
c->c_flags |= IE_RECOVER;
c->c_flags &= ~IE_TRACE_RECOV;
c->c_recover.rec_history = 0;
c->c_recover.rec_state = IDR_TEST_BOARD;
c->c_recover.rec_substate = 0;
c->c_recover.rec_flags = (q->q_flag & IP_SYNC) | IP_NO_RETRY;
s = spl_ipi();
(void) id_recover(c, (struct id_unit *)NULL);
(void) splx(s);
}
/*
* State transition table for recovery.
*/
struct id_next_state {
char ns_success; /* next state if command successful */
char ns_failed; /* next state if command failed */
char ns_failed_again; /* next state when command fails second time */
char *ns_msg; /* message */
};
/*
* Recovery table for controller.
*/
static struct id_next_state id_next_state[] = {
/* present next state next state next state */
/* state on success on failure on 2nd fail */
/* 0 IDR_NORMAL */ IDR_NORMAL, IDR_NORMAL, IDR_NORMAL,
"recovery complete",
/*
* Recovery from missing interrupt.
*/
/* 1 IDR_TEST_BOARD */ IDR_TEST_CHAN, IDR_RST_BOARD, IDR_REC_FAIL,
"test board",
/* 2 IDR_RST_BOARD */ IDR_RST_CHAN, IDR_REC_FAIL, IDR_REC_FAIL,
"reset board",
/* 3 IDR_TEST_CHAN */ IDR_TEST_CTLR, IDR_RST_CHAN, IDR_RST_BOARD,
"test chan",
/* 4 IDR_RST_CHAN */ IDR_RST_CTLR, IDR_RST_BOARD, IDR_REC_FAIL,
"reset chan",
/* 5 IDR_TEST_CTLR */ IDR_IDLE_CTLR, IDR_RST_CTLR, IDR_RST_CHAN,
"test ctlr",
/* 6 IDR_RST_CTLR */ IDR_GET_XFR, IDR_RST_CHAN, IDR_REC_FAIL,
"reset ctlr",
/* 7 IDR_GET_XFR */ IDR_SET_XFR, IDR_RST_CTLR, IDR_RST_CHAN,
"get xfr",
/* 8 IDR_SET_XFR */ IDR_STAT_CTLR, IDR_RST_CTLR, IDR_RST_CHAN,
"set xfr",
/* 9 IDR_STAT_CTLR */ IDR_ID_CTLR, IDR_RST_CTLR, IDR_RST_CHAN,
"stat ctlr",
/* 10 IDR_ID_CTLR */ IDR_ATTR_CTLR, IDR_RST_CTLR, IDR_RST_CHAN,
"id ctlr",
/* 11 IDR_ATTR_CTRL */ IDR_SATTR_CTLR1, IDR_RST_CTLR, IDR_RST_CHAN,
"attributes",
/* 12 IDR_SET_XFR1 */ IDR_RETRY, IDR_RST_CTLR, IDR_RST_CHAN,
"set xfr",
/* XXX - no path to IDR_ABORT for now (ISP-80 doesn't abort) */
/* 13 IDR_ABORT */ IDR_RETRY, IDR_RST_CTLR, IDR_RST_CHAN,
"abort",
/* 14 IDR_RETRY */ IDR_NORMAL, IDR_RST_CTLR, IDR_RST_CHAN,
"retry",
/* 15 IDR_REC_FAIL */ IDR_REC_FAIL, IDR_REC_FAIL, IDR_REC_FAIL,
"recovery failed",
/*
* Controller Re-initialization or initial configuration.
*/
/* XXX - eventually do more in the failure cases of these. */
/* 16 IDR_RST_CTLR1 */ IDR_GET_XFR1, IDR_REC_FAIL, IDR_REC_FAIL,
"reset ctlr",
/* 17 IDR_GET_XFR1 */ IDR_SET_XFR2, IDR_REC_FAIL, IDR_REC_FAIL,
"get xfr",
/* 18 IDR_SET_XFR2 */ IDR_STAT_CTLR1, IDR_REC_FAIL, IDR_REC_FAIL,
"set xfr",
/* 19 IDR_STAT_CTLR1 */ IDR_ID_CTLR1, IDR_REC_FAIL, IDR_REC_FAIL,
"stat ctlr",
/* 20 IDR_ID_CTLR1 */ IDR_ATTR_CTLR1, IDR_REC_FAIL, IDR_REC_FAIL,
"id ctlr",
/* 21 IDR_ATTR_CTRL1 */ IDR_SATTR_CTLR2, IDR_REC_FAIL, IDR_REC_FAIL,
"attr ctlr",
/* 22 IDR_SET_XFR3 */ IDR_NORMAL, IDR_REC_FAIL, IDR_REC_FAIL,
"set xfr",
/*
* Unit Re-initialization or initial configuration..
*/
/* 23 IDR_STAT_UNIT */ IDR_ATTR_UNIT, IDR_UNIT_FAILED, IDR_UNIT_FAILED,
"stat unit",
/* 24 IDR_ATTR_UNIT */ IDR_READ_LABEL, IDR_UNIT_FAILED, IDR_UNIT_FAILED,
"attr unit",
/* 25 IDR_READ_LABEL */ IDR_UNIT_NORMAL, IDR_UNIT_FAILED, IDR_UNIT_FAILED,
"read label",
/* 26 IDR_UNIT_NORMAL */ IDR_UNIT_NORMAL, IDR_UNIT_NORMAL, IDR_UNIT_NORMAL,
"unit recovery complete",
/* 27 IDR_UNIT_FAILED */ IDR_UNIT_FAILED, IDR_UNIT_FAILED, IDR_UNIT_FAILED,
"unit recovery failed",
/*
* Additional states inserted.
*/
/* 28 IDR_SATTR_CTLR1 */ IDR_SET_XFR1, IDR_REC_FAIL, IDR_REC_FAIL,
"set ctlr attr",
/* 29 IDR_SATTR_CTLR2 */ IDR_SET_XFR3, IDR_REC_FAIL, IDR_REC_FAIL,
"set ctlr attr",
/* 30 IDR_IDLE_CTLR */ IDR_NORMAL, IDR_DUMP_CTLR, IDR_RST_CTLR,
"idle ctlr",
/* 31 IDR_DUMP_CTLR */ IDR_RST_CTLR, IDR_RST_CTLR, IDR_RST_CTLR,
"dump ctlr",
};
#define IDR_NSTATES (sizeof (id_next_state) / sizeof (struct id_next_state))
/*
* Wrapper for calling id_recover through timeout(). Only one arg.
*/
static int
id_recover_idle(c)
struct id_ctlr *c;
{
int s;
s = spl_ipi();
(void) id_recover(c, (struct id_unit *)NULL);
(void) splx(s);
return (0);
}
/*
* This routine does the real work of recovering a controller.
* It gets reinvoked to issue the commands for every stage of recovery
* or loops if in synchronous mode.
*/
static int
id_recover(c, un)
register struct id_ctlr *c;
register struct id_unit *un;
{
register struct ipiq *q;
struct id_rec_state *rp;
u_int *flagsp;
long ipi_flags;
struct buf lbuf;
int mode;
int state;
int next_state;
int (*callback)();
int unit;
u_char *cp;
if (un) {
rp = &un->un_recover;
flagsp = &un->un_flags;
} else {
rp = &c->c_recover;
flagsp = &c->c_flags;
}
*flagsp |= IE_RECOVER | IE_RECOVER_ACTV;
ipi_flags = rp->rec_flags; /* flags for ipi requests */
callback = (ipi_flags & IP_SYNC) ? IPI_NULL : id_recover_start;
if (id_debug) {
*flagsp |= IE_TRACE_RECOV;
}
while (*flagsp & IE_RECOVER) {
state = rp->rec_state;
if (*flagsp & IE_TRACE_RECOV) {
if (un)
printf("id%3x: id_recover %d %s\n",
un->un_unit, state,
id_next_state[state].ns_msg);
else
printf("idc%d: id_recover %d %s\n",
c->c_ctlr, state,
id_next_state[state].ns_msg);
}
next_state = id_next_state[state].ns_success;
/*
* Build command.
*/
q = NULL;
switch (state) {
case IDR_NORMAL: /* recovery complete */
/*
* If a re-initialization became necessary during
* recovery, switch over to the right state to do it.
*/
if (c->c_flags & IE_RE_INIT) {
c->c_flags &= ~IE_RE_INIT;
rp->rec_state = IDR_RST_CTLR1;
rp->rec_history = 0;
break;
}
rp->rec_history |= 1 << state;
if (c->c_flags & ID_C_PRESENT)
printf("idc%d: Recovery complete.\n",
c->c_ctlr);
/*
* If there is no seek algorithm, allow a smaller number
* of commands to be sent to the controller so that the
* rest can be sorted in the host.
*/
if (!(c->c_flags & ID_SEEK_ALG))
c->c_max_q = MIN(c->c_max_q, MAX_UNSORTED);
c->c_flags &= ~IE_RECOVER;
c->c_flags |= ID_C_PRESENT;
/*
* Call idstart in case I/O was waiting for recovery to
* complete.
*/
for (unit = 0; unit < IDC_NUNIT; unit++)
if ((un = c->c_unit[unit]) != NULL)
(void) idstart(un);
if (!(ipi_flags & IP_SYNC))
wakeup((caddr_t)c);
break;
case IDR_REC_FAIL: /* recovery failed miserably */
/*
* Mark controller unusable.
*/
if (c->c_flags & ID_C_PRESENT)
printf("idc%d: Recovery failed. Controller marked unusable.\n",
c->c_ctlr);
c->c_flags &= ~(IE_RECOVER | IE_PAV);
rp->rec_history |= 1 << state;
/*
* Issue errors for pending commands.
*/
while ((q = c->c_retry_q) != NULL) {
c->c_retry_q = q->q_next;
if ((un = (struct id_unit *)q->q_dev) != NULL)
un->un_cmd_q++;
c->c_cmd_q++;
c->c_cmd_q_len +=
q->q_cmd->hdr_pktlen + sizeof (u_short);
ipi_complete(q, IP_RETRY_FAILED);
}
if (!(ipi_flags & IP_SYNC))
wakeup((caddr_t)c);
break;
case IDR_UNIT_NORMAL: /* unit recovery complete */
un->un_flags |= ID_UN_PRESENT;
un->un_flags &= ~IE_RECOVER;
rp->rec_history |= 1 << state;
if ((!q || q->q_result != IP_MISSING) && un->un_lp) {
/*
* see comment in id_recover_intr() about
* reading the label.
*/
if (islabel(un->un_unit, un->un_lp))
uselabel(un, un->un_lp);
kmem_free((caddr_t)un->un_lp, DEV_BSIZE);
un->un_lp = NULL;
}
if (!(ipi_flags & IP_SYNC))
wakeup((caddr_t)un);
break;
case IDR_UNIT_FAILED:
/*
* Unit may or may not be usable. The LABEL_VALID
* flag and partition sizes will determine whether
* it can be opened. Leave it's status alone so it
* can be opened for formatting, etc.
*/
un->un_flags &= ~IE_RECOVER;
rp->rec_history |= 1 << state;
if ((!q || q->q_result != IP_MISSING) && un->un_lp) {
/*
* see comment in id_recover_intr() about
* reading the label.
*/
if (islabel(un->un_unit, un->un_lp))
uselabel(un, un->un_lp);
kmem_free((caddr_t)un->un_lp, DEV_BSIZE);
un->un_lp = NULL;
}
if (!(ipi_flags & IP_SYNC))
wakeup((caddr_t)un);
break;
case IDR_TEST_BOARD: /* see if board is present */
q = ipi_setup(c->c_ipi_addr, (struct buf *)NULL,
sizeof (struct ipi3header), 0, callback, 0);
if (q == NULL)
goto setup_failed;
q->q_time = ID_REC_TIMEOUT;
ipi_test_board(q, ipi_flags, id_recover_intr);
break;
/*
* Unimplemented cases: just go to next step.
*/
/* XXX - test channel not implemented yet. */
case IDR_TEST_CHAN:
rp->rec_history |= 1 << state;
rp->rec_state = next_state;
rp->rec_substate = 0;
break;
case IDR_GET_XFR:
case IDR_GET_XFR1:
c->c_xfer_mode[0] = 0;
bzero((caddr_t)&lbuf, sizeof (lbuf));
lbuf.b_flags = B_BUSY | B_READ;
lbuf.b_un.b_addr = (caddr_t)c->c_xfer_mode;
lbuf.b_bcount = sizeof (c->c_xfer_mode);
if ((q = ipi_setup(c->c_ipi_addr, &lbuf,
sizeof (struct ipi3header),
MAX_RESPLEN, callback, 0)) == NULL)
goto setup_failed;
q->q_time = ID_REC_TIMEOUT;
ipi_get_xfer_mode(q, ipi_flags, id_recover_intr);
break;
/*
* Set transfer settings - use interlocked if possible,
* since attributes haven't been read. If not, rate must
* not be 20 MB/sec.
*/
case IDR_SET_XFR:
case IDR_SET_XFR2:
q = ipi_setup(c->c_ipi_addr, (struct buf *)NULL,
sizeof (struct ipi3header), 0, callback, 0);
if (q == NULL)
goto setup_failed;
q->q_time = ID_REC_TIMEOUT;
if ((c->c_xfer_mode[0] & IP_INLK_CAP) == 0)
mode = IP_STREAM;
else
mode = 0;
ipi_set_xfer_mode(q, ipi_flags, id_recover_intr, mode);
break;
/*
* Set transfer settings - attributes have been read, so
* use streaming if possible and proper rate.
*/
case IDR_SET_XFR1:
case IDR_SET_XFR3:
q = ipi_setup(c->c_ipi_addr, (struct buf *)NULL,
sizeof (struct ipi3header), 0, callback, 0);
if (q == NULL)
goto setup_failed;
q->q_time = ID_REC_TIMEOUT;
if ((c->c_xfer_mode[0] & IP_STREAM_CAP))
mode = IP_STREAM;
/* XXX - only handles 10 MB/sec now - get attributes later */
else
mode = 0;
ipi_set_xfer_mode(q, ipi_flags, id_recover_intr, mode);
break;
case IDR_TEST_CTLR:
q = ipi_setup(c->c_ipi_addr, (struct buf *)NULL,
sizeof (struct ipi3header), 0, callback, 0);
if (q == NULL)
goto setup_failed;
q->q_cmd->hdr_opcode = IP_NOP;
q->q_cmd->hdr_mods = 0;
q->q_cmd->hdr_pktlen = IPI_HDRLEN;
q->q_time = ID_REC_TIMEOUT;
ipi_start(q, ipi_flags, id_recover_intr);
break;
case IDR_RST_BOARD:
q = ipi_setup(c->c_ipi_addr, (struct buf *)NULL,
sizeof (struct ipi3header), 0, callback, 0);
if (q == NULL)
goto setup_failed;
ipi_reset_board(q, ipi_flags, id_recover_intr);
break;
case IDR_RST_CHAN:
q = ipi_setup(c->c_ipi_addr, (struct buf *)NULL,
sizeof (struct ipi3header), 0, callback, 0);
if (q == NULL)
goto setup_failed;
q->q_time = ID_REC_TIMEOUT;
ipi_reset_chan(q, ipi_flags, id_recover_intr);
break;
case IDR_RST_CTLR:
case IDR_RST_CTLR1:
q = ipi_setup(c->c_ipi_addr, (struct buf *)NULL,
sizeof (struct ipi3header), 0, callback, 0);
if (q == NULL)
goto setup_failed;
q->q_time = ID_RST_TIMEOUT;
ipi_reset_slave(q, ipi_flags | IP_LOG_RESET,
id_recover_intr);
break;
case IDR_STAT_CTLR:
case IDR_STAT_CTLR1:
if ((q = ipi_setup(c->c_ipi_addr, (struct buf *)NULL,
sizeof (struct ipi3header),
MAX_RESPLEN, callback, 0)) == NULL)
goto setup_failed;
q->q_cmd->hdr_opcode = IP_REPORT_STAT;
q->q_cmd->hdr_mods = IP_OM_CONDITION;
q->q_cmd->hdr_pktlen = IPI_HDRLEN;
q->q_time = ID_REC_TIMEOUT;
ipi_start(q, ipi_flags | IP_RESP_SUCCESS,
id_recover_intr);
break;
case IDR_STAT_UNIT:
if ((q = ipi_setup(un->un_ipi_addr, (struct buf *)NULL,
sizeof (struct ipi3header),
MAX_RESPLEN, callback, 0)) == NULL)
goto setup_failed;
q->q_cmd->hdr_opcode = IP_REPORT_STAT;
q->q_cmd->hdr_mods = IP_OM_CONDITION;
q->q_cmd->hdr_pktlen = IPI_HDRLEN;
q->q_dev = (caddr_t)un;
q->q_time = ID_REC_TIMEOUT;
ipi_start(q, ipi_flags | IP_RESP_SUCCESS,
id_recover_intr);
break;
case IDR_ID_CTLR:
case IDR_ID_CTLR1:
c->c_ctype = DKC_UNKNOWN;
q = id_build_attr_cmd(c, (struct id_unit *)NULL,
vendor_id_table, callback);
if (q == NULL)
goto setup_failed;
q->q_time = ID_REC_TIMEOUT;
ipi_start(q, ipi_flags | IP_RESP_SUCCESS,
id_recover_intr);
break;
case IDR_ATTR_CTLR:
case IDR_ATTR_CTLR1:
q = id_build_attr_cmd(c, (struct id_unit *)NULL,
&ctlr_conf_table[rp->rec_substate], callback);
if (q == NULL)
goto setup_failed;
q->q_time = ID_REC_TIMEOUT;
ipi_start(q, ipi_flags | IP_RESP_SUCCESS,
id_recover_intr);
break;
case IDR_SATTR_CTLR1:
case IDR_SATTR_CTLR2:
if (c->c_flags & ID_NO_RECONF) {
rp->rec_history |= 1 << state;
rp->rec_state = next_state;
rp->rec_substate = 0;
break;
}
q = id_build_set_attr_cmd(c, (struct id_unit *)NULL,
&ctlr_set_conf_table[rp->rec_substate],
callback);
if (q == NULL)
goto setup_failed;
q->q_time = ID_REC_TIMEOUT;
ipi_start(q, ipi_flags | IP_RESP_SUCCESS,
id_recover_intr);
break;
case IDR_ATTR_UNIT:
q = id_build_attr_cmd(c, un,
&attach_resp_table[rp->rec_substate], callback);
if (q == NULL)
goto setup_failed;
q->q_time = ID_REC_TIMEOUT;
ipi_start(q, ipi_flags | IP_RESP_SUCCESS,
id_recover_intr);
break;
case IDR_READ_LABEL:
un->un_flags &= ~ID_LABEL_VALID;
if (!(un->un_flags & ID_FORMATTED)) {
rp->rec_history |= 1 << state;
rp->rec_state = next_state;
break;
}
if (un->un_lp == NULL) {
id_printerr(q, "id_recover: no memory for label"); /* XXX */
rp->rec_state = IDR_UNIT_FAILED;
break;
}
un->un_lp->dkl_magic = 0;
bzero((caddr_t)&lbuf, sizeof (lbuf));
lbuf.b_flags = B_BUSY | B_READ;
lbuf.b_un.b_addr = (caddr_t)un->un_lp;
lbuf.b_bcount = sizeof (struct dk_label);
if ((q = ipi_setup(un->un_ipi_addr, &lbuf,
c->c_rw_cmd_len,
MAX_RESPLEN, callback, 0)) == NULL)
goto setup_failed;
id_build_rdwr(q, un, (daddr_t)0, 1); /* 1 block label */
q->q_buf = NULL; /* buffer is local */
ipi_start(q, ipi_flags, id_recover_intr);
break;
case IDR_RETRY: /* re-issue commands */
while ((q = c->c_retry_q) != NULL) {
c->c_retry_q = q->q_next;
id_retry(q);
}
rp->rec_history |= 1 << state;
rp->rec_state = next_state;
break;
case IDR_IDLE_CTLR: /* wait for cmds to finish */
/*
* Wait in this state in case the missing interrupt was
* because we the controller was just busy with other
* commands. No new commands are sent in the hope
* that things can get cleaned up.
*
* rp->rec_substate is time (seconds) in this state.
*/
if (c->c_cmd_q == 0) {
rp->rec_history |= 1 << state;
rp->rec_state = next_state;
rp->rec_substate = 0;
} else if ((ipi_flags & IP_SYNC) == 0 &&
rp->rec_substate++ < ID_IDLE_TIME) {
timeout(id_recover_idle, (caddr_t)c, hz);
goto out; /* Think about this. */
} else { /* time is up */
rp->rec_history |= 1 << state;
rp->rec_state = id_next_state[state].ns_failed;
rp->rec_substate = 0;
}
break;
case IDR_DUMP_CTLR: /* take firmware dump */
if (c->c_ctype != DKC_SUN_IPI1) {
rp->rec_history |= 1 << state;
rp->rec_state = next_state;
break;
}
printf("idc%d: driver requesting controller dump\n",
c->c_ctlr);
if ((q = ipi_setup(c->c_ipi_addr, (struct buf *)NULL,
sizeof (struct ipi3header)
+ sizeof (struct ipi_diag_num) + 2,
MAX_RESPLEN, callback, 0)) == NULL)
goto setup_failed;
q->q_cmd->hdr_opcode = IP_DIAG_CTL;
q->q_cmd->hdr_mods = 0;
cp = (u_char *)(q->q_cmd + 1); /* past header */
*cp++ = sizeof (struct ipi_diag_num)+1; /* parm + id */
*cp++ = IPI_DIAG_NUM; /* parameter ID */
((struct ipi_diag_num *)cp)->dn_diag_num = IPDN_DUMP;
q->q_cmd->hdr_pktlen = cp + sizeof (struct ipi_diag_num)
- (u_char *)q->q_cmd - sizeof (u_short);
q->q_dev = (caddr_t)un;
q->q_time = ID_DUMP_TIMEOUT;
ipi_start(q, ipi_flags | IP_SILENT, id_recover_intr);
break;
default:
printf("idc%d: id_recover: bad state %d\n",
c->c_ctlr, rp->rec_state);
rp->rec_history |= 1 << state;
rp->rec_state = IDR_REC_FAIL;
break;
}
/*
* Wait for command to complete.
* Id_recover_intr() will handle the ending status.
*/
if (q) {
if (ipi_flags & IP_SYNC) {
if (ipi_poll(q, (long)ID_POLL_TIMEOUT) == 0) {
q->q_result = IP_MISSING;
id_recover_intr(q);
/*
* Clear sync flag so subsequent
* controller reset will allow it
* to be freed (after IP_RETRY_FAIL).
*/
q->q_flag &= ~IP_SYNC;
} else {
ipi_free(q);
}
} else if (q->q_result == IP_INPROGRESS) {
break; /* interrupt routine will restart */
}
}
}
out:
*flagsp &= ~IE_RECOVER_ACTV;
return (0);
setup_failed:
if (callback == IPI_NULL)
printf("idc%d: synchronous command setup failed\n", c->c_ctlr);
*flagsp &= ~IE_RECOVER_ACTV;
return (DVMA_RUNOUT);
}
/*
* Called when a controller tried to get recovery started but couldn't get
* a request setup. This routine is called through the callback
* when a setup becomes possible and should be reattempted.
*/
/*ARGSUSED*/
static int
id_recover_start(arg)
caddr_t arg;
{
register struct id_ctlr *c;
struct id_unit *un;
int i;
int ctlr;
int stat;
int s;
stat = 0;
s = spl_ipi();
for (ctlr = 0; ctlr < nidc && stat == 0; ctlr++) {
if ((c = id_ctlr[ctlr]) == NULL)
continue;
if (c->c_flags & IE_RECOVER_ACTV)
continue;
if (c->c_flags & IE_RECOVER) {
stat = id_recover(c, (struct id_unit *)NULL);
} else {
for (i = 0; i < IDC_NUNIT && stat == 0; i++) {
if ((un = c->c_unit[i]) != NULL &&
un->un_flags & IE_RECOVER)
stat = id_recover(c, un);
}
}
}
(void) splx(s);
return (stat);
}
/*
* Interrupt handler for recovery actions.
*/
static void
id_recover_intr(q)
register struct ipiq *q;
{
register struct id_ctlr *c;
register struct id_unit *un;
struct id_rec_state *rp;
int flags;
struct id_next_state *nsp;
int state, next_state;
int stay_in_state = 0;
if (q == NULL)
return;
c = (struct id_ctlr *)q->q_ctlr;
un = (struct id_unit *)q->q_dev;
rp = un ? &un->un_recover : &c->c_recover;
if ((state = rp->rec_state) >= IDR_NSTATES) {
printf("id_recover_intr: bad state %d\n", state);
id_printerr(q, "bad recovery state");
return;
}
switch (q->q_result) {
case IP_ERROR:
case IP_COMPLETE:
if (q->q_resp) {
flags = id_error_parse(q, ipi_err_table, id_error,
c, un, 0);
if ((flags & IE_CMD) == 0) /* non fatal */
q->q_result = IP_SUCCESS;
}
break;
case IP_RETRY_FAILED:
/*
* When retry has failed, this result means a request
* sent by id_recover() was missing and now that the
* controller has been reset it can be freed.
*/
ipi_free(q);
return;
}
switch (state) {
case IDR_STAT_CTLR:
case IDR_STAT_CTLR1:
/*
* Evaluate the response from Report Addressee Status.
*/
if (q->q_result == IP_SUCCESS)
(void) id_error_parse(q, ipi_cond_table, id_error,
c, (struct id_unit *)NULL, IE_INIT_STAT);
else if (q->q_result == IP_MISSING)
break;
/*
* Check flags. If the controller isn't ready,
* consider the status operation a failure for the
* purposes of selecting the next state. Ignore the
* IE_RECOVER and IE_RE_INIT flags for this test.
*/
if (!IE_STAT_READY(c->c_flags & ~(IE_RECOVER | IE_RE_INIT))) {
q->q_result = IP_ERROR;
}
c->c_flags &= ~IE_INIT_STAT;
break;
case IDR_STAT_UNIT:
/*
* Evaluate the response from Report Addressee Status.
*/
if (q->q_result == IP_SUCCESS)
(void) id_error_parse(q, ipi_cond_table,
id_error, c, un, IE_FAC);
else if (q->q_result == IP_MISSING)
break;
/*
* Check flags. If the unit isn't ready,
* consider the status operation a failure for the
* purposes of selecting the next state. Ignore the
* IE_RECOVER and IE_RE_INIT flags for this test.
*/
if (!IE_STAT_READY(un->un_flags & ~(IE_RECOVER | IE_RE_INIT))) {
q->q_result = IP_ERROR;
un->un_flags &= ~ID_UN_PRESENT;
} else {
un->un_flags |= ID_UN_PRESENT;
}
un->un_flags &= ~IE_INIT_STAT;
break;
case IDR_ID_CTLR:
case IDR_ID_CTLR1:
if (id_print_attr)
ipi_print_resp(IPI_CHAN(q->q_csf), q->q_resp,
"ctlr id response");
if (q->q_result == IP_SUCCESS) {
ipi_parse_resp(q, vendor_id_table, (caddr_t)c);
if (c->c_ctype == DKC_UNKNOWN)
printf("idc%d: unknown string ctlr type\n",
c->c_ctlr);
}
break;
case IDR_ATTR_CTLR:
case IDR_ATTR_CTLR1:
if (q->q_result == IP_SUCCESS) {
if (id_print_attr)
ipi_print_resp(IPI_CHAN(q->q_csf), q->q_resp,
"ctlr attr response");
ipi_parse_resp(q, &ctlr_conf_table[rp->rec_substate],
(caddr_t)c);
rp->rec_substate += rp->rec_data;
/*
* Stay in this state if not done with table.
*/
stay_in_state =
ctlr_conf_table[rp->rec_substate]
.rt_parm_id;
if (stay_in_state == 0)
c->c_flags &= ~IE_RE_INIT;
}
break;
case IDR_ATTR_UNIT:
if (q->q_result == IP_SUCCESS) {
if (id_print_attr)
ipi_print_resp(IPI_CHAN(q->q_csf), q->q_resp, "unit attr response");
ipi_parse_resp(q, &attach_resp_table[rp->rec_substate],
(caddr_t)un);
rp->rec_substate += rp->rec_data;
/*
* Stay in this state if not done with table.
*/
stay_in_state =
attach_resp_table[rp->rec_substate].rt_parm_id;
}
break;
case IDR_RETRY:
if (c->c_retry_q)
stay_in_state = 1;
break;
case IDR_READ_LABEL:
/*
* We used to check the label here, but that has the
* unfortunate consequence of examing data returned by
* dvma before the dvma mappings are released, but more
* importantly before the i/o cache has been flushed.
* In certain cases islabel() would determine the label
* bad while it was simply that not all the bytes of the
* label had made it to memory yet. Instead of checking here,
* we check in the IDR_UNIT_NORMAL and IDR_UNIT_FAILED
* cases in id_recover() just before kmem_free() is called
* to release the buffer used for the label. By that point
* the i/o cache has been flushed (indirectly by ipi_free()
* after the IDR_READ_LABEL case in id_recover()).
*/
/*
if (q->q_result==IP_SUCCESS &&
islabel(un->un_unit, un->un_lp))
uselabel(un, un->un_lp);
*/
break;
}
nsp = &id_next_state[state];
if (!stay_in_state) {
if (q->q_result == IP_SUCCESS)
next_state = nsp->ns_success;
else if (rp->rec_history & (1 << state))
next_state = nsp->ns_failed_again;
else
next_state = nsp->ns_failed;
rp->rec_state = next_state;
rp->rec_history |= (1 << state);
rp->rec_substate = 0;
rp->rec_data = 0;
} else {
next_state = state;
}
if (un && (un->un_flags & IE_TRACE_RECOV)) {
printf("id%3x: id_recover_intr %d %s result %x\n",
un->un_unit, state, nsp->ns_msg, q->q_result);
} else if (c->c_flags & IE_TRACE_RECOV) {
printf("idc%d: id_recover_intr %d %s result %x\n",
c->c_ctlr, state, nsp->ns_msg, q->q_result);
}
if (!(q->q_flag & IP_SYNC)) {
if (q->q_result != IP_MISSING)
ipi_free(q); /* return ipiq to free list */
if (((un ? un->un_flags : c->c_flags) & IE_RECOVER_ACTV) == 0)
/* run next step of recovery */
(void) id_recover(c, un);
}
}
/*
* XXX - recovery should be hierarchical. Find a way to let the
* channel driver do its own recovery depending on it's own capabilities.
*/
/*
* Recover controller.
* Called by IPI layer when the channel has been reset and a controller
* reset is required.
*
* The channel may have been reset because a controller on the channel
* was having problems, or because another channel on the same board
* needed recovery and the entire board was reset.
*
* It may be possible to do a physical-only reset, allowing commands
* already in progress to be retained. However, if the entire board
* was reset, a physical and logical reset must be performed, otherwise
* the channel board state will not be consistent with the requests
* outstanding.
*/
static void
id_recover_ctlr(c, code)
struct id_ctlr *c;
int code; /* XXX - may indicate action eventually */
{
printf("idc%d: id_recover_ctlr\n", c->c_ctlr);
switch (code) {
case IPR_REINIT:
case IPR_RESET:
c->c_flags |= IE_RE_INIT;
c->c_flags &= ~ID_C_PRESENT;
break;
default:
printf("idc%d: id_recover_ctlr: bad case %x\n",
c->c_ctlr, code);
break;
}
}
static void
id_retry(q)
struct ipiq *q;
{
struct id_unit *un;
struct id_ctlr *c;
struct buf *bp;
if ((un = (struct id_unit *)q->q_dev) != NULL) {
un->un_cmd_q++;
}
if ((c = (struct id_ctlr *)q->q_ctlr) != NULL) {
c->c_cmd_q++;
c->c_cmd_q_len += q->q_cmd->hdr_pktlen + sizeof (u_short);
}
/*
* Reset residue and error block number, if appropriate.
*/
if ((bp = q->q_buf) != NULL) {
q->q_errblk = (int) (dkblock(bp) +
un->un_lpart[ID_LPART(bp->b_dev)].un_blkno);
bp->b_resid = bp->b_bcount - q->q_dma_len;
}
ipi_retry(q);
}
/*
* Queue a q for eventual or immediate retry.
*/
static void
id_q_retry(q)
struct ipiq *q;
{
struct id_ctlr *c;
if ((c = (struct id_ctlr *)q->q_ctlr) &&
(c->c_flags & (IE_RECOVER | IE_RE_INIT)))
{
q->q_next = c->c_retry_q;
c->c_retry_q = q;
} else {
id_retry(q);
}
}
/*
* Reallocate kmem_alloc-ed area.
* Only useful if newsize larger than oldsize.
* Works even if oldsize is zero.
* Returns non-zero on error, leaving old area allocated.
*/
static int
id_kmem_realloc(pp, oldsize, newsize)
caddr_t *pp; /* pointer to area pointer */
u_int oldsize; /* length of old area */
u_int newsize; /* length of new area */
{
caddr_t new;
caddr_t old;
if (newsize < oldsize || (new = kmem_alloc(newsize)) == NULL)
return (-1);
old = *pp;
bcopy(old, new, oldsize);
bzero(new + oldsize, newsize - oldsize);
*pp = new;
kmem_free(old, oldsize);
return (0);
}
/*
* Update starting block numbers for each of the partitions.
* This saves converting a cylinder offset to a block offset on each command.
* Must be called when changing partition map or geometry.
*/
static void
id_update_map(un)
struct id_unit *un;
{
struct un_lpart *lp;
for (lp = un->un_lpart; lp < &un->un_lpart[NDKMAP]; lp++) {
lp->un_blkno = (lp->un_map.dkl_cylno + un->un_g.dkg_bcyl)
* un->un_g.dkg_nhead * un->un_g.dkg_nsect
+ un->un_first_block;
}
}
/*
* Allocate and initialize read-back buffer for write checking.
*/
static void
id_alloc_wchk()
{
register struct buf *bp;
if (id_wchk_buf == NULL) {
bp = alloc(struct buf, 1);
id_wchk_buf = bp;
bp->b_un.b_addr = (caddr_t)kmem_alloc(ID_WCHK_BUFL);
bp->b_flags = B_BUSY | B_PHYS | B_READ;
bp->b_bcount = ID_WCHK_BUFL;
}
}
/*
* Do read-back after write.
* Called with write request after it has completed.
* The read-back request is all set up and ready to go.
*/
static void
id_readback(q)
struct ipiq *q;
{
register struct id_unit *un = (struct id_unit *)q->q_dev;
register struct id_ctlr *c = un->un_ctlr;
int dk;
struct ipiq *rbq; /* read-back request */
rbq = q_related(q);
/*
* Update counts of outstanding commands.
*/
un->un_cmd_q++;
c->c_cmd_q++;
c->c_cmd_q_len += c->c_rw_cmd_len;
rbq->q_buf = NULL; /* so rupt handler doesn't mess with buf */
/*
* Send command.
* If the WCHK_READ flag is already on, do a retry, since the command
* has been previously issued. Otherwise, do a start.
*/
if (rbq->q_flag & IP_WCHK_READ) {
id_q_retry(rbq);
} else {
rbq->q_flag |= IP_WCHK_READ;
ipi_start(rbq, (long)0, idintr);
}
/*
* Update iostat statistics.
*/
if ((dk = un->un_dk) >= 0) {
dk_busy |= 1 << dk;
dk_seek[dk]++;
dk_xfer[dk]++;
dk_read[dk]++;
dk_wds[dk] += q->q_buf->b_bcount >> 6;
}
}
/* Following code is included from SunDBE */
/* #ifdef SUNDBE */
static int
idcstrategy(bp)
struct buf *bp;
{
bp->b_dev = ID_BLKDEV(bp->b_dev);
return idstrategy(bp);
}
int (*id_get_strategy(major_dev))()
{
if (major_dev >= nchrdev || cdevsw[major_dev].d_open != idcopen)
return NULL;
return idcstrategy;
}
/* #endif SUNDBE */
Reference in New Issue View Git Blame Copy Permalink