The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/sparc64/isa/isa.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

    1 /*-
    2  * Copyright (c) 1998 Doug Rabson
    3  * Copyright (c) 2001 Thomas Moestl <tmm@FreeBSD.org>
    4  * All rights reserved.
    5  *
    6  * Redistribution and use in source and binary forms, with or without
    7  * modification, are permitted provided that the following conditions
    8  * are met:
    9  * 1. Redistributions of source code must retain the above copyright
   10  *    notice, this list of conditions and the following disclaimer.
   11  * 2. Redistributions in binary form must reproduce the above copyright
   12  *    notice, this list of conditions and the following disclaimer in the
   13  *    documentation and/or other materials provided with the distribution.
   14  *
   15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
   16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
   19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   25  * SUCH DAMAGE.
   26  *
   27  *      from: FreeBSD: src/sys/alpha/isa/isa.c,v 1.26 2001/07/11
   28  */
   29 
   30 #include <sys/cdefs.h>
   31 __FBSDID("$FreeBSD: releng/6.4/sys/sparc64/isa/isa.c 159779 2006-06-19 20:20:24Z marius $");
   32 
   33 #include <sys/param.h>
   34 #include <sys/systm.h>
   35 #include <sys/bus.h>
   36 
   37 #include <machine/bus.h>
   38 
   39 #include <sys/rman.h>
   40 
   41 #include <isa/isareg.h>
   42 #include <isa/isavar.h>
   43 #include <isa/isa_common.h>
   44 
   45 #include <dev/ofw/ofw_bus.h>
   46 #include <dev/ofw/openfirm.h>
   47 
   48 #include <machine/resource.h>
   49 
   50 #include <dev/pci/pcireg.h>
   51 #include <dev/pci/pcivar.h>
   52 
   53 #include <sparc64/pci/ofw_pci.h>
   54 #include <sparc64/isa/ofw_isa.h>
   55 
   56 /* There can be only one ISA bus, so it is safe to use globals. */
   57 bus_space_tag_t isa_io_bt = NULL;
   58 bus_space_handle_t isa_io_hdl;
   59 bus_space_tag_t isa_mem_bt = NULL;
   60 bus_space_handle_t isa_mem_hdl;
   61 
   62 static u_int64_t isa_io_base;
   63 static u_int64_t isa_io_limit;
   64 static u_int64_t isa_mem_base;
   65 static u_int64_t isa_mem_limit;
   66 
   67 device_t isa_bus_device;
   68 
   69 static phandle_t isab_node;
   70 static struct isa_ranges *isab_ranges;
   71 static int isab_nrange;
   72 static ofw_pci_intr_t isa_ino[8];
   73 static struct ofw_bus_iinfo isa_iinfo;
   74 
   75 /*
   76  * XXX: This is really partly PCI-specific, but unfortunately is
   77  * differently enough to have to duplicate it here...
   78  */
   79 #define ISAB_RANGE_PHYS(r)                                              \
   80         (((u_int64_t)(r)->phys_mid << 32) | (u_int64_t)(r)->phys_lo)
   81 #define ISAB_RANGE_SPACE(r)     (((r)->phys_hi >> 24) & 0x03)
   82 
   83 #define ISAR_SPACE_IO           0x01
   84 #define ISAR_SPACE_MEM          0x02
   85 
   86 #define INRANGE(x, start, end)  ((x) >= (start) && (x) <= (end))
   87 
   88 static void     isa_setup_children(device_t, phandle_t);
   89 
   90 intrmask_t
   91 isa_irq_pending(void)
   92 {
   93         intrmask_t pending;
   94         int i;
   95 
   96         /* XXX: Is this correct? */
   97         for (i = 7, pending = 0; i >= 0; i--) {
   98                 pending <<= 1;
   99                 if (isa_ino[i] != PCI_INVALID_IRQ) {
  100                         pending |= (OFW_PCI_INTR_PENDING(isa_bus_device,
  101                             isa_ino[i]) == 0) ? 0 : 1;
  102                 }
  103         }
  104         return (pending);
  105 }
  106 
  107 void
  108 isa_init(device_t dev)
  109 {
  110         device_t bridge;
  111         int i;
  112 
  113         /* The parent of the bus must be a PCI-ISA bridge. */
  114         bridge = device_get_parent(dev);
  115         isab_node = ofw_bus_get_node(bridge);
  116         isab_nrange = OF_getprop_alloc(isab_node, "ranges",
  117             sizeof(*isab_ranges), (void **)&isab_ranges);
  118         if (isab_nrange <= 0)
  119                 panic("isa_init: cannot get bridge range property");
  120 
  121         ofw_bus_setup_iinfo(isab_node, &isa_iinfo, sizeof(ofw_isa_intr_t));
  122 
  123         /*
  124          * This is really a bad kludge; however, it is needed to provide
  125          * isa_irq_pending(), which is unfortunately still used by some
  126          * drivers.
  127          * XXX: The only driver still using isa_irq_pending() is sio(4)
  128          *      which we don't use on sparc64. Should we just drop support
  129          *      for isa_irq_pending()?
  130          */
  131         for (i = 0; i < 8; i++)
  132                 isa_ino[i] = PCI_INVALID_IRQ;
  133 
  134         isa_setup_children(dev, isab_node);
  135 
  136         for (i = isab_nrange - 1; i >= 0; i--) {
  137                 switch(ISAB_RANGE_SPACE(&isab_ranges[i])) {
  138                 case ISAR_SPACE_IO:
  139                         /* This is probably always 0. */
  140                         isa_io_base = ISAB_RANGE_PHYS(&isab_ranges[i]);
  141                         isa_io_limit = isab_ranges[i].size;
  142                         isa_io_hdl = OFW_PCI_GET_BUS_HANDLE(bridge,
  143                             SYS_RES_IOPORT, isa_io_base, &isa_io_bt);
  144                         break;
  145                 case ISAR_SPACE_MEM:
  146                         /* This is probably always 0. */
  147                         isa_mem_base = ISAB_RANGE_PHYS(&isab_ranges[i]);
  148                         isa_mem_limit = isab_ranges[i].size;
  149                         isa_mem_hdl = OFW_PCI_GET_BUS_HANDLE(bridge,
  150                             SYS_RES_MEMORY, isa_mem_base, &isa_mem_bt);
  151                         break;
  152                 }
  153         }
  154 }
  155 
  156 static const struct {
  157         const char      *name;
  158         uint32_t        id;
  159 } ofw_isa_pnp_map[] = {
  160         { "SUNW,lomh",  0x0000ae4e }, /* SUN0000 */
  161         { "dma",        0x0002d041 }, /* PNP0200 */
  162         { "floppy",     0x0007d041 }, /* PNP0700 */
  163         { "rtc",        0x000bd041 }, /* PNP0B00 */
  164         { "flashprom",  0x0100ae4e }, /* SUN0001 */
  165         { "parallel",   0x0104d041 }, /* PNP0401 */
  166         { "serial",     0x0105d041 }, /* PNP0501 */
  167         { "i2c",        0x0200ae4e }, /* SUN0002 */
  168         { "rmc-comm",   0x0300ae4e }, /* SUN0003 */
  169         { "kb_ps2",     0x0303d041 }, /* PNP0303 */
  170         { "kdmouse",    0x030fd041 }, /* PNP0F03 */
  171         { "power",      0x0c0cd041 }, /* PNP0C0C */
  172         { NULL,         0x0 }
  173 };
  174 
  175 static void
  176 isa_setup_children(device_t dev, phandle_t parent)
  177 {
  178         struct isa_regs *regs;
  179         struct resource_list *rl;
  180         device_t cdev;
  181         u_int64_t end, start;
  182         ofw_isa_intr_t *intrs, rintr;
  183         phandle_t node;
  184         uint32_t *drqs, *regidx;
  185         int i, ndrq, nintr, nreg, nregidx, rid, rtype;
  186         char *name;
  187 
  188         /*
  189          * Loop through children and fake up PnP devices for them.
  190          * Their resources are added as fully mapped and specified because
  191          * adjusting the resources and the resource list entries respectively
  192          * in isa_alloc_resource() causes trouble with drivers which use
  193          * rman_get_start(), pass-through or allocate and release resources
  194          * multiple times, etc. Adjusting the resources might be better off
  195          * in a bus_activate_resource method but the common ISA code doesn't
  196          * allow for an isa_activate_resource().
  197          */
  198         for (node = OF_child(parent); node != 0; node = OF_peer(node)) {
  199                 if ((OF_getprop_alloc(node, "name", 1, (void **)&name)) == -1)
  200                         continue;
  201 
  202                 /*
  203                  * Keyboard and mouse controllers hang off of the `8042'
  204                  * node but we have no real use for the `8042' itself.
  205                  */
  206                 if (strcmp(name, "8042") == 0) {
  207                         isa_setup_children(dev, node);
  208                         free(name, M_OFWPROP);
  209                         continue;
  210                 }
  211 
  212                 for (i = 0; ofw_isa_pnp_map[i].name != NULL; i++)
  213                         if (strcmp(ofw_isa_pnp_map[i].name, name) == 0)
  214                                 break;
  215                 if (ofw_isa_pnp_map[i].name == NULL) {
  216                         printf("isa_setup_children: no PnP map entry for node "
  217                             "0x%lx: %s\n", (unsigned long)node, name);
  218                         free(name, M_OFWPROP);
  219                         continue;
  220                 }
  221 
  222                 if ((cdev = BUS_ADD_CHILD(dev, ISA_ORDER_PNPBIOS, NULL, -1)) ==
  223                     NULL)
  224                         panic("isa_setup_children: BUS_ADD_CHILD failed");
  225                 isa_set_logicalid(cdev, ofw_isa_pnp_map[i].id);
  226                 isa_set_vendorid(cdev, ofw_isa_pnp_map[i].id);
  227 
  228                 rl = BUS_GET_RESOURCE_LIST(dev, cdev);
  229                 nreg = OF_getprop_alloc(node, "reg", sizeof(*regs),
  230                     (void **)&regs);
  231                 for (i = 0; i < nreg; i++) {
  232                         start = ISA_REG_PHYS(&regs[i]);
  233                         end = start + regs[i].size - 1;
  234                         rtype = ofw_isa_range_map(isab_ranges, isab_nrange,
  235                             &start, &end, NULL);
  236                         rid = 0;
  237                         while (resource_list_find(rl, rtype, rid) != NULL)
  238                                 rid++;
  239                         bus_set_resource(cdev, rtype, rid, start,
  240                             end - start + 1);
  241                 }
  242                 if (nreg == -1 && parent != isab_node) {
  243                         /*
  244                          * The "reg" property still might be an index into
  245                          * the set of registers of the parent device like
  246                          * with the nodes hanging off of the `8042' node.
  247                          */
  248                         nregidx = OF_getprop_alloc(node, "reg", sizeof(*regidx),
  249                             (void **)&regidx);
  250                         if (nregidx > 2)
  251                                 panic("isa_setup_children: impossible number "
  252                                     "of register indices");
  253                         if (nregidx != -1 && (nreg = OF_getprop_alloc(parent,
  254                             "reg", sizeof(*regs), (void **)&regs)) >= nregidx) {
  255                                 for (i = 0; i < nregidx; i++) {
  256                                         start = ISA_REG_PHYS(&regs[regidx[i]]);
  257                                         end = start + regs[regidx[i]].size - 1;
  258                                         rtype = ofw_isa_range_map(isab_ranges,
  259                                             isab_nrange, &start, &end, NULL);
  260                                         rid = 0;
  261                                         while (resource_list_find(rl, rtype,
  262                                             rid) != NULL)
  263                                                 rid++;
  264                                         bus_set_resource(cdev, rtype, rid,
  265                                             start, end - start + 1);
  266                                 }
  267                         }
  268                         if (regidx != NULL)
  269                                 free(regidx, M_OFWPROP);
  270                 }
  271                 if (regs != NULL)
  272                         free(regs, M_OFWPROP);
  273 
  274                 nintr = OF_getprop_alloc(node, "interrupts", sizeof(*intrs),
  275                     (void **)&intrs);
  276                 for (i = 0; i < nintr; i++) {
  277                         if (intrs[i] > 7)
  278                                 panic("isa_setup_children: intr too large");
  279                         rintr = ofw_isa_route_intr(device_get_parent(dev), node,
  280                             &isa_iinfo, intrs[i]);
  281                         if (rintr == PCI_INVALID_IRQ)
  282                                 panic("isa_setup_children: could not map ISA "
  283                                     "interrupt %d", intrs[i]);
  284                         isa_ino[intrs[i]] = rintr;
  285                         bus_set_resource(cdev, SYS_RES_IRQ, i, rintr, 1);
  286                 }
  287                 if (intrs != NULL)
  288                         free(intrs, M_OFWPROP);
  289 
  290                 ndrq = OF_getprop_alloc(node, "dma-channel", sizeof(*drqs),
  291                     (void **)&drqs);
  292                 for (i = 0; i < ndrq; i++)
  293                         bus_set_resource(cdev, SYS_RES_DRQ, i, drqs[i], 1);
  294                 if (drqs != NULL)
  295                         free(drqs, M_OFWPROP);
  296 
  297                 /*
  298                  * Devices using DMA hang off of the `dma' node instead of
  299                  * directly from the ISA bridge node.
  300                  */
  301                 if (strcmp(name, "dma") == 0)
  302                         isa_setup_children(dev, node);
  303 
  304                 free(name, M_OFWPROP);
  305         }
  306 }
  307 
  308 struct resource *
  309 isa_alloc_resource(device_t bus, device_t child, int type, int *rid,
  310                    u_long start, u_long end, u_long count, u_int flags)
  311 {
  312         /*
  313          * Consider adding a resource definition.
  314          */
  315         int passthrough = (device_get_parent(child) != bus);
  316         int isdefault = (start == 0UL && end == ~0UL);
  317         struct resource_list *rl;
  318         struct resource_list_entry *rle;
  319         u_long base, limit;
  320 
  321         rl = BUS_GET_RESOURCE_LIST(bus, child);
  322         if (!passthrough && !isdefault) {
  323                 rle = resource_list_find(rl, type, *rid);
  324                 if (!rle) {
  325                         if (*rid < 0)
  326                                 return (NULL);
  327                         switch (type) {
  328                         case SYS_RES_IRQ:
  329                                 if (*rid >= ISA_NIRQ)
  330                                         return (NULL);
  331                                 break;
  332                         case SYS_RES_DRQ:
  333                                 if (*rid >= ISA_NDRQ)
  334                                         return (NULL);
  335                                 break;
  336                         case SYS_RES_MEMORY:
  337                                 if (*rid >= ISA_NMEM)
  338                                         return (NULL);
  339                                 break;
  340                         case SYS_RES_IOPORT:
  341                                 if (*rid >= ISA_NPORT)
  342                                         return (NULL);
  343                                 break;
  344                         default:
  345                                 return (NULL);
  346                         }
  347                         resource_list_add(rl, type, *rid, start, end, count);
  348                 }
  349         }
  350 
  351         /*
  352          * Sanity check if the resource in the respective entry is fully
  353          * mapped and specified and its type allocable. A driver could
  354          * have added an out of range resource on its own.
  355          */
  356         if (!passthrough) {
  357                 if ((rle = resource_list_find(rl, type, *rid)) == NULL)
  358                         return (NULL);
  359                 base = limit = 0;
  360                 switch (type) {
  361                 case SYS_RES_MEMORY:
  362                         if (isa_mem_bt == NULL)
  363                                 return (NULL);
  364                         base = isa_mem_base;
  365                         limit = base + isa_mem_limit;
  366                         break;
  367                 case SYS_RES_IOPORT:
  368                         if (isa_io_bt == NULL)
  369                                 return (NULL);
  370                         base = isa_io_base;
  371                         limit = base + isa_io_limit;
  372                         break;
  373                 case SYS_RES_IRQ:
  374                         if (rle->start != rle->end || rle->start <= 7)
  375                                 return (NULL);
  376                         break;
  377                 case SYS_RES_DRQ:
  378                         break;
  379                 default:
  380                         return (NULL);
  381                 }
  382                 if (type == SYS_RES_MEMORY || type == SYS_RES_IOPORT) {
  383                         if (!INRANGE(rle->start, base, limit) ||
  384                             !INRANGE(rle->end, base, limit))
  385                                 return (NULL);
  386                 }
  387         }
  388 
  389         return (resource_list_alloc(rl, bus, child, type, rid, start, end,
  390             count, flags));
  391 }
  392 
  393 int
  394 isa_release_resource(device_t bus, device_t child, int type, int rid,
  395                      struct resource *res)
  396 {
  397 
  398         return (bus_generic_rl_release_resource(bus, child, type, rid, res));
  399 }
  400 
  401 int
  402 isa_setup_intr(device_t dev, device_t child,
  403                struct resource *irq, int flags,
  404                driver_intr_t *intr, void *arg, void **cookiep)
  405 {
  406 
  407         /*
  408          * Just pass through. This is going to be handled by either
  409          * one of the parent PCI buses or the nexus device.
  410          * The interrupt had been routed before it was added to the
  411          * resource list of the child.
  412          */
  413         return (BUS_SETUP_INTR(device_get_parent(dev), child, irq, flags, intr,
  414             arg, cookiep));
  415 }
  416 
  417 int
  418 isa_teardown_intr(device_t dev, device_t child,
  419                   struct resource *irq, void *cookie)
  420 {
  421 
  422         return (BUS_TEARDOWN_INTR(device_get_parent(dev), child, irq, cookie));
  423 }

Cache object: 135d842132d9b6c821389f9309ed38d8


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.