420 lines
11 KiB
C
420 lines
11 KiB
C
/* $NetBSD: cs80bus.c,v 1.9 2007/03/04 06:01:46 christos Exp $ */
|
|
|
|
/*-
|
|
* Copyright (c) 2001 The NetBSD Foundation, Inc.
|
|
* All rights reserved.
|
|
*
|
|
* This code is derived from software contributed to The NetBSD Foundation
|
|
* by Gregory McGarry.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* 3. All advertising materials mentioning features or use of this software
|
|
* must display the following acknowledgement:
|
|
* This product includes software developed by the NetBSD
|
|
* Foundation, Inc. and its contributors.
|
|
* 4. Neither the name of The NetBSD Foundation nor the names of its
|
|
* contributors may be used to endorse or promote products derived
|
|
* from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
|
|
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
|
|
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
|
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
|
|
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
* POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
#include <sys/cdefs.h>
|
|
__KERNEL_RCSID(0, "$NetBSD: cs80bus.c,v 1.9 2007/03/04 06:01:46 christos Exp $");
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/systm.h>
|
|
#include <sys/device.h>
|
|
#include <sys/endian.h>
|
|
#include <sys/malloc.h>
|
|
|
|
#include <dev/gpib/gpibvar.h>
|
|
#include <dev/gpib/cs80busvar.h>
|
|
|
|
#define DEBUG
|
|
|
|
#ifdef DEBUG
|
|
int cs80busdebug = 0xff;
|
|
#define DBG_FOLLOW 0x01
|
|
#define DBG_STATUS 0x02
|
|
#define DBG_FAIL 0x04
|
|
#define DPRINTF(mask, str) if (cs80busdebug & (mask)) printf str
|
|
#else
|
|
#define DPRINTF(mask, str) /* nothing */
|
|
#endif
|
|
|
|
#include "locators.h"
|
|
#define cs80buscf_slave cf_loc[CS80BUSCF_SLAVE]
|
|
#define cs80buscf_punit cf_loc[CS80BUSCF_PUNIT]
|
|
|
|
int cs80busmatch(struct device *, struct cfdata *, void *);
|
|
void cs80busattach(struct device *, struct device *, void *);
|
|
|
|
CFATTACH_DECL(cs80bus, sizeof(struct cs80bus_softc),
|
|
cs80busmatch, cs80busattach, NULL, NULL);
|
|
|
|
static int cs80bus_alloc(struct cs80bus_softc *, int, int);
|
|
static int cs80bussearch(struct device *, struct cfdata *,
|
|
const int *, void *);
|
|
static int cs80busprint(void *, const char *);
|
|
|
|
/*
|
|
* HP's CS80/SS80 command set can be found on `newer' devices, while
|
|
* the HP's Amigo command set is used on before-you-were-born
|
|
* devices. Devices that respond to CS80/SS80 (and probably Amigo, too)
|
|
* are tagged with a 16-bit ID.
|
|
*
|
|
* CS80/SS80 has a 2-level addressing scheme; slave, the analog
|
|
* of a SCSI ID, and punit, the analog of a SCSI LUN. Unforunately,
|
|
* IDs are on a per-slave basis; punits are often used for disk
|
|
* drives that have an accompanying tape drive on the second punit.
|
|
*
|
|
* We treat CS80/SS80 as an indirect bus. However, since we are given
|
|
* some ID information, it is unreasonable to disallow cloning of
|
|
* CS80/SS80 devices.
|
|
*
|
|
* To deal with all of this, we use the semi-twisted scheme
|
|
* in cs80bus_attach_children(). For each GPIB slave, we loop
|
|
* through all of the possibly-configured children, allowing
|
|
* them to modify the punit parameter (but NOT the slave!).
|
|
*
|
|
*/
|
|
|
|
int
|
|
cs80busmatch(parent, match, aux)
|
|
struct device *parent;
|
|
struct cfdata *match;
|
|
void *aux;
|
|
{
|
|
|
|
return (1);
|
|
}
|
|
|
|
void
|
|
cs80busattach(parent, self, aux)
|
|
struct device *parent, *self;
|
|
void *aux;
|
|
{
|
|
struct cs80bus_softc *sc = device_private(self);
|
|
struct gpib_attach_args *ga = aux;
|
|
struct cs80bus_attach_args ca;
|
|
int slave;
|
|
u_int16_t id;
|
|
|
|
printf("\n");
|
|
|
|
sc->sc_ic = ga->ga_ic;
|
|
|
|
for (slave = 0; slave < 8; slave++) {
|
|
|
|
if (gpib_isalloc((void *)device_parent(&sc->sc_dev), slave))
|
|
continue;
|
|
|
|
if (gpibrecv(sc->sc_ic, GPIB_BROADCAST_ADDR,
|
|
slave, &id, 2) != 2)
|
|
continue;
|
|
|
|
BE16TOH(id);
|
|
|
|
DPRINTF(DBG_STATUS, ("cs80busattach: found id 0x%x\n", id));
|
|
|
|
if ((id & 0x200) == 0)
|
|
continue;
|
|
|
|
ca.ca_ic = sc->sc_ic;
|
|
ca.ca_slave = slave;
|
|
ca.ca_id = id;
|
|
|
|
(void)config_search_ia(cs80bussearch, &sc->sc_dev, "cs80bus", &ca);
|
|
}
|
|
}
|
|
|
|
int
|
|
cs80bussearch(parent, cf, ldesc, aux)
|
|
struct device *parent;
|
|
struct cfdata *cf;
|
|
const int *ldesc;
|
|
void *aux;
|
|
{
|
|
struct cs80bus_softc *sc = (struct cs80bus_softc *)parent;
|
|
struct cs80bus_attach_args *ca = aux;
|
|
|
|
/*
|
|
* Set punit if operator specified one in the kernel
|
|
* configuration file.
|
|
*/
|
|
if (cf->cs80buscf_punit != CS80BUSCF_PUNIT_DEFAULT &&
|
|
cf->cs80buscf_punit < CS80BUS_NPUNITS)
|
|
ca->ca_punit = cf->cs80buscf_punit;
|
|
else
|
|
/* default punit */
|
|
ca->ca_punit = 0;
|
|
|
|
DPRINTF(DBG_FOLLOW, ("cs80bussearch: id=0x%x slave=%d punit=%d\n",
|
|
ca->ca_id, ca->ca_slave, ca->ca_punit));
|
|
|
|
if (config_match(parent, cf, ca) > 0) {
|
|
|
|
DPRINTF(DBG_FOLLOW,
|
|
("cs80bussearch: got id=0x%x slave=%d punit %d\n",
|
|
ca->ca_id, ca->ca_slave, ca->ca_punit));
|
|
|
|
/*
|
|
* The device probe has succeeded, and filled in
|
|
* the punit information. Make sure the configuration
|
|
* allows for this slave/punit combination.
|
|
*/
|
|
if (cf->cs80buscf_slave != CS80BUSCF_SLAVE_DEFAULT &&
|
|
cf->cs80buscf_slave != ca->ca_slave)
|
|
goto out;
|
|
if (cf->cs80buscf_punit != CS80BUSCF_PUNIT_DEFAULT &&
|
|
cf->cs80buscf_punit != ca->ca_punit)
|
|
goto out;
|
|
|
|
/*
|
|
* Allocate the device's address from the bus's
|
|
* resource map.
|
|
*/
|
|
if (cs80bus_alloc(sc, ca->ca_slave, ca->ca_punit))
|
|
goto out;
|
|
|
|
/*
|
|
* This device is allowed; attach it.
|
|
*/
|
|
config_attach(parent, cf, ca, cs80busprint);
|
|
}
|
|
out:
|
|
return (0);
|
|
}
|
|
|
|
int
|
|
cs80busprint(aux, pnp)
|
|
void *aux;
|
|
const char *pnp;
|
|
{
|
|
struct cs80bus_attach_args *ca = aux;
|
|
|
|
printf(" slave %d punit %d", ca->ca_slave, ca->ca_punit);
|
|
return (UNCONF);
|
|
}
|
|
|
|
static int
|
|
cs80bus_alloc(sc, slave, punit)
|
|
struct cs80bus_softc *sc;
|
|
int slave, punit;
|
|
{
|
|
|
|
DPRINTF(DBG_FOLLOW, ("cs80bus_alloc: sc=%p\n", sc));
|
|
|
|
if (slave >= CS80BUS_NSLAVES || punit >= CS80BUS_NPUNITS)
|
|
panic("cs80bus_alloc: device address out of range");
|
|
|
|
gpib_alloc((void *)device_parent(&sc->sc_dev), slave);
|
|
|
|
if (sc->sc_rmap[slave][punit] == 0) {
|
|
sc->sc_rmap[slave][punit] = 1;
|
|
return (0);
|
|
}
|
|
return (1);
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
* CS80/SS80 (secondary) command functions
|
|
*/
|
|
|
|
int
|
|
cs80describe(v, slave, punit, csd)
|
|
void *v;
|
|
int slave;
|
|
int punit;
|
|
struct cs80_description *csd;
|
|
{
|
|
struct cs80bus_softc *sc = v;
|
|
struct cs80_describecmd desc;
|
|
u_int8_t stat;
|
|
|
|
DPRINTF(DBG_FOLLOW, ("cs80describe: sc=%p slave=%d\n", sc, slave));
|
|
|
|
/*
|
|
* Note command is always issued to unit 0.
|
|
*/
|
|
|
|
desc.c_unit = CS80CMD_SUNIT(0);
|
|
desc.c_vol = CS80CMD_SVOL(0);
|
|
desc.c_cmd = CS80CMD_DESC;
|
|
(void) gpibsend(sc->sc_ic, slave, CS80CMD_SCMD, &desc, sizeof(desc));
|
|
(void) gpibrecv(sc->sc_ic, slave, CS80CMD_EXEC, csd, sizeof(*csd));
|
|
(void) gpibrecv(sc->sc_ic, slave, CS80CMD_QSTAT, &stat, 1);
|
|
if (stat != 0) {
|
|
DPRINTF(DBG_FAIL, ("cs80describe: failed, stat=0x%x\n", stat));
|
|
return (1);
|
|
}
|
|
BE16TOH(csd->d_iuw);
|
|
BE16TOH(csd->d_cmaxxfr);
|
|
BE16TOH(csd->d_sectsize);
|
|
BE16TOH(csd->d_blocktime);
|
|
BE16TOH(csd->d_uavexfr);
|
|
BE16TOH(csd->d_retry);
|
|
BE16TOH(csd->d_access);
|
|
BE32TOH(csd->d_maxcylhead);
|
|
BE16TOH(csd->d_maxsect);
|
|
BE16TOH(csd->d_maxvsecth);
|
|
BE32TOH(csd->d_maxvsectl);
|
|
|
|
return (0);
|
|
}
|
|
|
|
int
|
|
cs80reset(v, slave, punit)
|
|
void *v;
|
|
int slave;
|
|
int punit;
|
|
{
|
|
struct cs80bus_softc *sc = v;
|
|
struct cs80_clearcmd clear;
|
|
struct cs80_srcmd sr;
|
|
struct cs80_ssmcmd ssm;
|
|
|
|
DPRINTF(DBG_FOLLOW, ("cs80reset: sc=%p slave=%d punit=%d\n", sc,
|
|
slave, punit));
|
|
|
|
clear.c_unit = CS80CMD_SUNIT(punit);
|
|
clear.c_cmd = CS80CMD_CLEAR;
|
|
if (cs80send(sc, slave, punit, CS80CMD_TCMD, &clear, sizeof(clear))) {
|
|
DPRINTF(DBG_FAIL, ("cs80reset: CLEAR failed\n"));
|
|
return (1);
|
|
}
|
|
|
|
sr.c_unit = CS80CMD_SUNIT(15); /* XXX */
|
|
sr.c_nop = CS80CMD_NOP;
|
|
sr.c_cmd = CS80CMD_SREL;
|
|
sr.c_param = 0xc0; /* XXX */
|
|
if (cs80send(sc, slave, punit, CS80CMD_SCMD, &sr, sizeof(sr))) {
|
|
DPRINTF(DBG_FAIL, ("cs80reset: SREL failed\n"));
|
|
return (1);
|
|
}
|
|
|
|
ssm.c_unit = CS80CMD_SUNIT(punit);
|
|
ssm.c_cmd = CS80CMD_SSM;
|
|
ssm.c_refm = htobe16(REF_MASK);
|
|
ssm.c_fefm = htobe16(FEF_MASK);
|
|
ssm.c_aefm = htobe16(AEF_MASK);
|
|
ssm.c_iefm = htobe16(IEF_MASK);
|
|
if (cs80send(sc, slave, punit, CS80CMD_SCMD, &ssm, sizeof(ssm))) {
|
|
DPRINTF(DBG_FAIL, ("cs80reset: SSM failed\n"));
|
|
return (1);
|
|
}
|
|
|
|
return (0);
|
|
}
|
|
|
|
int
|
|
cs80status(v, slave, punit, css)
|
|
void *v;
|
|
int slave;
|
|
int punit;
|
|
struct cs80_stat *css;
|
|
{
|
|
struct cs80bus_softc *sc = v;
|
|
struct cs80_statuscmd rs;
|
|
u_int8_t stat;
|
|
|
|
rs.c_unit = CS80CMD_SUNIT(punit);
|
|
rs.c_sram = CS80CMD_SRAM;
|
|
rs.c_param = 0; /* single vector (i.e. sector number) */
|
|
rs.c_cmd = CS80CMD_STATUS;
|
|
memset((void *)css, 0, sizeof(*css));
|
|
(void) gpibsend(sc->sc_ic, slave, CS80CMD_SCMD, &rs, sizeof(rs));
|
|
(void) gpibrecv(sc->sc_ic, slave, CS80CMD_EXEC, css, sizeof(*css));
|
|
(void) gpibrecv(sc->sc_ic, slave, CS80CMD_QSTAT, &stat, 1);
|
|
if (stat != 0) {
|
|
DPRINTF(DBG_FAIL, ("cs80status: failed, stat=0x%x\n", stat));
|
|
return (1);
|
|
}
|
|
BE16TOH(css->c_ref);
|
|
BE16TOH(css->c_fef);
|
|
BE16TOH(css->c_aef);
|
|
BE16TOH(css->c_ief);
|
|
BE32TOH(css->c_blk);
|
|
|
|
return (0);
|
|
}
|
|
|
|
int
|
|
cs80setoptions(v, slave, punit, options)
|
|
void *v;
|
|
int slave;
|
|
int punit;
|
|
u_int8_t options;
|
|
{
|
|
struct cs80bus_softc *sc = v;
|
|
struct cs80_soptcmd opt;
|
|
|
|
opt.c_unit = CS80CMD_SUNIT(punit);
|
|
opt.c_nop = CS80CMD_NOP;
|
|
opt.c_opt = CS80CMD_SOPT;
|
|
opt.c_param = options;
|
|
if (cs80send(sc, slave, punit, CS80CMD_SCMD, &opt, sizeof(opt))) {
|
|
DPRINTF(DBG_FAIL, ("cs80setoptions: failed\n"));
|
|
return (1);
|
|
}
|
|
|
|
return (0);
|
|
}
|
|
|
|
int
|
|
cs80send(v, slave, punit, cmd, ptr, cnt)
|
|
void *v;
|
|
int slave;
|
|
int punit;
|
|
int cmd;
|
|
void *ptr;
|
|
int cnt;
|
|
{
|
|
struct cs80bus_softc *sc = v;
|
|
u_int8_t *buf = ptr;
|
|
u_int8_t stat;
|
|
|
|
DPRINTF(DBG_FOLLOW,
|
|
("cs80send: sc=%p slave=%d punit=%d cmd=%d ptr=%p cnt=%d\n", sc,
|
|
slave, punit, cmd, buf, cnt));
|
|
|
|
if (gpibsend(sc->sc_ic, slave, cmd, buf, cnt) != cnt) {
|
|
DPRINTF(DBG_FAIL, ("cs80send: SCMD failed\n"));
|
|
return (1);
|
|
}
|
|
if (gpibswait(sc->sc_ic, slave)) {
|
|
DPRINTF(DBG_FAIL, ("cs80send: wait failed\n"));
|
|
return (1);
|
|
}
|
|
if (gpibrecv(sc->sc_ic, slave, CS80CMD_QSTAT, &stat, 1) != 1) {
|
|
DPRINTF(DBG_FAIL, ("cs80send: QSTAT failed\n"));
|
|
return (1);
|
|
}
|
|
if (stat != 0) {
|
|
DPRINTF(DBG_FAIL, ("cs80send: failed, stat=0x%x\n", stat));
|
|
return (1);
|
|
}
|
|
|
|
return (0);
|
|
}
|