Return to tsp_pci.c CVS log

Up to [local] / sys / arch / alpha / pci

Annotation of sys/arch/alpha/pci/tsp_pci.c, Revision 1.1.1.1

1.1       nbrk        1: /* $OpenBSD: tsp_pci.c,v 1.3 2002/03/14 01:26:27 millert Exp $ */
                      2: /* $NetBSD: tsp_pci.c,v 1.1 1999/06/29 06:46:47 ross Exp $ */
                      3:
                      4: /*-
                      5:  * Copyright (c) 1999 by Ross Harvey.  All rights reserved.
                      6:  *
                      7:  * Redistribution and use in source and binary forms, with or without
                      8:  * modification, are permitted provided that the following conditions
                      9:  * are met:
                     10:  * 1. Redistributions of source code must retain the above copyright
                     11:  *    notice, this list of conditions and the following disclaimer.
                     12:  * 2. Redistributions in binary form must reproduce the above copyright
                     13:  *    notice, this list of conditions and the following disclaimer in the
                     14:  *    documentation and/or other materials provided with the distribution.
                     15:  * 3. All advertising materials mentioning features or use of this software
                     16:  *    must display the following acknowledgement:
                     17:  *     This product includes software developed by Ross Harvey.
                     18:  * 4. The name of Ross Harvey may not be used to endorse or promote products
                     19:  *    derived from this software without specific prior written permission.
                     20:  *
                     21:  * THIS SOFTWARE IS PROVIDED BY ROSS HARVEY ``AS IS'' AND ANY EXPRESS
                     22:  * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
                     23:  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURP0SE
                     24:  * ARE DISCLAIMED.  IN NO EVENT SHALL ROSS HARVEY BE LIABLE FOR ANY
                     25:  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
                     26:  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
                     27:  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
                     28:  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
                     29:  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
                     30:  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
                     31:  * SUCH DAMAGE.
                     32:  *
                     33:  */
                     34:
                     35: #include <sys/param.h>
                     36: #include <sys/systm.h>
                     37: #include <sys/kernel.h>
                     38: #include <sys/device.h>
                     39:
                     40: #include <uvm/uvm_extern.h>
                     41:
                     42: #include <dev/pci/pcireg.h>
                     43: #include <dev/pci/pcivar.h>
                     44:
                     45: #include <machine/autoconf.h>
                     46: #include <machine/rpb.h>
                     47:
                     48: #include <alpha/pci/tsreg.h>
                     49: #include <alpha/pci/tsvar.h>
                     50:
                     51: #define tsp_pci() { Generate ctags(1) key. }
                     52:
                     53: void           tsp_attach_hook(struct device *, struct device *,
                     54:                    struct pcibus_attach_args *);
                     55: int            tsp_bus_maxdevs(void *, int);
                     56: pcitag_t       tsp_make_tag(void *, int, int, int);
                     57: void           tsp_decompose_tag(void *, pcitag_t, int *, int *,
                     58:                    int *);
                     59: pcireg_t       tsp_conf_read(void *, pcitag_t, int);
                     60: void           tsp_conf_write(void *, pcitag_t, int, pcireg_t);
                     61:
                     62: void
                     63: tsp_pci_init(pc, v)
                     64:        pci_chipset_tag_t pc;
                     65:        void *v;
                     66: {
                     67:        pc->pc_conf_v = v;
                     68:        pc->pc_attach_hook = tsp_attach_hook;
                     69:        pc->pc_bus_maxdevs = tsp_bus_maxdevs;
                     70:        pc->pc_make_tag = tsp_make_tag;
                     71:        pc->pc_decompose_tag = tsp_decompose_tag;
                     72:        pc->pc_conf_read = tsp_conf_read;
                     73:        pc->pc_conf_write = tsp_conf_write;
                     74: }
                     75:
                     76: void
                     77: tsp_attach_hook(parent, self, pba)
                     78:        struct device *parent, *self;
                     79:        struct pcibus_attach_args *pba;
                     80: {
                     81: }
                     82:
                     83: int
                     84: tsp_bus_maxdevs(cpv, busno)
                     85:        void *cpv;
                     86:        int busno;
                     87: {
                     88:        return 32;
                     89: }
                     90:
                     91: pcitag_t
                     92: tsp_make_tag(cpv, b, d, f)
                     93:        void *cpv;
                     94:        int b, d, f;
                     95: {
                     96:        return b << 16 | d << 11 | f << 8;
                     97: }
                     98:
                     99: void
                    100: tsp_decompose_tag(cpv, tag, bp, dp, fp)
                    101:        void *cpv;
                    102:        pcitag_t tag;
                    103:        int *bp, *dp, *fp;
                    104: {
                    105:        if (bp != NULL)
                    106:                *bp = (tag >> 16) & 0xff;
                    107:        if (dp != NULL)
                    108:                *dp = (tag >> 11) & 0x1f;
                    109:        if (fp != NULL)
                    110:                *fp = (tag >> 8) & 0x7;
                    111: }
                    112: /*
                    113:  * Tsunami makes this a lot easier than it used to be, automatically
                    114:  * generating type 0 or type 1 cycles, and quietly returning -1 with
                    115:  * no errors on unanswered probes.
                    116:  */
                    117: pcireg_t
                    118: tsp_conf_read(cpv, tag, offset)
                    119:        void *cpv;
                    120:        pcitag_t tag;
                    121:        int offset;
                    122: {
                    123:        pcireg_t *datap, data;
                    124:        struct tsp_config *pcp = cpv;
                    125:
                    126:        datap = S_PAGE(pcp->pc_iobase | P_PCI_CONFIG | tag | (offset & ~3));
                    127:        alpha_mb();
                    128:        data = *datap;
                    129:        alpha_mb();
                    130:        return data;
                    131: }
                    132:
                    133: void
                    134: tsp_conf_write(cpv, tag, offset, data)
                    135:        void *cpv;
                    136:        pcitag_t tag;
                    137:        int offset;
                    138:        pcireg_t data;
                    139: {
                    140:        pcireg_t *datap;
                    141:        struct tsp_config *pcp = cpv;
                    142:
                    143:        datap = S_PAGE(pcp->pc_iobase | P_PCI_CONFIG | tag | (offset & ~3));
                    144:        alpha_mb();
                    145:        *datap = data;
                    146:        alpha_mb();
                    147: }