sys/dev/pci/agp_ali.c

   1 /*      $NetBSD: agp_ali.c,v 1.14 2008/04/13 13:07:31 njoly Exp $       */
   2
   3 /*-
   4  * Copyright (c) 2000 Doug Rabson
   5  * 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  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  *
  28  *      $FreeBSD: src/sys/pci/agp_ali.c,v 1.3 2001/07/05 21:28:46 jhb Exp $
  29  */
  30
  31 #include <sys/cdefs.h>
  32 __KERNEL_RCSID(0, "$NetBSD: agp_ali.c,v 1.14 2008/04/13 13:07:31 njoly Exp $");
  33
  34 #include <sys/param.h>
  35 #include <sys/kernel.h>
  36 #include <sys/malloc.h>
  37 #include <sys/systm.h>
  38 #include <sys/proc.h>
  39 #include <sys/conf.h>
  40 #include <sys/device.h>
  41 #include <sys/agpio.h>
  42
  43 #include <uvm/uvm_extern.h>
  44
  45 #include <dev/pci/pcivar.h>
  46 #include <dev/pci/pcireg.h>
  47 #include <dev/pci/agpvar.h>
  48 #include <dev/pci/agpreg.h>
  49
  50 #include <sys/bus.h>
  51
  52 struct agp_ali_softc {
  53         u_int32_t       initial_aperture; /* aperture size at startup */
  54         struct agp_gatt *gatt;
  55 };
  56
  57 static u_int32_t agp_ali_get_aperture(struct agp_softc *);
  58 static int agp_ali_set_aperture(struct agp_softc *sc, u_int32_t);
  59 static int agp_ali_bind_page(struct agp_softc *, off_t, bus_addr_t);
  60 static int agp_ali_unbind_page(struct agp_softc *, off_t);
  61 static void agp_ali_flush_tlb(struct agp_softc *);
  62
  63
  64 static struct agp_methods agp_ali_methods = {
  65         agp_ali_get_aperture,
  66         agp_ali_set_aperture,
  67         agp_ali_bind_page,
  68         agp_ali_unbind_page,
  69         agp_ali_flush_tlb,
  70         agp_generic_enable,
  71         agp_generic_alloc_memory,
  72         agp_generic_free_memory,
  73         agp_generic_bind_memory,
  74         agp_generic_unbind_memory,
  75 };
  76
  77 int
  78 agp_ali_attach(device_t parent, device_t self, void *aux)
  79 {
  80         struct agp_softc *sc = device_private(self);
  81         struct agp_ali_softc *asc;
  82         struct pci_attach_args *pa = aux;
  83         struct agp_gatt *gatt;
  84         pcireg_t reg;
  85
  86         asc = malloc(sizeof *asc, M_AGP, M_NOWAIT);
  87         if (asc == NULL) {
  88                 aprint_error(": failed to allocate softc\n");
  89                 return ENOMEM;
  90         }
  91         sc->as_chipc = asc;
  92         sc->as_methods = &agp_ali_methods;
  93
  94         if (agp_map_aperture(pa, sc, AGP_APBASE) != 0) {
  95                 aprint_error(": failed to map aperture\n");
  96                 free(asc, M_AGP);
  97                 return ENXIO;
  98         }
  99
 100         pci_get_capability(pa->pa_pc, pa->pa_tag, PCI_CAP_AGP, &sc->as_capoff,
 101             NULL);
 102
 103         asc->initial_aperture = agp_ali_get_aperture(sc);
 104
 105         for (;;) {
 106                 gatt = agp_alloc_gatt(sc);
 107                 if (gatt != NULL)
 108                         break;
 109
 110                 /*
 111                  * Probably contigmalloc failure. Try reducing the
 112                  * aperture so that the gatt size reduces.
 113                  */
 114                 if (AGP_SET_APERTURE(sc, AGP_GET_APERTURE(sc) / 2)) {
 115                         agp_generic_detach(sc);
 116                         aprint_error(": failed to set aperture\n");
 117                         return ENOMEM;
 118                 }
 119         }
 120         asc->gatt = gatt;
 121
 122         /* Install the gatt. */
 123         reg = pci_conf_read(pa->pa_pc, pa->pa_tag, AGP_ALI_ATTBASE);
 124         reg = (reg & 0xfff) | (gatt->ag_physical & ~0xfff);
 125         pci_conf_write(pa->pa_pc, pa->pa_tag, AGP_ALI_ATTBASE, reg);
 126
 127         /* Enable the TLB. */
 128         reg = pci_conf_read(pa->pa_pc, pa->pa_tag, AGP_ALI_TLBCTRL);
 129         reg = (reg & ~0xff) | 0x10;
 130         pci_conf_write(pa->pa_pc, pa->pa_tag, AGP_ALI_TLBCTRL, reg);
 131
 132         return 0;
 133 }
 134
 135 #if 0
 136 static int
 137 agp_ali_detach(struct agp_softc *sc)
 138 {
 139         int error;
 140         pcireg_t reg;
 141         struct agp_ali_softc *asc = sc->as_chipc;
 142
 143         error = agp_generic_detach(sc);
 144         if (error)
 145                 return error;
 146
 147         /* Disable the TLB.. */
 148         reg = pci_conf_read(sc->as_pc, sc->as_tag, AGP_ALI_TLBCTRL);
 149         reg &= ~0xff;
 150         reg |= 0x90;
 151         pci_conf_write(sc->as_pc, sc->as_tag, AGP_ALI_TLBCTRL, reg);
 152
 153         /* Put the aperture back the way it started. */
 154         AGP_SET_APERTURE(sc, asc->initial_aperture);
 155         reg = pci_conf_read(sc->as_pc, sc->as_tag, AGP_ALI_ATTBASE);
 156         reg &= 0xf;
 157         pci_conf_write(sc->as_pc, sc->as_tag, AGP_ALI_ATTBASE, reg);
 158
 159         agp_free_gatt(sc, asc->gatt);
 160         return 0;
 161 }
 162 #endif
 163
 164 #define M 1024*1024
 165
 166 static const u_int32_t agp_ali_table[] = {
 167         0,                      /* 0 - invalid */
 168         1,                      /* 1 - invalid */
 169         2,                      /* 2 - invalid */
 170         4*M,                    /* 3 */
 171         8*M,                    /* 4 */
 172         0,                      /* 5 - Reserved */
 173         16*M,                   /* 6 */
 174         32*M,                   /* 7 */
 175         64*M,                   /* 8 */
 176         128*M,                  /* 9 */
 177         256*M,                  /* 10 */
 178 };
 179 #define agp_ali_table_size (sizeof(agp_ali_table) / sizeof(agp_ali_table[0]))
 180
 181 static u_int32_t
 182 agp_ali_get_aperture(struct agp_softc *sc)
 183 {
 184         int i;
 185
 186         /*
 187          * The aperture size is derived from the low bits of attbase.
 188          * I'm not sure this is correct..
 189          */
 190         i = (int)pci_conf_read(sc->as_pc, sc->as_tag, AGP_ALI_ATTBASE) & 0xf;
 191         if (i >= agp_ali_table_size)
 192                 return 0;
 193         return agp_ali_table[i];
 194 }
 195
 196 static int
 197 agp_ali_set_aperture(struct agp_softc *sc, u_int32_t aperture)
 198 {
 199         int i;
 200         pcireg_t reg;
 201
 202         if (aperture & (aperture - 1) || aperture < 1*M)
 203                 return EINVAL;
 204
 205         for (i = 0; i < agp_ali_table_size; i++)
 206                 if (agp_ali_table[i] == aperture)
 207                         break;
 208         if (i == agp_ali_table_size)
 209                 return EINVAL;
 210
 211         reg = pci_conf_read(sc->as_pc, sc->as_tag, AGP_ALI_ATTBASE);
 212         reg &= ~0xf;
 213         reg |= i;
 214         pci_conf_write(sc->as_pc, sc->as_tag, AGP_ALI_ATTBASE, reg);
 215         return 0;
 216 }
 217
 218 static int
 219 agp_ali_bind_page(struct agp_softc *sc, off_t offset, bus_addr_t physical)
 220 {
 221         struct agp_ali_softc *asc = sc->as_chipc;
 222
 223         if (offset < 0 || offset >= (asc->gatt->ag_entries << AGP_PAGE_SHIFT))
 224                 return EINVAL;
 225
 226         asc->gatt->ag_virtual[offset >> AGP_PAGE_SHIFT] = physical;
 227         return 0;
 228 }
 229
 230 static int
 231 agp_ali_unbind_page(struct agp_softc *sc, off_t offset)
 232 {
 233         struct agp_ali_softc *asc = sc->as_chipc;
 234
 235         if (offset < 0 || offset >= (asc->gatt->ag_entries << AGP_PAGE_SHIFT))
 236                 return EINVAL;
 237
 238         asc->gatt->ag_virtual[offset >> AGP_PAGE_SHIFT] = 0;
 239         return 0;
 240 }
 241
 242 static void
 243 agp_ali_flush_tlb(struct agp_softc *sc)
 244 {
 245         pcireg_t reg;
 246
 247         reg = pci_conf_read(sc->as_pc, sc->as_tag, AGP_ALI_TLBCTRL);
 248         reg &= ~0xff;
 249         reg |= 0x90;
 250         pci_conf_write(sc->as_pc, sc->as_tag, AGP_ALI_TLBCTRL, reg);
 251         reg &= ~0xff;
 252         reg |= 0x10;
 253         pci_conf_write(sc->as_pc, sc->as_tag, AGP_ALI_TLBCTRL, reg);
 254 }