d/freebsd-skq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
7e4a9dced9
freebsd-skq/sys/i386/isa/ida.c
julian 2326a927fb Compaq "Intelligent Disk Array" driver. 
Mark Dawson holds teh copyright on this and has releases from
Compaq to allow him to do so..

Not functional in 4.0 yet but being checked in to allow the functional
3.x version to be branched at this point.
1999-05-25 19:45:17 +00:00

1787 lines
45 KiB
C
Raw Blame History

/*
* Copyright (c) 1996, 1997, 1998, 1999
* Mark Dawson and David James. All rights reserved.
*
* 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 immediately at the beginning of the file, without modification,
* 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. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
*
* $Id$
*
*/
/*
* Compaq SMART disk array controller driver for FreeBSD.
* Supports the Compaq SMART-2 and SMART-3 families of disk
* array controllers.
*
*/
#include "id.h"
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/conf.h>
#include <sys/errno.h>
#include <sys/malloc.h>
#include <sys/buf.h>
#include <sys/file.h>
#include <sys/stat.h>
#include <sys/proc.h>
#include <sys/sysctl.h>
#include <i386/isa/isa.h>
#include <i386/isa/isa_device.h>
#ifdef DEVFS
#include <sys/devfsext.h>
#endif /*DEVFS*/
/*#include <sys/dkbad.h>*/
#include <sys/devicestat.h>
#include <sys/disklabel.h>
#include <sys/diskslice.h>
#include <vm/vm.h>
#include <vm/vm_param.h>
#include <vm/vm_prot.h>
#include <vm/pmap.h>
#include <pci.h>
#include <pci/pcireg.h>
#include <pci/pcivar.h>
#include <sys/reboot.h>
extern u_long bootdev;
#define IDA_VERSION 1
#define PAGESIZ 4096
/* IDA wdc vector stealing (cuckoo) control */
#define IDA_CUCKOO_NEVER 0 /* never steal wdc vectors */
#define IDA_CUCKOO_ROOTWD 1 /* steal iff rootdev is wd device */
#define IDA_CUCKOO_ROOTNOTIDA 2 /* steal if rootdev not ida device */
#define IDA_CUCKOO_ALWAYS 3 /* always steal wdc vectors */
#ifndef IDA_CUCKOO_MODE
#define IDA_CUCKOO_MODE IDA_CUCKOO_ALWAYS
#endif
/* IDA PCI controller */
#define PCI_DEVICE_ID_COMPAQ_SMART2P 0xae100e11ul
#define PCI_CONTROLLER(ctlp) (ctlp->ident == PCI_DEVICE_ID_COMPAQ_SMART2P)
typedef struct ida_pci_reg {
u_long unknown;
u_long initiate_fifo;
#define IDA_PCI_BUSY 1
u_long complete_fifo;
u_long interrupt;
#define IDA_PCI_ENABLE_INTS 1
#define IDA_PCI_DISABLE_INTS 0
u_long status;
#define IDA_PCI_PENDING 1
#define IDA_PCI_READY 2
} ida_pci_reg_t;
/* IDA controller register definitions */
#define R_ID0 0xc80 /* id byte 0 */
#define R_ID1 0xc81 /* id byte 1 */
#define R_ID2 0xc82 /* id byte 2 */
#define R_ID3 0xc83 /* id byte 3 */
#define R_CONF 0xc88 /* global configuration */
#define R_SYSINT 0xc89 /* system interrupt enable/ctrl */
#define R_SEM0 0xc8a /* semaphore port 0 */
#define R_SEM1 0xc8b /* semaphore port 1 */
#define R_LBELL_E 0xc8c /* local doorbell enable */
#define R_LBELL_I 0xc8d /* local doorbell int/status */
#define R_EBELL_E 0xc8e /* EISA doorbell enable */
#define R_EBELL_I 0xc8f /* EISA doorbell int/status */
#define R_SUB_ADDR 0xc90 /* submit address */
#define R_SUB_LEN 0xc94 /* submit cmdlist size */
#define R_COM_ADDR 0xc98 /* completion address */
#define R_COM_OFF 0xc9c /* completion request offset */
#define R_COM_STAT 0xc9e /* completion cmdlist status */
#define R_INTDEF 0xcc0 /* interrupt definition */
/*
* BMIC doorbell status codes
*/
#define BMIC_DATA_READY 0x01 /* data ready bit */
#define BMIC_CHAN_CLEAR 0x02 /* channel clear bit */
/* IDA controller command list return status values */
#define IDA_COMPL_OK 0x01 /* command list completed ok */
#define IDA_NON_FATAL 0x02 /* non-fatal error */
#define IDA_FATAL 0x04 /* fatal error */
#define IDA_ABORTED 0x08 /* command list aborted */
#define IDA_INVAL_REQ 0x10 /* bad request block */
#define IDA_INVAL_LIST 0x20 /* bad command list */
#define IDA_AARGH_LIST 0x40 /* totally disastrous command list */
/* IDA controller command codes */
#define IDA_GET_DRV_INFO 0x10
#define IDA_GET_CTL_INFO 0x11
#define IDA_READ_DATA 0x20
#define IDA_WRITE_DATA 0x30
#define IDA_FLUSH_CACHE 0xc2
/* Interrupt definition codes */
#define IDA_IRQ_MASK 0xfc
#define IDA_IRQ_10 0x20
#define IDA_IRQ_11 0x10
#define IDA_IRQ_14 0x40
#define IDA_IRQ_15 0x80
/* IDA controller hardware command structure definitions */
typedef u_long physaddr_t;
struct ida_hdr {
u_long drive:8; /* logical drive */
u_long priority:8; /* block priority */
u_long flags:16; /* control flags */
};
struct ida_req {
u_long next:16; /* offset of next request */
u_long command:8; /* command */
u_long error:8; /* return error code */
u_long blkno; /* block number */
u_short bcount; /* block count */
u_short sgcount; /* number of scatter gather entries */
/* a struct ida_req is followed physically by an array of struct ida_sgb */
};
struct ida_sgb {
u_long len; /* length of scatter gather segmmentk */
physaddr_t addr; /* physical address of block */
};
/* first some handy definitions as FreeBSD gcc doesn't do #pragma pack() */
#define pack_char(name) u_char name[1]
#define pack_short(name) u_char name[2]
#define pack_int(name) u_char name[4]
#define pack_long(name) u_char name[4]
/* ugly, but not inefficient, as it gets evaluated at compile time by gcc */
#define u_unpack(member) ( \
(sizeof(member) == 1) ? *(u_char *)(member) \
: (sizeof(member) == 2) ? *(u_short *)(member) \
: *(u_int *)(member) \
)
#define s_unpack(member) ( \
(sizeof(member) == 1) ? *(char *)(member) \
: (sizeof(member) == 2) ? *(short *)(member) \
: *(int *)(member) \
)
/* IDA controller hardware returned data structure definitions */
struct ida_ctl_info {
pack_char(num_drvs);
pack_long(signature);
pack_long(firm_rev);
};
struct ida_drv_info {
pack_short(secsize);
pack_long(secperunit);
pack_short(ncylinders);
pack_char(ntracks);
pack_char(signature);
pack_char(psectors);
pack_short(wprecomp);
pack_char(max_acc);
pack_char(control);
pack_short(pcylinders);
pack_char(ptracks);
pack_short(landing_zone);
pack_char(nsectors);
pack_char(checksum);
pack_char(mirror);
};
/* IDA driver queue command block */
#define IDA_MAX_SGLEN 32 /* maximum entries in scatter gather list */
#define IDA_MAX_DRVS_CTLR 8 /* maximum logical drives per controller */
#define IDA_DEF_PRIORITY 16 /* default priority for command list */
#define IDA_SCSI_TARGET_ID 7
#define IDA_QCB_MAX 256
struct ida_qcb {
/* first some hardware specific fields ... */
struct ida_hdr hdr;
struct ida_req req;
struct ida_sgb sglist[IDA_MAX_SGLEN];
/* and then some driver queue managment stuff */
u_int flags; /* qcb type */
#define QCB_FREE 0 /* ready for a new command */
#define QCB_ACTIVE 1 /* waiting to be sent to the controller */
#define QCB_SENT 2 /* waiting for interrupt from the controller */
#define QCB_IMMED 4 /* immediate (non-queued) command */
#define QCB_IMMED_FAIL 8
struct ida_qcb *next; /* next ida command block of this type */
struct ida_qcb *last; /* last ida command block of this type */
struct buf *buf; /* buf associated with this qcb */
physaddr_t paddr; /* physical address of this struct */
struct ida_qcb *nexthash; /* next ida command block with same hash value */
};
typedef struct ida_qcb qcb_t;
/* IDA driver controller and drive information blocks */
#define QCB_HASH_SIZE 257 /* some suitable prime number */
#define QCB_HASH(h) ((h) % QCB_HASH_SIZE)
struct ida_drv {
u_int flags;
#define ID_INIT 0x0001
#define ID_WRITEPROT 0x0002
#define ID_DEV_OPEN 0x0004
u_int ctl_unit; /* which controller is this drive on */
u_int drv_unit; /* number of this virtual disk */
struct ida_drv_info drv_info; /* data from the controller */
struct diskslices *slices; /* new slice code */
struct devstat dk_stats; /* devstat entry */
};
struct ida_ctl {
u_int ident; /* controller identifier */
u_int flags;
u_int iobase;
u_short inside; /* number of qcbs in the controller */
u_short max_inside; /* maximum number simulaneously active */
u_short num_qcbs; /* number of qcbs allocated */
u_char num_drvs;
u_char irq;
u_char com_status; /* status of last completed command list */
physaddr_t com_addr; /* address of last completed command list */
u_short com_offset; /* offset of last completed command list */
qcb_t *freelist; /* linked list of free qcbs */
qcb_t *send_next; /* doubly-linked list of unsent qcbs */
qcb_t *send_last; /* because we must treat all jobs equally */
qcb_t *hashlist[QCB_HASH_SIZE];
};
extern struct ida_ctl *idadata[NIDA];
/* Useful IDA controller IO macro definitions */
#define IDA_DISABLE_INTERRUPT(iobase) outb(iobase + R_SYSINT, 0)
#define IDA_ENABLE_INTERRUPT(ctlp) outb(ctlp->iobase + R_SYSINT, 1)
#define IDA_SET_READY(ctlp) outb(ctlp->iobase + R_EBELL_E, 1)
#define IDA_DATA_READY(ctlp) ((inb(ctlp->iobase + R_EBELL_I) & 1))
#define IDA_CHAN_CLEAR(ctlp) ((inb(ctlp->iobase + R_EBELL_I) & 2))
/* enable/disable interrupts on a change of channel clear status (?) */
#define IDA_ENABLE_CHAN(ctlp) \
outb(ctlp->iobase + R_EBELL_E, inb(ctlp->iobase + R_EBELL_E) | 2)
#define IDA_DISABLE_CHAN(ctlp) \
outb(ctlp->iobase + R_EBELL_E, inb(ctlp->iobase + R_EBELL_E) & ~0x2)
/* acknowledge the completion of a command */
#define IDA_ACK_CMD_COM(ctlp) \
(outb(ctlp->iobase + R_EBELL_I, 1), outb(ctlp->iobase + R_LBELL_I, 2))
/* set submission details for a command list */
#define IDA_SET_SUB_ADDR(ctlp, addr) outl(ctlp->iobase + R_SUB_ADDR, addr)
#define IDA_SET_SUB_LEN(ctlp, size) outw(ctlp->iobase + R_SUB_LEN, size)
/* get completion details for a command list */
#define IDA_GET_COM_ADDR(ctlp) inl(ctlp->iobase + R_COM_ADDR)
#define IDA_GET_COM_OFFSET(ctlp) inw(ctlp->iobase + R_COM_OFF)
#define IDA_GET_COM_STATUS(ctlp) inb(ctlp->iobase + R_COM_STAT)
#define IDA_READ_EBELL_I(ctlp) inb(ctlp->iobase + R_EBELL_I)
#define IDA_READ_EBELL_E(ctlp) inb(ctlp->iobase + R_EBELL_E)
#define IDA_READ_LBELL_I(ctlp) inb(ctlp->iobase + R_LBELL_I)
#define IDA_SET_EBELL_I(ctlp, n) outb(ctlp->iobase + R_EBELL_I, n)
#define IDA_SET_LBELL_I(ctlp, n) outb(ctlp->iobase + R_LBELL_I, n)
#define JOB_SUCCESS 0
#define JOB_FAILURE 1
#define JOB_ABORTED 2
/* debugging aids */
#ifdef IDADEBUG
# define IDA_MAXQCBS (1<<0)
# define IDA_SHOWQCBS (1<<1)
# define IDA_SHOWSUBS (1<<2)
# define IDA_SHOWINTS (1<<3)
# define IDA_SHOWCMDS (1<<4)
# define IDA_SHOWMISC (1<<5)
void ida_print_qcb(qcb_t *qcbp);
void ida_print_active_qcb(int unit);
static int ida_debug = 0;
SYSCTL_INT(_debug, OID_AUTO, ida_debug, CTLFLAG_RW, &ida_debug, 0, "");
#endif
static int ida_soft_errors = 0;
SYSCTL_INT(_debug, OID_AUTO, ida_soft_errors,
CTLFLAG_RW, &ida_soft_errors, 0, "");
/* EISA probe and board identification definitions */
#define MAX_EISA_SLOT 16
#define IDA_EISA_PROD_ID 0x40
union eisa_id {
u_int value;
struct {
u_int rev:8;
u_int prod:8;
u_int mfr2:5;
u_int mfr1:5;
u_int mfr0:5;
} split;
};
/* test the manufacturer ID within an EISA board ID */
#define EISA_MFR_EQ(ident, mfr) ( \
(ident).split.mfr0 + '@' == (mfr)[0] && \
(ident).split.mfr1 + '@' == (mfr)[1] && \
(ident).split.mfr2 + '@' == (mfr)[2] \
)
/* generates a list of EISA board ID values, suitable for a printf */
#define EISA_ID_LIST(ident) \
(ident).split.mfr0 + '@', \
(ident).split.mfr1 + '@', \
(ident).split.mfr2 + '@', \
(ident).split.prod, \
(ident).split.rev
extern void DELAY(int millisecs);
/* FreeBSD IDA driver forward function definitions */
static d_open_t idopen;
static d_read_t idread;
static d_write_t idwrite;
static d_close_t idclose;
static d_strategy_t idstrategy;
static d_ioctl_t idioctl;
static d_dump_t iddump;
static d_psize_t idsize;
static pci_inthand_t idaintr;
static const char *ida_pci_probe(pcici_t tag, pcidi_t type);
static void ida_pci_attach(pcici_t config_id, int unit);
static int ida_eisa_probe __P((struct isa_device *dev));
static int ida_eisa_attach __P((struct isa_device *dev));
static int ida_poll __P((int unit, int wait));
static void idaminphys __P((struct buf *bp));
static void ida_start __P((int unit));
static int ida_get_ctl_info(int unit);
static int ida_attach_drives(int unit);
void ida_done(int cntlr, qcb_t *qcbp, int state);
static void ida_queue_buf(int cntlr, struct buf *bp);
static void ida_newqueue(int cntlr);
static qcb_t *ida_dequeue(int cntlr);
static void ida_enqueue(int cntlr, qcb_t *qcbp);
static int ida_submit(int unit, qcb_t *qcbp, int size);
static int ida_submit_wait(int unit, qcb_t *qcbp, int size);
static qcb_t *ida_get_qcb(int unit);
static void ida_free_qcb(int unit, qcb_t *qcbp);
static qcb_t *ida_qcb_phys_kv(struct ida_ctl *ida, physaddr_t ida_qcb_phys);
static struct cdevsw id_cdevsw;
struct isa_driver idadriver = {
ida_eisa_probe,
ida_eisa_attach,
"ida"
};
static u_long ida_pci_count;
static struct pci_device ida_pci_driver = {
"ida",
ida_pci_probe,
ida_pci_attach,
&ida_pci_count
};
DATA_SET (pcidevice_set, ida_pci_driver);
/* definitions for stealing wd driver's vectors */
#define ID_BDMAJ 29
#define ID_CDMAJ 109
#define WD_BDMAJ 0
#define WD_CDMAJ 3
struct isa_driver wdcdriver;
static int stub_probe __P((struct isa_device *dev));
static int stub_attach __P((struct isa_device *dev));
static struct isa_driver nodriver = {
stub_probe,
stub_attach,
"stub"
};
/* steal the wdc driver's vectors if we have booted off a wd device */
static
void
ida_cuckoo_wdc(void)
{
int cuckoo = IDA_CUCKOO_MODE;
int steal = 0;
char *mode;
int major = B_TYPE(bootdev);
if (cuckoo == IDA_CUCKOO_NEVER) {
mode = "never";
} else if (cuckoo == IDA_CUCKOO_ROOTWD) {
mode = "rootwd";
steal = (major == WD_BDMAJ);
} else if (cuckoo == IDA_CUCKOO_ROOTNOTIDA) {
mode = "notida";
/* check for magic value of 3 rather than ID_BDMAJ as boot code
* pretends we are a wt device (not normally bootable)
*/
steal = (major != 3);
} else {
mode = "always";
steal = 1;
}
printf("ida: wdc vector stealing %s (mode = %s, boot major = %d)\n",
(steal ? "on" : "off"), mode, major);
if (!steal) return;
/* OK - we have a controller, so steal wd driver's vectors */
wdcdriver = nodriver;
bdevsw[WD_BDMAJ]->d_open = cdevsw[WD_CDMAJ]->d_open = idopen;
bdevsw[WD_BDMAJ]->d_close = cdevsw[WD_CDMAJ]->d_close = idclose;
bdevsw[WD_BDMAJ]->d_read = cdevsw[WD_CDMAJ]->d_read = idread;
bdevsw[WD_BDMAJ]->d_write = cdevsw[WD_CDMAJ]->d_write = idwrite;
bdevsw[WD_BDMAJ]->d_strategy = cdevsw[WD_CDMAJ]->d_strategy = idstrategy;
bdevsw[WD_BDMAJ]->d_ioctl = cdevsw[WD_CDMAJ]->d_ioctl = idioctl;
bdevsw[WD_BDMAJ]->d_dump = iddump;
bdevsw[WD_BDMAJ]->d_psize = idsize;
return;
}
static struct ida_ctl *idadata[NIDA]; /* controller structures */
static struct ida_drv *id_drive[NID]; /* table of drives */
static int id_unit = 0; /* number of drives found */
/* general purpose data buffer for 'special' IDA driver commands */
union ida_buf {
char pad[512];
struct ida_ctl_info ctl;
struct ida_drv_info drv;
} ida_buf;
static int
stub_probe(struct isa_device *dev)
{
return 0;
}
static int
stub_attach(struct isa_device *dev)
{
return 0;
}
const char *
ida_pci_probe(pcici_t tag, pcidi_t type)
{
switch (type) {
case PCI_DEVICE_ID_COMPAQ_SMART2P:
return "Compaq SMART-2/P array controller";
break;
default:
break;
}
return NULL;
}
static void
ida_pci_attach(pcici_t config_id, int unit)
{
ida_pci_reg_t *reg;
struct ida_ctl *ctlp;
u_long id;
vm_offset_t paddr, vaddr;
id = pci_conf_read(config_id, PCI_ID_REG);
switch (id) {
case PCI_DEVICE_ID_COMPAQ_SMART2P:
break;
default:
break;
}
if (!pci_map_mem(config_id, 0x14, &vaddr, &paddr)) {
printf("ida: map failed.\n");
return;
}
/* allocate and initialise a storage area for this controller */
if (idadata[unit]) {
printf("ida%d: controller structure already allocated\n", unit);
return;
}
if ((ctlp = malloc(sizeof(struct ida_ctl), M_TEMP, M_NOWAIT)) == NULL) {
printf("ida%d: unable to allocate controller structure\n", unit);
return;
}
idadata[unit] = ctlp;
bzero(ctlp, sizeof(struct ida_ctl));
ctlp->ident = id;
ctlp->iobase = vaddr;
/* Install the interrupt handler. */
if (!pci_map_int (config_id, idaintr, (void *)unit, &bio_imask)) {
printf ("ida%d: failed to assign an interrupt handler\n", unit);
free((caddr_t)ctlp, M_DEVBUF);
idadata[unit] = 0;
return;
}
if (!(ida_get_ctl_info(unit) && ida_attach_drives(unit))) {
return;
}
reg = (ida_pci_reg_t *) vaddr;
reg->interrupt = IDA_PCI_ENABLE_INTS;
ida_cuckoo_wdc();
return;
}
int
ida_eisa_probe(struct isa_device *dev)
{
static u_int ida_used = 0;
u_int slot;
u_int port;
u_char intdef;
u_char irq;
int unit = dev->id_unit;
union eisa_id ident;
struct ida_ctl *ctlp;
if (dev->id_iobase) {
/* check out the configured iobase if given one */
slot = dev->id_iobase / 0x1000;
if (slot == 0 || slot > MAX_EISA_SLOT) {
printf("ida: port address (0x%x) out of range\n", dev->id_iobase);
return 0;
}
} else {
/* otherwise, search from the beginning for an unused slot to check out */
slot = 1;
}
while (1) {
while (ida_used & (1 << slot)) {
if (slot++ == MAX_EISA_SLOT) return 0;
}
ida_used |= (1 << slot);
port = slot * 0x1000;
/* read the EISA identification bytes */
ident.value = inb(port + R_ID0);
ident.value <<= 8;
ident.value |= inb(port + R_ID1);
ident.value <<= 8;
ident.value |= inb(port + R_ID2);
ident.value <<= 8;
ident.value |= inb(port + R_ID3);
/* check that the card is the right type ? */
if (EISA_MFR_EQ(ident, "CPQ") && ident.split.prod == IDA_EISA_PROD_ID) {
break;
}
/* if we were config'ed with an iobase, then don't probe any more slots */
if (dev->id_iobase) return 0;
}
/* disable interrupts and find out what interrupt this controller uses */
IDA_DISABLE_INTERRUPT(port);
intdef = inb(port + R_INTDEF);
switch (intdef & IDA_IRQ_MASK) {
case IDA_IRQ_10:
irq = 10;
break;
case IDA_IRQ_11:
irq = 11;
break;
case IDA_IRQ_14:
irq = 14;
break;
case IDA_IRQ_15:
irq = 15;
break;
default:
printf("ida: slot %d bogus interrupt setting (0x%02x)\n", slot, intdef);
return 0;
}
dev->id_irq = (1 << irq);
dev->id_drq = -1;
/* allocate and initialise a storage area for this controller */
if (idadata[unit]) {
printf("ida%d: controller structure already allocated\n", unit);
return 0;
}
if ((ctlp = malloc(sizeof(struct ida_ctl), M_TEMP, M_NOWAIT)) == NULL) {
printf("ida%d: unable to allocate controller structure\n", unit);
return 0;
}
idadata[unit] = ctlp;
bzero(ctlp, sizeof(struct ida_ctl));
ctlp->iobase = dev->id_iobase = port;
ctlp->ident = ident.value;
ctlp->irq = irq;
if (ida_get_ctl_info(unit) == 0) {
return 0;
}
/* return range of io ports used */
return 0x1000;
}
int
ida_get_ctl_info(int unit)
{
struct ida_ctl *ctlp = idadata[unit];
qcb_t qcb;
qcb_t *qcbp = &qcb;
ida_newqueue(unit);
/* controller capacity statistics */
ctlp->inside = 0;
ctlp->max_inside = 0;
/* ask the controller to tell us about itself with an IDA_GET_CTL_INFO */
bzero(qcbp, sizeof(qcb_t));
qcbp->paddr = vtophys(qcbp);
if (PCI_CONTROLLER(ctlp)) {
qcbp->hdr.priority = 0x00;
qcbp->hdr.flags = 0x24;
} else {
qcbp->hdr.priority = IDA_DEF_PRIORITY;
qcbp->hdr.flags = 0x12;
}
qcbp->req.command = IDA_GET_CTL_INFO;
qcbp->req.bcount = 1;
qcbp->req.sgcount = 1;
qcbp->sglist[0].len = sizeof(ida_buf);
qcbp->sglist[0].addr = vtophys(&ida_buf);
if (ida_submit_wait(unit, qcbp, sizeof(struct ida_qcb))) {
printf("ida%d: idasubmit failed on IDA_GET_CTL_INFO\n", unit);
return 0;
}
if (!PCI_CONTROLLER(ctlp)) {
if (ctlp->com_status != IDA_COMPL_OK) {
printf("ida%d: bad status 0x%02x from IDA_GET_CTL_INFO\n",
unit, ctlp->com_status);
return 0;
}
}
/* got the information at last, print it and note the number of drives */
printf("ida%d: drvs=%d firm_rev=%c%c%c%c\n", unit,
u_unpack(ida_buf.ctl.num_drvs), ida_buf.ctl.firm_rev[0],
ida_buf.ctl.firm_rev[1], ida_buf.ctl.firm_rev[2],
ida_buf.ctl.firm_rev[3]);
ctlp->num_drvs = u_unpack(ida_buf.ctl.num_drvs);
return 1;
}
int
ida_attach_drives(int cntlr)
{
struct ida_ctl *ctlp = idadata[cntlr];
qcb_t qcb;
qcb_t *qcbp = &qcb;
struct ida_drv *drv;
int drive;
int unit;
/* prepare to interrogate the drives */
bzero(qcbp, sizeof(qcb_t));
qcbp->req.command = IDA_GET_DRV_INFO;
qcbp->paddr = vtophys(qcbp);
if (PCI_CONTROLLER(ctlp)) {
qcbp->hdr.priority = 0x00;
qcbp->hdr.flags = 0x24;
} else {
qcbp->hdr.priority = IDA_DEF_PRIORITY;
qcbp->hdr.flags = 0x12;
}
qcbp->req.bcount = 1;
qcbp->req.sgcount = 1;
qcbp->sglist[0].len = sizeof(ida_buf);
qcbp->sglist[0].addr = vtophys(&ida_buf);
for (drive = 0 ; drive < ctlp->num_drvs ; drive++) {
qcbp->hdr.drive = drive;
if (ida_submit_wait(cntlr, qcbp, sizeof(struct ida_qcb))) {
printf("ida%d: ida_submit_wait failed on IDA_GET_DRV_INFO\n", cntlr);
return 0;
}
if (!PCI_CONTROLLER(ctlp)) {
if (ctlp->com_status != IDA_COMPL_OK) {
printf("ida%d: bad status 0x%02x from IDA_GET_DRV_INFO\n",
cntlr, ctlp->com_status);
return 0;
}
}
if ((drv = malloc(sizeof(struct ida_drv), M_TEMP, M_NOWAIT)) == NULL) {
printf("ida%d: unable to allocate drive structure\n", cntlr);
return 0;
}
bzero(drv, sizeof(struct ida_drv));
drv->ctl_unit = cntlr;
drv->drv_unit = drive;
drv->drv_info = ida_buf.drv;
drv->flags |= ID_INIT;
unit = id_unit;
id_unit++; /* XXX unsure if this is the right way to do things */
id_drive[unit] = drv;
printf("ida%d: unit %d (id%d): <%s>\n",
cntlr, drive, unit, "Compaq Logical Drive");
printf("id%d: %luMB (%lu total sec), ",
unit,
(u_long)(u_unpack(drv->drv_info.secperunit) / 2048)
* (u_unpack(drv->drv_info.secsize) / 512),
(u_long)u_unpack(drv->drv_info.secperunit));
printf("%lu cyl, %lu head, %lu sec, bytes/sec %lu\n",
(u_long)u_unpack(drv->drv_info.ncylinders),
(u_long)u_unpack(drv->drv_info.ntracks),
(u_long)u_unpack(drv->drv_info.nsectors),
(u_long)u_unpack(drv->drv_info.secsize));
/*
* Export the drive to the devstat interface.
*/
devstat_add_entry(&drv->dk_stats, "id",
unit, (u_int32_t)drv->drv_info.secsize,
DEVSTAT_NO_ORDERED_TAGS,
DEVSTAT_TYPE_DIRECT | DEVSTAT_TYPE_IF_OTHER);
#ifdef IDADEBUG
if (ida_debug & IDA_SHOWMISC) {
printf("ida%d: drive %d secsize=%d secperunit=%d ncylinders=%d ntracks=%d\n",
unit,
drive,
u_unpack(ida_buf.drv.secsize),
u_unpack(ida_buf.drv.secperunit),
u_unpack(ida_buf.drv.ncylinders),
u_unpack(ida_buf.drv.ntracks));
printf(" signature=0x%02x psectors=%d wprecomp=%d max_acc=%d control=0x%02x\n",
u_unpack(ida_buf.drv.signature),
u_unpack(ida_buf.drv.psectors),
u_unpack(ida_buf.drv.wprecomp),
u_unpack(ida_buf.drv.max_acc),
u_unpack(ida_buf.drv.control));
printf(" pcylinders=%d ptracks=%d landing_zone=%d nsectors=%d checksum=0x%02x\n",
u_unpack(ida_buf.drv.pcylinders),
u_unpack(ida_buf.drv.ptracks),
u_unpack(ida_buf.drv.landing_zone),
u_unpack(ida_buf.drv.nsectors),
u_unpack(ida_buf.drv.checksum));
}
#endif
}
return 1;
}
/* Attach all the sub-devices we can find. */
int
ida_eisa_attach(struct isa_device *dev)
{
int cntlr = dev->id_unit;
struct ida_ctl *ctlp = idadata[cntlr];
if (ida_attach_drives(cntlr)) {
IDA_ENABLE_INTERRUPT(ctlp);
IDA_SET_READY(ctlp);
ida_cuckoo_wdc();
return 1;
} else {
return 0;
}
}
/*
* Initialize a drive.
*/
int
idopen(dev_t dev, int flags, int fmt, struct proc *p)
{
struct ida_drv *drv;
int part = dkpart(dev);
int unit = dkunit(dev);
struct disklabel label;
int err;
if (unit >= NID || part >= MAXPARTITIONS) /* bounds check */
return(ENXIO);
drv = id_drive[unit];
if (!drv || !(drv->flags & ID_INIT)) /* drive not initialised */
return(ENXIO);
drv->flags |= ID_DEV_OPEN;
/* knock up a label for the whole disk. */
bzero(&label, sizeof label);
label.d_secsize = u_unpack(drv->drv_info.secsize);
label.d_nsectors = u_unpack(drv->drv_info.nsectors);
label.d_ntracks = u_unpack(drv->drv_info.ntracks);
label.d_ncylinders = u_unpack(drv->drv_info.ncylinders);
label.d_secpercyl =
u_unpack(drv->drv_info.ntracks) * u_unpack(drv->drv_info.nsectors);
if (label.d_secpercyl == 0)
label.d_secpercyl = 100; /* prevent accidental division by zero */
label.d_secperunit = u_unpack(drv->drv_info.secperunit);
/* Initialize slice tables. */
if ((err = dsopen("id", dev, fmt, 0, &drv->slices, &label, idstrategy,
(ds_setgeom_t *)NULL, &id_cdevsw)) == NULL) {
return 0;
}
if (!dsisopen(drv->slices)) {
drv->flags &= ~ID_DEV_OPEN;
}
return err;
}
/* ARGSUSED */
int
idclose(dev_t dev, int flags, int fmt, struct proc *p)
{
struct ida_drv *drv;
int part = dkpart(dev);
int unit = dkunit(dev);
if (unit >= NID || part >= MAXPARTITIONS) /* bounds check */
return(ENXIO);
drv = id_drive[unit];
dsclose(dev, fmt, drv->slices);
if (!dsisopen(drv->slices)) {
drv->flags &= ~ID_DEV_OPEN;
}
return 0;
}
int
idioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct proc *p)
{
struct ida_drv *drv;
int part = dkpart(dev);
int unit = dkunit(dev);
int err;
if (unit >= NID || part >= MAXPARTITIONS ||
!(drv = id_drive[unit]) || !(drv->flags & ID_INIT)) /* sanity check */
return(ENXIO);
err = dsioctl("id", dev, cmd, addr, flag, &drv->slices,
idstrategy, (ds_setgeom_t *)NULL);
if (err != -1)
return (err);
if (dkpart(dev) != RAW_PART)
return (ENOTTY);
return (0);
}
static int
idread(dev_t dev, struct uio *uio, int ioflag)
{
return (physio(idstrategy, NULL, dev, 1, minphys, uio));
}
static int
idwrite(dev_t dev, struct uio *uio, int ioflag)
{
return (physio(idstrategy, NULL, dev, 0, minphys, uio));
}
/* Read/write routine for a buffer. Finds the proper unit, range checks
* arguments, and schedules the transfer. Does not wait for the transfer
* to complete. Multi-page transfers are supported. All I/O requests must
* be a multiple of a sector in length.
*/
void
idstrategy(struct buf *bp)
{
int unit = dkunit(bp->b_dev);
struct ida_drv *drv;
int opri;
if (unit >= NID) {
printf("ida: unit out of range\n");
bp->b_error = EINVAL;
goto bad;
}
if (!(drv = id_drive[unit]) || !(drv->flags & ID_INIT)) {
printf("id%d: drive not initialised\n", unit);
bp->b_error = EINVAL;
goto bad;
}
if (bp->b_blkno < 0) {
printf("id%d: negative block requested\n", unit);
bp->b_error = EINVAL;
goto bad;
}
if (bp->b_bcount % DEV_BSIZE != 0) { /* bounds check */
printf("id%d: count (%lu) not a multiple of a block\n",
unit, bp->b_bcount);
bp->b_error = EINVAL;
goto bad;
}
idaminphys(bp); /* adjust the transfer size */
/* "soft" write protect check */
if ((drv->flags & ID_WRITEPROT) && (bp->b_flags & B_READ) == 0) {
bp->b_error = EROFS;
goto bad;
}
/* If it's a null transfer, return immediately */
if (bp->b_bcount == 0) {
goto done;
}
if (dscheck(bp, drv->slices) <= 0) {
goto done;
}
opri = splbio();
ida_queue_buf(unit, bp);
devstat_start_transaction(&drv->dk_stats);
ida_start(drv->ctl_unit); /* hit the appropriate controller */
splx(opri);
return /*0*/;
bad:
bp->b_flags |= B_ERROR;
done:
/* correctly set the buf to indicate a completed xfer */
bp->b_resid = bp->b_bcount;
biodone(bp);
return /*0*/;
}
void
idaminphys(bp)
struct buf *bp;
{
/* assumes each page requires an sgb entry */
int max = (IDA_MAX_SGLEN - 1) * PAGESIZ;
if (bp->b_bcount > max) {
bp->b_bcount = max;
}
}
/* Get a free qcb.
* If there are none, see if we can allocate a new one.
* If so, put it in the hash table too,
* otherwise either return an error or sleep.
*/
static qcb_t *
ida_get_qcb(int unit)
{
struct ida_ctl *ida = idadata[unit];
unsigned opri = 0;
qcb_t *qcbp;
int hashnum;
opri = splbio();
/* if the freelist is empty - create a qcb until limit is reached */
while (!(qcbp = ida->freelist)) {
if (ida->num_qcbs < IDA_QCB_MAX) {
qcbp = (qcb_t *)malloc(sizeof(qcb_t), M_TEMP, M_NOWAIT);
if (qcbp) {
bzero(qcbp, sizeof(qcb_t));
ida->num_qcbs++;
qcbp->flags = QCB_ACTIVE;
#ifdef IDADEBUG
if (ida_debug & IDA_SHOWQCBS)
printf("ida_get_qcb%d: qcb %d created\n",
unit, ida->num_qcbs);
#endif
/* Put in the phystokv hash table. */
/* Never gets taken out. */
qcbp->paddr = vtophys(qcbp);
hashnum = QCB_HASH(qcbp->paddr);
qcbp->nexthash = ida->hashlist[hashnum];
ida->hashlist[hashnum] = qcbp;
} else {
printf("ida%d: Can't malloc QCB\n", unit);
} goto gottit;
} else {
/* reached maximum allocation of qcbs - sleep until one is freed */
tsleep((caddr_t)&ida->freelist, PRIBIO, "idaqcb", 0);
}
} if (qcbp) {
/* qet the qcb from from the (non-empty) free list */
ida->freelist = qcbp->next;
qcbp->flags = QCB_ACTIVE;
}
gottit:
splx(opri);
#ifdef IDADEBUG
if (ida_debug & IDA_SHOWQCBS)
printf("ida_get_qcb%d: returns 0x%x\n", unit, qcbp);
#endif
return (qcbp);
}
/* Return a qcb to the free list */
static void
ida_free_qcb(int unit, qcb_t *qcbp)
{
unsigned int opri = 0;
struct ida_ctl *ida = idadata[unit];
#ifdef IDADEBUG
if (ida_debug & IDA_SHOWQCBS)
printf("ida_free_qcb%d: freeing 0x%x\n", unit, qcbp);
#endif
opri = splbio();
qcbp->next = ida->freelist;
ida->freelist = qcbp;
qcbp->flags = QCB_FREE;
/* if the free list was empty, wakeup anyone sleeping */
if (!qcbp->next) {
#ifdef IDADEBUG
if (ida_debug & IDA_SHOWQCBS)
printf("ida_free_qcb%d: about to wakeup 0x%x queue\n",
unit, &ida->freelist);
#endif
wakeup((caddr_t)&ida->freelist);
}
splx(opri);
}
/* Find the ida_qcb having a given physical address */
qcb_t *
ida_qcb_phys_kv(ida, ida_qcb_phys)
struct ida_ctl *ida;
physaddr_t ida_qcb_phys;
{
int hash = QCB_HASH(ida_qcb_phys);
qcb_t *qcbp = ida->hashlist[hash];
while (qcbp) {
if (qcbp->paddr == ida_qcb_phys)
break;
qcbp = qcbp->nexthash;
}
#ifdef IDADEBUG
if (ida_debug & IDA_SHOWQCBS)
printf("ida?: ida_qcb_phys_kv(0x%x) = 0x%x\n", ida_qcb_phys, qcbp);
#endif
return qcbp;
}
void
ida_queue_buf(int unit, struct buf *bp)
{
struct ida_drv *drv = id_drive[unit];
int cntlr = drv->ctl_unit;
qcb_t *qcbp = ida_get_qcb(cntlr); /* may cause us to wait */
struct ida_ctl *ida = idadata[cntlr];
unsigned int datalen = bp->b_bcount;
int thiskv = (int)bp->b_data;
physaddr_t thisphys = vtophys(thiskv);
int nsgb = 0; /* number of scatter/gather blocks used */
struct ida_sgb *sg = &(qcbp->sglist[0]);
/* fill in the qcb command header */
if (PCI_CONTROLLER(ida)) {
qcbp->hdr.priority = 0x00;
qcbp->hdr.flags = 0x24;
} else {
qcbp->hdr.priority = IDA_DEF_PRIORITY;
qcbp->hdr.flags = 0x10;
}
qcbp->hdr.drive = drv->drv_unit; /* logical drive number */
qcbp->buf = bp; /* the buf this command came from */
/* set up the scatter-gather list in the qcb */
while ((datalen) && (nsgb < IDA_MAX_SGLEN)) {
int bytes_this_seg = 0;
physaddr_t nextphys;
/* put in the base address */
sg->addr = thisphys;
/* do it at least once */
nextphys = thisphys;
while ((datalen) && (thisphys == nextphys)) {
int bytes_this_page;
/* This page is contiguous (physically) with the the last, */
/* just extend the length */
/* how far to the end of the page ... */
nextphys = (thisphys & (~(PAGESIZ - 1))) + PAGESIZ;
bytes_this_page = nextphys - thisphys;
/* ... or to the end of the data */
bytes_this_page = min(bytes_this_page, datalen);
bytes_this_seg += bytes_this_page;
datalen -= bytes_this_page;
/* get ready for the next page */
thiskv = (thiskv & (~(PAGESIZ - 1))) + PAGESIZ;
if (datalen)
thisphys = vtophys(thiskv);
}
/* next page isn't contiguous, finish the seg */
sg->len = bytes_this_seg;
sg++;
nsgb++;
}
if (datalen) { /* still data => command block too small */
printf("ida_queue_buf%d: more than %d scatter/gather blocks needed\n",
cntlr, IDA_MAX_SGLEN);
bp->b_error = EIO;
bp->b_flags |= B_ERROR;
biodone(bp);
return;
}
/* fill-in the I/O request block */
qcbp->req.error = 0;
qcbp->req.next = 0;
qcbp->req.blkno = bp->b_pblkno;
qcbp->req.bcount = bp->b_bcount >> 9;
qcbp->req.sgcount = nsgb;
qcbp->req.command = (bp->b_flags & B_READ ? IDA_READ_DATA : IDA_WRITE_DATA);
#ifdef IDADEBUG
if (ida_debug & IDA_SHOWQCBS) {
printf("ida_rw%d: queuing:\n", cntlr);
ida_print_qcb(qcbp);
}
#endif
/* queue for submission to the controller */
ida_enqueue(cntlr, qcbp);
}
void
ida_start(int cntlr)
{
struct ida_ctl *ida = idadata[cntlr];
qcb_t *qcbp;
int count = 0;
int opri = splbio();
if (!ida->send_next) { /* check there is a job in the queue */
splx(opri);
return;
}
if (PCI_CONTROLLER(ida)) {
ida_pci_reg_t *reg = (ida_pci_reg_t *)ida->iobase;
u_int fifo = reg->initiate_fifo;
if (fifo == 1) {
splx(opri);
return; /* not sent - must try again later */
}
/* submit upto 16 jobs at once into the initiate fifo */
while (count < 16 && (fifo = reg->initiate_fifo) != 1
&& (qcbp = ida_dequeue(cntlr))) {
reg->initiate_fifo = qcbp->paddr;
qcbp->flags = QCB_SENT;
ida->inside++;
count++;
}
} else {
if (!IDA_CHAN_CLEAR(ida)) {
IDA_ENABLE_CHAN(ida);
splx(opri);
return;
}
qcbp = ida_dequeue(cntlr);
#ifdef IDADEBUG
if (ida_debug & IDA_SHOWQCBS)
printf("ida%d: ida_start: sending 0x%x\n", cntlr, qcbp);
#endif
IDA_SET_EBELL_I(ida, 2);
IDA_SET_SUB_ADDR(ida, qcbp->paddr); /* physical address of this qcb */
IDA_SET_SUB_LEN(ida, sizeof(qcb_t));
IDA_SET_LBELL_I(ida, 1);
qcbp->flags = QCB_SENT;
ida->inside++;
count++;
}
if (ida->inside > ida->max_inside) {
ida->max_inside = ida->inside; /* new maximum */
splx(opri);
#ifdef IDADEBUG
if (ida_debug & IDA_MAXQCBS)
printf("ida%d: qcbs %d/%d\n", cntlr, ida->inside, ida->num_qcbs);
#endif
} else {
splx(opri);
}
#ifdef IDADEBUG
if ((ida_debug & IDA_SHOWSUBS) && count > 1)
printf("ida%d: %d jobs submitted (queue %s).\n",
cntlr, count, ida->send_next ? "not emptied" : "emptied");
#endif
}
void
ida_newqueue(int cntlr)
{
struct ida_ctl *ida = idadata[cntlr];
ida->send_next = 0;
ida->send_last = 0;
}
qcb_t *
ida_dequeue(int cntlr)
{
struct ida_ctl *ida = idadata[cntlr];
qcb_t *qcbp = ida->send_next; /* who is next? */
if (qcbp) { /* queue is not empty */
qcb_t* nextp = qcbp->next;
if (nextp) { /* more than one element in the queue */
nextp->last = 0; /* we are the first */
ida->send_next = nextp; /* hence first to go */
} else { /* exactly one element in the queue */
ida->send_last = ida->send_next = 0;
}
}
return qcbp;
}
static void
ida_enqueue(int cntlr, qcb_t *qcbp)
{
struct ida_ctl *ida = idadata[cntlr];
qcb_t *lastp = ida->send_last; /* who is last? */
int opri = splbio();
if (lastp) { /* if the queue is not empty */
lastp->next = qcbp; /* then we go after the last */
} else { /* if the queue was empty */
ida->send_next = qcbp; /* then we go next */
}
qcbp->last = lastp; /* we follow the last */
qcbp->next = 0; /* and nothing follows us */
ida->send_last = qcbp; /* we go last */
splx(opri);
}
void
idaintr(void *arg)
{
int cntlr = (int)arg;
qcb_t *qcbp;
struct ida_ctl *ida = idadata[cntlr];
u_char status;
physaddr_t paddr, paddr1; /* physical address of the qcb */
int offset; /* qcb offset */
u_char cstat; /* job status */
if (PCI_CONTROLLER(ida)) { /*pci:*/
ida_pci_reg_t *reg = (ida_pci_reg_t *)ida->iobase;
int status = reg->status;
#ifdef IDADEBUG
if (ida_debug & IDA_SHOWINTS)
printf("ida%d: idaintr: status=%x (before complete)\n"
, cntlr, status);
#endif
while (status & IDA_PCI_PENDING) {
paddr1 = reg->complete_fifo;
paddr = paddr1 & ~3;
qcbp = ida_qcb_phys_kv(ida, paddr);
#ifdef IDADEBUG
if (ida_debug & IDA_SHOWQCBS) {
printf("ida%d: idaintr: qcb(%x) completed\n", cntlr, qcbp);
ida_print_qcb(qcbp);
}
#endif
if (qcbp) {
if (qcbp->req.error & 3) ida_soft_errors++;
ida_done(cntlr, qcbp, (qcbp->req.error>>2) ? JOB_FAILURE : JOB_SUCCESS);
} else {
printf("ida%d: idaintr: completion (%x) ignored\n", cntlr, paddr1);
}
status = reg->status;
}
#ifdef IDADEBUG
if (ida_debug & IDA_SHOWINTS)
printf("ida%d: idaintr: status=%x (before initiate)\n"
, cntlr, status);
#endif
if (status & IDA_PCI_READY) {
ida_start(cntlr);
}
} else {
while(1) {
status = IDA_READ_EBELL_I(ida) & IDA_READ_EBELL_E(ida);
#ifdef IDADEBUG
if (ida_debug & IDA_SHOWINTS)
printf("ida%d: idaintr: status = 0x%x\n", cntlr, status);
#endif
if ((status & (BMIC_DATA_READY | BMIC_CHAN_CLEAR)) == 0) break;
if (status & BMIC_DATA_READY) { /* data ready */
int job_status;
if (IDA_READ_LBELL_I(ida) & JOB_ABORTED) {
printf("ida%d: idaintr: status:%x local channel should be busy! ",
cntlr, status);
}
paddr = IDA_GET_COM_ADDR(ida);
offset = IDA_GET_COM_OFFSET(ida);
cstat = IDA_GET_COM_STATUS(ida);
/* acknowledge interrupt */
IDA_ACK_CMD_COM(ida);
/* determine which job completed */
qcbp = ida_qcb_phys_kv(ida, paddr);
/* analyse the job status code */
if (cstat & IDA_COMPL_OK) {
job_status = JOB_SUCCESS;
} else {
printf("ida%d: idaintr: return code %x=", cntlr, cstat);
if (cstat & IDA_NON_FATAL) printf("recoverable error! ");
if (cstat & IDA_FATAL) printf("fatal error! ");
if (cstat & IDA_ABORTED) printf("aborted! ");
if (cstat & IDA_INVAL_REQ) printf("invalid request block! ");
if (cstat & IDA_INVAL_LIST) printf("cmd list error! ");
if (cstat & IDA_AARGH_LIST) printf("really bad cmd list! ");
job_status = JOB_FAILURE;
}
#ifdef IDADEBUG
if (ida_debug & IDA_SHOWQCBS) {
printf("ida%d: idaintr: qcb(%x) returned.\n", cntlr, qcbp);
ida_print_qcb(qcbp);
}
#endif
ida_done(cntlr, qcbp, job_status); /* retire the job */
ida_start(cntlr); /* send the controller another job */
}
if (status & BMIC_CHAN_CLEAR) {
/* channel not clear */
IDA_DISABLE_CHAN(ida);
ida_start(cntlr); /* send the controller another job */
}
} /*eisa*/
}
}
int
ida_poll(cntlr, wait)
int cntlr;
int wait; /* delay in milliseconds */
{
struct ida_ctl *ctlp = idadata[cntlr];
if (PCI_CONTROLLER(ctlp)) {
printf("ida%d: error: ida_poll called on a PCI controller\n", cntlr);
return EIO;
}
while (wait-- > 0) {
if (IDA_DATA_READY(ctlp)) {
ctlp->com_addr = IDA_GET_COM_ADDR(ctlp);
ctlp->com_offset = IDA_GET_COM_OFFSET(ctlp);
ctlp->com_status = IDA_GET_COM_STATUS(ctlp);
IDA_ACK_CMD_COM(ctlp);
if (0) printf("ida_poll: addr=0x%08x off=0x%04x cmdstatus=0x%02x\n",
(u_int)ctlp->com_addr,
ctlp->com_offset,
ctlp->com_status);
return 0;
}
DELAY(1000);
}
printf("ida%d: board not responding\n", cntlr);
return EIO;
}
int
ida_submit(int cntlr, qcb_t *qcbp, int size)
{
struct ida_ctl *ida = idadata[cntlr];
int s = splbio();
if (PCI_CONTROLLER(ida)) {
ida_pci_reg_t *reg = (ida_pci_reg_t *)ida->iobase;
u_int fifo = reg->initiate_fifo;
if (fifo == 1) {
splx(s);
#ifdef IDADEBUG
if (ida_debug & IDA_SHOWSUBS)
printf("ida%d: ida_submit(%x): fifo=1 not submitting\n",
cntlr, qcbp, fifo);
#endif
return(1); /* not sent - must try again later */
}
#ifdef IDADEBUG
if (ida_debug & IDA_SHOWSUBS)
printf("ida%d: ida_submit(%x): fifo=%d submitting\n", cntlr, qcbp, fifo);
#endif
reg->initiate_fifo = qcbp->paddr;
} else {
if (!IDA_CHAN_CLEAR(ida)) {
IDA_ENABLE_CHAN(ida);
splx(s);
return(1); /* not sent - must try again later */
}
IDA_SET_EBELL_I(ida, 2);
IDA_SET_SUB_ADDR(ida, qcbp->paddr); /* physical address of this qcb */
IDA_SET_SUB_LEN(ida, size);
IDA_SET_LBELL_I(ida, 1);
}
splx(s);
return(0); /* sent */
}
static
void
ida_empty_pci_complete_fifo(int cntlr, ida_pci_reg_t *reg) {
u_long paddr;
if (paddr = reg->complete_fifo) {
int count = 200;
while (paddr && count > 0) {
printf("ida%d: command completion discarded (0x%x).\n",
cntlr, (u_int)paddr);
if (paddr = reg->complete_fifo) {
DELAY(100);
count--;
}
}
}
return;
}
static
u_long
ida_complete_pci_command(int cntlr, ida_pci_reg_t *reg) {
int count = 1;
u_long paddr;
while (count < 1000000) {
if (reg->status & IDA_PCI_PENDING) {
if ((paddr = reg->complete_fifo) == 0)
printf("ida%d: ida_complete_pci_command: zero address returned.\n",
cntlr);
else
return paddr;
}
DELAY(10);
}
return 1;
}
static
int
ida_submit_wait(int cntlr, qcb_t *qcbp, int size)
{
struct ida_ctl *ida = idadata[cntlr];
if (PCI_CONTROLLER(ida)) {
ida_pci_reg_t *reg = (ida_pci_reg_t *)ida->iobase;
int i, count = 1000000;
u_long paddr;
ida_empty_pci_complete_fifo(cntlr, reg);
reg->interrupt = IDA_PCI_DISABLE_INTS;
while (count > 0 && (i = reg->initiate_fifo) > 16) {
DELAY(10);
count--;
}
if (count == 0) {
printf("ida%d: ida_pci_submit_wait: fifo failed to clear - controller has failed.\n", cntlr);
return 1;
}
reg->initiate_fifo = qcbp->paddr;
paddr = ida_complete_pci_command(cntlr, reg);
if (paddr == 1) {
printf("ida%d: ida_pci_submit_wait timeout. No command list returned.\n",
cntlr);
return 1;
}
if (paddr != qcbp->paddr) {
printf("ida%d: ida_pci_submit_wait error. Invalid command list returned.\n",
cntlr);
return 1;
}
if (qcbp->req.error != 0xfe && qcbp->req.error == 0x40) {
printf("ida%d: ida_pci_submit_wait: Job error.\n", cntlr);
return 1;
}
} else {
if (ida_submit(cntlr, qcbp, size)) {
return 1;
}
if (ida_poll(cntlr, 10)) {
return 1;
}
}
return 0; /* sent */
}
void
ida_done(int cntlr, qcb_t *qcbp, int state)
{
struct buf *bp = qcbp->buf;
if (idadata[cntlr] > 0)
idadata[cntlr]->inside--; /* one less job inside the controller */
if (state != JOB_SUCCESS) {
#ifdef IDADEBUG
if (ida_debug & IDA_SHOWMISC)
printf("ida%d: ida_done: job failed 0x%x\n", cntlr, state);
#endif
/* we had a problem */
bp->b_error = EIO;
bp->b_flags |= B_ERROR;
} else {
struct ida_drv *drv = id_drive[dkunit(bp->b_dev)];
bp->b_resid = 0;
/* Update device stats */
devstat_end_transaction(&drv->dk_stats,
bp->b_bcount - bp->b_resid,
DEVSTAT_TAG_NONE,
(bp->b_flags & B_READ) ? DEVSTAT_READ : DEVSTAT_WRITE);
}
ida_free_qcb(cntlr, qcbp);
biodone(bp);
}
int
idsize(dev_t dev)
{
int unit = dkunit(dev);
struct ida_drv *drv;
if (unit >= NID)
return (-1);
drv = id_drive[unit];
if (!drv || !(drv->flags & ID_INIT))
return (-1);
return (dssize(dev, &drv->slices, idopen, idclose));
}
/*
* dump all of physical memory into the partition specified, starting
* at offset 'dumplo' into the partition.
*/
int
iddump(dev_t dev)
{ /* dump core after a system crash */
return 0; /* XXX */
}
static id_devsw_installed = 0;
static void
id_drvinit(void *unused)
{
if( ! id_devsw_installed ) {
cdevsw_add_generic(ID_BDMAJ,ID_CDMAJ, &id_cdevsw);
id_devsw_installed = 1;
}
}
SYSINIT(iddev,SI_SUB_DRIVERS,SI_ORDER_MIDDLE+ID_CDMAJ,id_drvinit,NULL)
#ifdef IDADEBUG
void
ida_print_qcb(qcb_t *qcbp)
{
int i;
printf("qcb(%x): drive=%x priority=%x flags=%x sgcount=%d\n"
,qcbp
,qcbp->hdr.drive
,qcbp->hdr.priority
,qcbp->hdr.flags
,qcbp->req.sgcount);
printf("qcb(%x): next=%x command=%x error=%x blkno=%x bcount=%x\n"
,qcbp
,qcbp->req.next
,qcbp->req.command
,qcbp->req.error
,qcbp->req.blkno
,qcbp->req.bcount);
for (i=0; i < qcbp->req.sgcount; i++)
printf("qcb(%x): %x len=%x addr=%x\n"
,qcbp
,i
,qcbp->sglist[i].len
,qcbp->sglist[i].addr);
}
void
ida_print_active_qcb(int cntlr)
{
struct ida_ctl *ida = idadata[cntlr];
int i;
for (i=0; i < QCB_HASH_SIZE; i++) {
qcb_t *qcbp = ida->hashlist[i];
while (qcbp) {
if (qcbp->flags != QCB_FREE) {
ida_print_qcb(qcbp);
}
qcbp = qcbp->nexthash;
}
}
}
#endif /*IDADEBUG */
Reference in New Issue View Git Blame Copy Permalink