usr/src/sys/tahoevba/vbavar.h

/*
 * Copyright (c) 1988 Regents of the University of California.
 * All rights reserved.
 *
 * Redistribution is only permitted until one year after the first shipment
 * of 4.4BSD by the Regents.  Otherwise, redistribution and use in source and
 * binary forms are permitted provided that: (1) source distributions retain
 * this entire copyright notice and comment, and (2) distributions including
 * binaries display the following acknowledgement:  This product includes
 * software developed by the University of California, Berkeley and its
 * contributors'' in the documentation or other materials provided with the
 * distribution and in all advertising materials mentioning features or use
 * of this software.  Neither the name of the University 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 AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 *
 *      @(#)vbavar.h    7.5 (Berkeley) 6/28/90
 */

/*
 * This file contains definitions related to the kernel structures
 * for dealing with the VERSAbus adapters.
 *
 * Each VERSAbus has a vba_hd structure.
 * Each VERSAbus controller which is not a device has a vba_ctlr structure.
 * Each VERSAbus device has a vba_device structure.
 */

#ifndef LOCORE
/*
 * Per-vba structure.
 */
struct  vba_hd {
        int     vh_lastiv;              /* last interrupt vector assigned */
};

/*
 * Per-controller structure.
 * (E.g. one for each disk and tape controller, and other things
 * which use and release buffered data paths.)
 *
 * If a controller has devices attached, then there are
 * cross-referenced vba_drive structures.
 * This structure is the one which is queued in VERSAbus resource wait,
 * and saves the information about VERSAbus resources which are used.
 * The queue of devices waiting to transfer is also attached here.
 */
struct vba_ctlr {
        struct  vba_driver *um_driver;
        short   um_ctlr;        /* controller index in driver */
        short   um_vbanum;      /* the vba it is on */
        short   um_alive;       /* controller exists */
        int     (**um_intr)();  /* interrupt handler(s) */
        caddr_t um_addr;        /* address of device in i/o space */
        struct  vba_hd *um_hd;
/* the driver saves the prototype command here for use in its go routine */
        int     um_cmd;         /* communication to dgo() */
        int     um_vbinfo;      /* save VERSAbus registers, etc */
        struct  buf um_tab;     /* queue of devices for this controller */
};

/*
 * Per ``device'' structure.
 * (A controller has devices or uses and releases buffered data paths).
 * (Everything else is a ``device''.)
 *
 * If a controller has many drives attached, then there will
 * be several vba_device structures associated with a single vba_ctlr
 * structure.
 *
 * This structure contains all the information necessary to run
 * a VERSAbus device.  It also contains information
 * for slaves of VERSAbus controllers as to which device on the slave
 * this is.  A flags field here can also be given in the system specification
 * and is used to tell which tty lines are hard wired or other device
 * specific parameters.
 */
struct vba_device {
        struct  vba_driver *ui_driver;
        short   ui_unit;        /* unit number on the system */
        short   ui_ctlr;        /* mass ctlr number; -1 if none */
        short   ui_vbanum;      /* the vba it is on */
        short   ui_slave;       /* slave on controller */
        int     (**ui_intr)();  /* interrupt handler(s) */
        caddr_t ui_addr;        /* address of device in i/o space */
        short   ui_dk;          /* if init 1 set to number for iostat */
        long    ui_flags;       /* parameter from system specification */
        short   ui_alive;       /* device exists */
        short   ui_type;        /* driver specific type information */
        caddr_t ui_physaddr;    /* phys addr, for standalone (dump) code */
/* this is the forward link in a list of devices on a controller */
        struct  vba_device *ui_forw;
/* if the device is connected to a controller, this is the controller */
        struct  vba_ctlr *ui_mi;
        struct  vba_hd *ui_hd;
};
#endif

/*
 * Per-driver structure.
 *
 * Each VERSAbus driver defines entries for a set of routines
 * as well as an array of types which are acceptable to it.
 * These are used at boot time by the configuration program.
 */
struct vba_driver {
        int     (*ud_probe)();          /* see if a driver is really there */
        int     (*ud_slave)();          /* see if a slave is there */
        int     (*ud_attach)();         /* setup driver for a slave */
        int     (*ud_dgo)();            /* fill csr/ba to start transfer */
        long    *ud_addr;               /* device csr addresses */
        char    *ud_dname;              /* name of a device */
        struct  vba_device **ud_dinfo;  /* backpointers to vbdinit structs */
        char    *ud_mname;              /* name of a controller */
        struct  vba_ctlr **ud_minfo;    /* backpointers to vbminit structs */
};

/*
 * Common state for Versabus driver I/O resources,
 * including memory for intermediate buffer and page map,
 * allocated by vbainit.
 */
struct vb_buf {
        /* these fields set up once by vbainit */
        int     vb_flags;               /* device parameters */
        struct  pte *vb_map;            /* private page entries */
        caddr_t vb_utl;                 /* virtual addresses mapped by vb_map */
        caddr_t vb_rawbuf;              /* intermediate buffer */
        u_long  vb_physbuf;             /* phys addr of intermediate buffer */
        u_long  vb_bufsize;             /* intermediate buffer size */
        u_long  vb_maxphys;             /* physical address limit */
        /* remaining fields apply to current transfer: */
        int     vb_copy;                /* copy to/from intermediate buffer */
        int     vb_iskernel;            /* is to/from kernel address space */
};

/*
 * flags to vbainit
 */
#define VB_32BIT        0x00            /* device uses 32-bit addressing */
#define VB_24BIT        0x01            /* device uses 24-bit addressing */
#define VB_20BIT        0x02            /* device uses 20-bit addressing */
#define VB_SCATTER      0x04            /* device does scatter-gather */

/*
 * hardware memory-addressing limits: highest physical address
 * that each address length can use for main memory access.
 */
#define VB_MAXADDR20    0x000fffff      /* highest addr for 20-bit */
#define VB_MAXADDR24    0x00efffff      /* highest addr for 23/24-bit */
#define VB_MAXADDR32    0x3effffff      /* highest addr for 32-bit */

/*
 * Statistics on vba operations.
 */
struct vbastat {
        u_long  k_raw;          /* to/from contiguous kernel DMA buffer */
        u_long  u_raw;          /* to/from contiguous user DMA buffer */
        u_long  k_copy;         /* copied to/from kernel */
        u_long  u_copy;         /* copied to/from user */
        u_long  k_sg;           /* scatter-gather to/from kernel */
        u_long  u_sg;           /* scatter-gather to/from user */
};

#ifndef LOCORE
#ifdef KERNEL
/*
 * VBA related kernel variables
 */
int     numvba;                                 /* number of uba's */
struct  vba_hd vba_hd[];
struct  vbastat vbastat;

/*
 * Vbminit and vbdinit initialize the mass storage controller and
 * device tables specifying possible devices.
 */
extern  struct  vba_ctlr vbminit[];
extern  struct  vba_device vbdinit[];

/*
 * VERSAbus device address space is mapped by VMEMmap
 * into virtual address vmem[].
 */
extern  struct pte VMEMmap[];   /* vba device addr pte's */
extern  char vmem[];            /* vba device addr space */
u_long  vbasetup();
#endif KERNEL
#endif !LOCORE