sys/sparc64/sparc64/jbusppm.c

   1 /*-
   2  * Copyright (c) 2008 Marius Strobl <marius@FreeBSD.org>
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  */
  26
  27 #include <sys/cdefs.h>
  28 __FBSDID("$FreeBSD$");
  29
  30 #include <sys/param.h>
  31 #include <sys/systm.h>
  32 #include <sys/bus.h>
  33 #include <sys/kernel.h>
  34 #include <sys/module.h>
  35 #include <sys/resource.h>
  36 #include <sys/rman.h>
  37
  38 #include <dev/ofw/ofw_bus.h>
  39
  40 #include <machine/bus.h>
  41 #include <machine/resource.h>
  42
  43 #if 1
  44 #include <sparc64/pci/ofw_pci.h>
  45 #endif
  46
  47 #define JBUSPPM_NREG    2
  48
  49 #define JBUSPPM_DEVID   0
  50 #define JBUSPPM_ESTAR   1
  51
  52 #define JBUSPPM_DEVID_JID               0x00
  53 #define JBUSPPM_DEVID_JID_MASTER        0x00040000
  54
  55 #define JBUSPPM_ESTAR_CTRL              0x00
  56 #define JBUSPPM_ESTAR_CTRL_1            0x00000001
  57 #define JBUSPPM_ESTAR_CTRL_2            0x00000002
  58 #define JBUSPPM_ESTAR_CTRL_32           0x00000020
  59 #define JBUSPPM_ESTAR_CTRL_MASK                                         \
  60         (JBUSPPM_ESTAR_CTRL_1 | JBUSPPM_ESTAR_CTRL_2 | JBUSPPM_ESTAR_CTRL_32)
  61 #define JBUSPPM_ESTAR_JCHNG             0x08
  62 #define JBUSPPM_ESTAR_JCHNG_DELAY_MASK  0x00000007
  63 #define JBUSPPM_ESTAR_JCHNG_START       0x00000010
  64 #define JBUSPPM_ESTAR_JCHNG_OCCURED     0x00000018
  65
  66 struct jbusppm_softc {
  67         struct resource         *sc_res[JBUSPPM_NREG];
  68         bus_space_tag_t         sc_bt[JBUSPPM_NREG];
  69         bus_space_handle_t      sc_bh[JBUSPPM_NREG];
  70 };
  71
  72 #define JBUSPPM_READ(sc, reg, off)                                      \
  73         bus_space_read_8((sc)->sc_bt[(reg)], (sc)->sc_bh[(reg)], (off))
  74 #define JBUSPPM_WRITE(sc, reg, off, val)                                \
  75         bus_space_write_8((sc)->sc_bt[(reg)], (sc)->sc_bh[(reg)], (off), (val))
  76
  77 static device_probe_t jbusppm_probe;
  78 static device_attach_t jbusppm_attach;
  79
  80 static device_method_t jbusppm_methods[] = {
  81         /* Device interface */
  82         DEVMETHOD(device_probe,         jbusppm_probe),
  83         DEVMETHOD(device_attach,        jbusppm_attach),
  84
  85         DEVMETHOD_END
  86 };
  87
  88 static devclass_t jbusppm_devclass;
  89
  90 DEFINE_CLASS_0(jbusppm, jbusppm_driver, jbusppm_methods,
  91     sizeof(struct jbusppm_softc));
  92 DRIVER_MODULE(jbusppm, nexus, jbusppm_driver, jbusppm_devclass, 0, 0);
  93
  94 static int
  95 jbusppm_probe(device_t dev)
  96 {
  97         const char* compat;
  98
  99         compat = ofw_bus_get_compat(dev);
 100         if (compat != NULL && strcmp(ofw_bus_get_name(dev), "ppm") == 0 &&
 101             strcmp(compat, "jbus-ppm") == 0) {
 102                 device_set_desc(dev, "JBus power management");
 103                 return (BUS_PROBE_DEFAULT);
 104         }
 105         return (ENXIO);
 106 }
 107
 108 static int
 109 jbusppm_attach(device_t dev)
 110 {
 111         struct jbusppm_softc *sc;
 112         int i, rid;
 113 #if 1
 114         device_t *children, tomatillo;
 115         u_long tcount, tstart, jcount, jstart;
 116         int j, nchildren;
 117 #endif
 118
 119         sc = device_get_softc(dev);
 120         for (i = JBUSPPM_DEVID; i <= JBUSPPM_ESTAR; i++) {
 121                 rid = i;
 122                 /*
 123                  * The JBUSPPM_ESTAR resources is shared with that of the
 124                  * Tomatillo bus A controller configuration register bank.
 125                  */
 126 #if 0
 127                 sc->sc_res[i] = bus_alloc_resource_any(dev, SYS_RES_MEMORY,
 128                     &rid, (i == JBUSPPM_ESTAR ? RF_SHAREABLE : 0) | RF_ACTIVE);
 129                 if (sc->sc_res[i] == NULL) {
 130                         device_printf(dev,
 131                             "could not allocate resource %d\n", i);
 132                         goto fail;
 133                 }
 134                 sc->sc_bt[i] = rman_get_bustag(sc->sc_res[i]);
 135                 sc->sc_bh[i] = rman_get_bushandle(sc->sc_res[i]);
 136 #else
 137                 /*
 138                  * Workaround for the fact that rman(9) only allows to
 139                  * share resources of the same size.
 140                  */
 141                 if (i == JBUSPPM_ESTAR) {
 142                         if (bus_get_resource(dev, SYS_RES_MEMORY, i, &jstart,
 143                             &jcount) != 0) {
 144                                 device_printf(dev,
 145                                     "could not determine Estar resource\n");
 146                                 goto fail;
 147                         }
 148                         if (device_get_children(device_get_parent(dev),
 149                             &children, &nchildren) != 0) {
 150                                 device_printf(dev, "could not get children\n");
 151                                 goto fail;
 152                         }
 153                         tomatillo = NULL;
 154                         for (j = 0; j < nchildren; j++) {
 155                                 if (ofw_bus_get_type(children[j]) != NULL &&
 156                                     strcmp(ofw_bus_get_type(children[j]),
 157                                     OFW_TYPE_PCI) == 0 &&
 158                                     ofw_bus_get_compat(children[j]) != NULL &&
 159                                     strcmp(ofw_bus_get_compat(children[j]),
 160                                     "pci108e,a801") == 0 &&
 161                                     ((bus_get_resource_start(children[j],
 162                                     SYS_RES_MEMORY, 0) >> 20) & 1) == 0) {
 163                                         tomatillo = children[j];
 164                                         break;
 165                                 }
 166                         }
 167                         free(children, M_TEMP);
 168                         if (tomatillo == NULL) {
 169                                 device_printf(dev,
 170                                     "could not find Tomatillo\n");
 171                                 goto fail;
 172                         }
 173                         if (bus_get_resource(tomatillo, SYS_RES_MEMORY, 1,
 174                             &tstart, &tcount) != 0) {
 175                                 device_printf(dev,
 176                                     "could not determine Tomatillo "
 177                                     "resource\n");
 178                                 goto fail;
 179                         }
 180                         sc->sc_res[i] = bus_alloc_resource(dev, SYS_RES_MEMORY,
 181                             &rid, tstart, tstart + tcount - 1, tcount,
 182                             RF_SHAREABLE | RF_ACTIVE);
 183                 } else
 184                         sc->sc_res[i] = bus_alloc_resource_any(dev,
 185                             SYS_RES_MEMORY, &rid, RF_ACTIVE);
 186                 if (sc->sc_res[i] == NULL) {
 187                         device_printf(dev,
 188                             "could not allocate resource %d\n", i);
 189                         goto fail;
 190                 }
 191                 sc->sc_bt[i] = rman_get_bustag(sc->sc_res[i]);
 192                 sc->sc_bh[i] = rman_get_bushandle(sc->sc_res[i]);
 193                 if (i == JBUSPPM_ESTAR)
 194                         bus_space_subregion(sc->sc_bt[i], sc->sc_bh[i],
 195                             jstart - tstart, jcount, &sc->sc_bh[i]);
 196 #endif
 197         }
 198
 199         if (bootverbose) {
 200                 if ((JBUSPPM_READ(sc, JBUSPPM_DEVID, JBUSPPM_DEVID_JID) &
 201                     JBUSPPM_DEVID_JID_MASTER) != 0)
 202                         device_printf(dev, "master I/O bridge\n");
 203                 device_printf(dev, "running at ");
 204                 switch (JBUSPPM_READ(sc, JBUSPPM_ESTAR, JBUSPPM_ESTAR_CTRL) &
 205                     JBUSPPM_ESTAR_CTRL_MASK) {
 206                 case JBUSPPM_ESTAR_CTRL_1:
 207                         printf("full");
 208                         break;
 209                 case JBUSPPM_ESTAR_CTRL_2:
 210                         printf("half");
 211                         break;
 212                 case JBUSPPM_ESTAR_CTRL_32:
 213                         printf("1/32");
 214                         break;
 215                 default:
 216                         printf("unknown");
 217                         break;
 218                 }
 219                 printf(" speed\n");
 220         }
 221
 222         return (0);
 223
 224  fail:
 225         for (i = JBUSPPM_DEVID; i <= JBUSPPM_ESTAR && sc->sc_res[i] != NULL;
 226             i++)
 227                 bus_release_resource(dev, SYS_RES_MEMORY,
 228                     rman_get_rid(sc->sc_res[i]), sc->sc_res[i]);
 229         return (ENXIO);
 230 }