17c478bd9Sstevel@tonic-gate /*
27c478bd9Sstevel@tonic-gate * CDDL HEADER START
37c478bd9Sstevel@tonic-gate *
47c478bd9Sstevel@tonic-gate * The contents of this file are subject to the terms of the
5ae115bc7Smrj * Common Development and Distribution License (the "License").
6ae115bc7Smrj * You may not use this file except in compliance with the License.
77c478bd9Sstevel@tonic-gate *
87c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
97c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing.
107c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions
117c478bd9Sstevel@tonic-gate * and limitations under the License.
127c478bd9Sstevel@tonic-gate *
137c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each
147c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
157c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the
167c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying
177c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner]
187c478bd9Sstevel@tonic-gate *
197c478bd9Sstevel@tonic-gate * CDDL HEADER END
207c478bd9Sstevel@tonic-gate */
217c478bd9Sstevel@tonic-gate /*
2226947304SEvan Yan * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
237c478bd9Sstevel@tonic-gate * Use is subject to license terms.
24b97d6ca7SMilan Jurik * Copyright 2012 Milan Jurik. All rights reserved.
2548bbca81SDaniel Hoffman * Copyright (c) 2016 by Delphix. All rights reserved.
26*3fe80ca4SDan Cross * Copyright 2023 Oxide Computer Company
277c478bd9Sstevel@tonic-gate */
287c478bd9Sstevel@tonic-gate
297c478bd9Sstevel@tonic-gate #if defined(DEBUG)
307c478bd9Sstevel@tonic-gate #define BUSRA_DEBUG
317c478bd9Sstevel@tonic-gate #endif
327c478bd9Sstevel@tonic-gate
337c478bd9Sstevel@tonic-gate /*
347c478bd9Sstevel@tonic-gate * This module provides a set of resource management interfaces
357c478bd9Sstevel@tonic-gate * to manage bus resources globally in the system.
367c478bd9Sstevel@tonic-gate *
377c478bd9Sstevel@tonic-gate * The bus nexus drivers are typically responsible to setup resource
387c478bd9Sstevel@tonic-gate * maps for the bus resources available for a bus instance. However
397c478bd9Sstevel@tonic-gate * this module also provides resource setup functions for PCI bus
407c478bd9Sstevel@tonic-gate * (used by both SPARC and X86 platforms) and ISA bus instances (used
417c478bd9Sstevel@tonic-gate * only for X86 platforms).
427c478bd9Sstevel@tonic-gate */
437c478bd9Sstevel@tonic-gate
447c478bd9Sstevel@tonic-gate #include <sys/types.h>
457c478bd9Sstevel@tonic-gate #include <sys/systm.h>
467c478bd9Sstevel@tonic-gate #include <sys/ddi.h>
477c478bd9Sstevel@tonic-gate #include <sys/sunddi.h>
487c478bd9Sstevel@tonic-gate #include <sys/sunndi.h>
497c478bd9Sstevel@tonic-gate #include <sys/ddi_impldefs.h>
507c478bd9Sstevel@tonic-gate #include <sys/ndi_impldefs.h>
517c478bd9Sstevel@tonic-gate #include <sys/kmem.h>
527c478bd9Sstevel@tonic-gate #include <sys/pctypes.h>
537c478bd9Sstevel@tonic-gate #include <sys/modctl.h>
547c478bd9Sstevel@tonic-gate #include <sys/debug.h>
557c478bd9Sstevel@tonic-gate #include <sys/spl.h>
567c478bd9Sstevel@tonic-gate #include <sys/pci.h>
577c478bd9Sstevel@tonic-gate #include <sys/autoconf.h>
587c478bd9Sstevel@tonic-gate
597c478bd9Sstevel@tonic-gate #if defined(BUSRA_DEBUG)
607c478bd9Sstevel@tonic-gate int busra_debug = 0;
617c478bd9Sstevel@tonic-gate #define DEBUGPRT \
627c478bd9Sstevel@tonic-gate if (busra_debug) cmn_err
637c478bd9Sstevel@tonic-gate
647c478bd9Sstevel@tonic-gate #else
657c478bd9Sstevel@tonic-gate #define DEBUGPRT \
667c478bd9Sstevel@tonic-gate if (0) cmn_err
677c478bd9Sstevel@tonic-gate #endif
687c478bd9Sstevel@tonic-gate
697c478bd9Sstevel@tonic-gate
707c478bd9Sstevel@tonic-gate /*
717c478bd9Sstevel@tonic-gate * global mutex that protects the global list of resource maps.
727c478bd9Sstevel@tonic-gate */
737c478bd9Sstevel@tonic-gate kmutex_t ra_lock;
747c478bd9Sstevel@tonic-gate
757c478bd9Sstevel@tonic-gate /*
767c478bd9Sstevel@tonic-gate * basic resource element
777c478bd9Sstevel@tonic-gate */
787c478bd9Sstevel@tonic-gate struct ra_resource {
797c478bd9Sstevel@tonic-gate struct ra_resource *ra_next;
807c478bd9Sstevel@tonic-gate uint64_t ra_base;
8186ef0a63SRichard Lowe uint64_t ra_len;
827c478bd9Sstevel@tonic-gate };
837c478bd9Sstevel@tonic-gate
847c478bd9Sstevel@tonic-gate /*
857c478bd9Sstevel@tonic-gate * link list element for the list of dips (and their resource ranges)
867c478bd9Sstevel@tonic-gate * for a particular resource type.
877c478bd9Sstevel@tonic-gate * ra_rangeset points to the list of resources available
887c478bd9Sstevel@tonic-gate * for this type and this dip.
897c478bd9Sstevel@tonic-gate */
907c478bd9Sstevel@tonic-gate struct ra_dip_type {
917c478bd9Sstevel@tonic-gate struct ra_dip_type *ra_next;
927c478bd9Sstevel@tonic-gate struct ra_resource *ra_rangeset;
937c478bd9Sstevel@tonic-gate dev_info_t *ra_dip;
947c478bd9Sstevel@tonic-gate };
957c478bd9Sstevel@tonic-gate
967c478bd9Sstevel@tonic-gate
977c478bd9Sstevel@tonic-gate /*
987c478bd9Sstevel@tonic-gate * link list element for list of types resources. Each element
997c478bd9Sstevel@tonic-gate * has all resources for a particular type.
1007c478bd9Sstevel@tonic-gate */
1017c478bd9Sstevel@tonic-gate struct ra_type_map {
1027c478bd9Sstevel@tonic-gate struct ra_type_map *ra_next;
1037c478bd9Sstevel@tonic-gate struct ra_dip_type *ra_dip_list;
1047c478bd9Sstevel@tonic-gate char *type;
1057c478bd9Sstevel@tonic-gate };
1067c478bd9Sstevel@tonic-gate
1077c478bd9Sstevel@tonic-gate
1087c478bd9Sstevel@tonic-gate /*
1097c478bd9Sstevel@tonic-gate * place holder to keep the head of the whole global list.
1107c478bd9Sstevel@tonic-gate * the address of the first typemap would be stored in it.
1117c478bd9Sstevel@tonic-gate */
1127c478bd9Sstevel@tonic-gate static struct ra_type_map *ra_map_list_head = NULL;
1137c478bd9Sstevel@tonic-gate
1147c478bd9Sstevel@tonic-gate
1157c478bd9Sstevel@tonic-gate /*
1167c478bd9Sstevel@tonic-gate * This is the loadable module wrapper.
1177c478bd9Sstevel@tonic-gate * It is essentially boilerplate so isn't documented
1187c478bd9Sstevel@tonic-gate */
1197c478bd9Sstevel@tonic-gate extern struct mod_ops mod_miscops;
1207c478bd9Sstevel@tonic-gate
1217c478bd9Sstevel@tonic-gate #ifdef BUSRA_DEBUG
122b97d6ca7SMilan Jurik void ra_dump_all(char *, dev_info_t *);
1237c478bd9Sstevel@tonic-gate #endif
1247c478bd9Sstevel@tonic-gate
1257c478bd9Sstevel@tonic-gate /* internal function prototypes */
1267c478bd9Sstevel@tonic-gate static struct ra_dip_type *find_dip_map_resources(dev_info_t *dip, char *type,
1277c478bd9Sstevel@tonic-gate struct ra_dip_type ***backdip, struct ra_type_map ***backtype,
1287c478bd9Sstevel@tonic-gate uint32_t flag);
1297c478bd9Sstevel@tonic-gate static int isnot_pow2(uint64_t value);
1307c478bd9Sstevel@tonic-gate static int claim_pci_busnum(dev_info_t *dip, void *arg);
1317c478bd9Sstevel@tonic-gate static int ra_map_exist(dev_info_t *dip, char *type);
1327c478bd9Sstevel@tonic-gate
13326947304SEvan Yan static int pci_get_available_prop(dev_info_t *dip, uint64_t base,
13426947304SEvan Yan uint64_t len, char *busra_type);
13526947304SEvan Yan static int pci_put_available_prop(dev_info_t *dip, uint64_t base,
13626947304SEvan Yan uint64_t len, char *busra_type);
13726947304SEvan Yan static uint32_t pci_type_ra2pci(char *type);
13826947304SEvan Yan static boolean_t is_pcie_fabric(dev_info_t *dip);
13926947304SEvan Yan
14026947304SEvan Yan #define PCI_ADDR_TYPE_MASK (PCI_REG_ADDR_M | PCI_REG_PF_M)
14126947304SEvan Yan #define PCI_ADDR_TYPE_INVAL 0xffffffff
1427c478bd9Sstevel@tonic-gate
1437c478bd9Sstevel@tonic-gate #define RA_INSERT(prev, el) \
1447c478bd9Sstevel@tonic-gate el->ra_next = *prev; \
1457c478bd9Sstevel@tonic-gate *prev = el;
1467c478bd9Sstevel@tonic-gate
1477c478bd9Sstevel@tonic-gate #define RA_REMOVE(prev, el) \
1487c478bd9Sstevel@tonic-gate *prev = el->ra_next;
1497c478bd9Sstevel@tonic-gate
1507c478bd9Sstevel@tonic-gate
1517c478bd9Sstevel@tonic-gate static struct modlmisc modlmisc = {
1527c478bd9Sstevel@tonic-gate &mod_miscops, /* Type of module. This one is a module */
15339b361b2SRichard Bean "Bus Resource Allocator (BUSRA)", /* Name of the module. */
1547c478bd9Sstevel@tonic-gate };
1557c478bd9Sstevel@tonic-gate
1567c478bd9Sstevel@tonic-gate static struct modlinkage modlinkage = {
1577c478bd9Sstevel@tonic-gate MODREV_1, (void *)&modlmisc, NULL
1587c478bd9Sstevel@tonic-gate };
1597c478bd9Sstevel@tonic-gate
1607c478bd9Sstevel@tonic-gate int
_init()1617c478bd9Sstevel@tonic-gate _init()
1627c478bd9Sstevel@tonic-gate {
1637c478bd9Sstevel@tonic-gate int ret;
1647c478bd9Sstevel@tonic-gate
1657c478bd9Sstevel@tonic-gate mutex_init(&ra_lock, NULL, MUTEX_DRIVER,
16626947304SEvan Yan (void *)(intptr_t)__ipltospl(SPL7 - 1));
1677c478bd9Sstevel@tonic-gate if ((ret = mod_install(&modlinkage)) != 0) {
1687c478bd9Sstevel@tonic-gate mutex_destroy(&ra_lock);
1697c478bd9Sstevel@tonic-gate }
1707c478bd9Sstevel@tonic-gate return (ret);
1717c478bd9Sstevel@tonic-gate }
1727c478bd9Sstevel@tonic-gate
1737c478bd9Sstevel@tonic-gate int
_fini()1747c478bd9Sstevel@tonic-gate _fini()
1757c478bd9Sstevel@tonic-gate {
1767c478bd9Sstevel@tonic-gate int ret;
1777c478bd9Sstevel@tonic-gate
1787c478bd9Sstevel@tonic-gate mutex_enter(&ra_lock);
1797c478bd9Sstevel@tonic-gate
1807c478bd9Sstevel@tonic-gate if (ra_map_list_head != NULL) {
1817c478bd9Sstevel@tonic-gate mutex_exit(&ra_lock);
1827c478bd9Sstevel@tonic-gate return (EBUSY);
1837c478bd9Sstevel@tonic-gate }
1847c478bd9Sstevel@tonic-gate
1857c478bd9Sstevel@tonic-gate ret = mod_remove(&modlinkage);
1867c478bd9Sstevel@tonic-gate
1877c478bd9Sstevel@tonic-gate mutex_exit(&ra_lock);
1887c478bd9Sstevel@tonic-gate
1897c478bd9Sstevel@tonic-gate if (ret == 0)
1907c478bd9Sstevel@tonic-gate mutex_destroy(&ra_lock);
1917c478bd9Sstevel@tonic-gate
1927c478bd9Sstevel@tonic-gate return (ret);
1937c478bd9Sstevel@tonic-gate }
1947c478bd9Sstevel@tonic-gate
1957c478bd9Sstevel@tonic-gate int
_info(struct modinfo * modinfop)1967c478bd9Sstevel@tonic-gate _info(struct modinfo *modinfop)
1977c478bd9Sstevel@tonic-gate {
1987c478bd9Sstevel@tonic-gate return (mod_info(&modlinkage, modinfop));
1997c478bd9Sstevel@tonic-gate }
2007c478bd9Sstevel@tonic-gate
2017c478bd9Sstevel@tonic-gate /*
2027c478bd9Sstevel@tonic-gate * set up an empty resource map for a given type and dip
2037c478bd9Sstevel@tonic-gate */
2047c478bd9Sstevel@tonic-gate int
ndi_ra_map_setup(dev_info_t * dip,char * type)2057c478bd9Sstevel@tonic-gate ndi_ra_map_setup(dev_info_t *dip, char *type)
2067c478bd9Sstevel@tonic-gate {
2077c478bd9Sstevel@tonic-gate struct ra_type_map *typemapp;
2087c478bd9Sstevel@tonic-gate struct ra_dip_type *dipmap;
2097c478bd9Sstevel@tonic-gate struct ra_dip_type **backdip;
2107c478bd9Sstevel@tonic-gate struct ra_type_map **backtype;
2117c478bd9Sstevel@tonic-gate
2127c478bd9Sstevel@tonic-gate
2137c478bd9Sstevel@tonic-gate mutex_enter(&ra_lock);
2147c478bd9Sstevel@tonic-gate
2157c478bd9Sstevel@tonic-gate dipmap = find_dip_map_resources(dip, type, &backdip, &backtype, 0);
2167c478bd9Sstevel@tonic-gate
2177c478bd9Sstevel@tonic-gate if (dipmap == NULL) {
2187c478bd9Sstevel@tonic-gate if (backtype == NULL) {
2197c478bd9Sstevel@tonic-gate typemapp = (struct ra_type_map *)
22026947304SEvan Yan kmem_zalloc(sizeof (*typemapp), KM_SLEEP);
2217c478bd9Sstevel@tonic-gate typemapp->type = (char *)kmem_zalloc(strlen(type) + 1,
22226947304SEvan Yan KM_SLEEP);
2237c478bd9Sstevel@tonic-gate (void) strcpy(typemapp->type, type);
2247c478bd9Sstevel@tonic-gate RA_INSERT(&ra_map_list_head, typemapp);
2257c478bd9Sstevel@tonic-gate } else {
2267c478bd9Sstevel@tonic-gate typemapp = *backtype;
2277c478bd9Sstevel@tonic-gate }
2287c478bd9Sstevel@tonic-gate if (backdip == NULL) {
2297c478bd9Sstevel@tonic-gate /* allocate and insert in list of dips for this type */
2307c478bd9Sstevel@tonic-gate dipmap = (struct ra_dip_type *)
23126947304SEvan Yan kmem_zalloc(sizeof (*dipmap), KM_SLEEP);
2327c478bd9Sstevel@tonic-gate dipmap->ra_dip = dip;
2337c478bd9Sstevel@tonic-gate RA_INSERT(&typemapp->ra_dip_list, dipmap);
2347c478bd9Sstevel@tonic-gate }
2357c478bd9Sstevel@tonic-gate }
2367c478bd9Sstevel@tonic-gate
2377c478bd9Sstevel@tonic-gate mutex_exit(&ra_lock);
2387c478bd9Sstevel@tonic-gate return (NDI_SUCCESS);
2397c478bd9Sstevel@tonic-gate }
2407c478bd9Sstevel@tonic-gate
2417c478bd9Sstevel@tonic-gate /*
2427c478bd9Sstevel@tonic-gate * destroys a resource map for a given dip and type
2437c478bd9Sstevel@tonic-gate */
2447c478bd9Sstevel@tonic-gate int
ndi_ra_map_destroy(dev_info_t * dip,char * type)2457c478bd9Sstevel@tonic-gate ndi_ra_map_destroy(dev_info_t *dip, char *type)
2467c478bd9Sstevel@tonic-gate {
2477c478bd9Sstevel@tonic-gate struct ra_dip_type *dipmap;
2487c478bd9Sstevel@tonic-gate struct ra_dip_type **backdip;
24986ef0a63SRichard Lowe struct ra_type_map **backtype, *typemap;
2507c478bd9Sstevel@tonic-gate struct ra_resource *range;
2517c478bd9Sstevel@tonic-gate
2527c478bd9Sstevel@tonic-gate mutex_enter(&ra_lock);
2537c478bd9Sstevel@tonic-gate dipmap = find_dip_map_resources(dip, type, &backdip, &backtype, 0);
2547c478bd9Sstevel@tonic-gate
2557c478bd9Sstevel@tonic-gate if (dipmap == NULL) {
2567c478bd9Sstevel@tonic-gate mutex_exit(&ra_lock);
2577c478bd9Sstevel@tonic-gate return (NDI_FAILURE);
2587c478bd9Sstevel@tonic-gate }
2597c478bd9Sstevel@tonic-gate
2607c478bd9Sstevel@tonic-gate /*
2617c478bd9Sstevel@tonic-gate * destroy all resources for this dip
2627c478bd9Sstevel@tonic-gate * remove dip from type list
2637c478bd9Sstevel@tonic-gate */
2647c478bd9Sstevel@tonic-gate ASSERT((backdip != NULL) && (backtype != NULL));
2657c478bd9Sstevel@tonic-gate while (dipmap->ra_rangeset != NULL) {
2667c478bd9Sstevel@tonic-gate range = dipmap->ra_rangeset;
2677c478bd9Sstevel@tonic-gate RA_REMOVE(&dipmap->ra_rangeset, range);
2687c478bd9Sstevel@tonic-gate kmem_free((caddr_t)range, sizeof (*range));
2697c478bd9Sstevel@tonic-gate }
2707c478bd9Sstevel@tonic-gate /* remove from dip list */
2717c478bd9Sstevel@tonic-gate RA_REMOVE(backdip, dipmap);
2727c478bd9Sstevel@tonic-gate kmem_free((caddr_t)dipmap, sizeof (*dipmap));
2737c478bd9Sstevel@tonic-gate if ((*backtype)->ra_dip_list == NULL) {
2747c478bd9Sstevel@tonic-gate /*
2757c478bd9Sstevel@tonic-gate * This was the last dip with this resource type.
2767c478bd9Sstevel@tonic-gate * Remove the type from the global list.
2777c478bd9Sstevel@tonic-gate */
2787c478bd9Sstevel@tonic-gate typemap = *backtype;
2797c478bd9Sstevel@tonic-gate RA_REMOVE(backtype, (*backtype));
2807c478bd9Sstevel@tonic-gate kmem_free((caddr_t)typemap->type, strlen(typemap->type) + 1);
2817c478bd9Sstevel@tonic-gate kmem_free((caddr_t)typemap, sizeof (*typemap));
2827c478bd9Sstevel@tonic-gate }
2837c478bd9Sstevel@tonic-gate
2847c478bd9Sstevel@tonic-gate mutex_exit(&ra_lock);
2857c478bd9Sstevel@tonic-gate return (NDI_SUCCESS);
2867c478bd9Sstevel@tonic-gate }
2877c478bd9Sstevel@tonic-gate
2887c478bd9Sstevel@tonic-gate static int
ra_map_exist(dev_info_t * dip,char * type)2897c478bd9Sstevel@tonic-gate ra_map_exist(dev_info_t *dip, char *type)
2907c478bd9Sstevel@tonic-gate {
2917c478bd9Sstevel@tonic-gate struct ra_dip_type **backdip;
2927c478bd9Sstevel@tonic-gate struct ra_type_map **backtype;
2937c478bd9Sstevel@tonic-gate
2947c478bd9Sstevel@tonic-gate mutex_enter(&ra_lock);
2957c478bd9Sstevel@tonic-gate if (find_dip_map_resources(dip, type, &backdip, &backtype, 0) == NULL) {
2967c478bd9Sstevel@tonic-gate mutex_exit(&ra_lock);
2977c478bd9Sstevel@tonic-gate return (NDI_FAILURE);
2987c478bd9Sstevel@tonic-gate }
2997c478bd9Sstevel@tonic-gate
3007c478bd9Sstevel@tonic-gate mutex_exit(&ra_lock);
3017c478bd9Sstevel@tonic-gate return (NDI_SUCCESS);
3027c478bd9Sstevel@tonic-gate }
3037c478bd9Sstevel@tonic-gate /*
3047c478bd9Sstevel@tonic-gate * Find a dip map for the specified type, if NDI_RA_PASS will go up on dev tree
3057c478bd9Sstevel@tonic-gate * if found, backdip and backtype will be updated to point to the previous
3067c478bd9Sstevel@tonic-gate * dip in the list and previous type for this dip in the list.
3077c478bd9Sstevel@tonic-gate * If no such type at all in the resource list both backdip and backtype
3087c478bd9Sstevel@tonic-gate * will be null. If the type found but no dip, back dip will be null.
3097c478bd9Sstevel@tonic-gate */
3107c478bd9Sstevel@tonic-gate
3117c478bd9Sstevel@tonic-gate static struct ra_dip_type *
find_dip_map_resources(dev_info_t * dip,char * type,struct ra_dip_type *** backdip,struct ra_type_map *** backtype,uint32_t flag)3127c478bd9Sstevel@tonic-gate find_dip_map_resources(dev_info_t *dip, char *type,
3137c478bd9Sstevel@tonic-gate struct ra_dip_type ***backdip, struct ra_type_map ***backtype,
3147c478bd9Sstevel@tonic-gate uint32_t flag)
3157c478bd9Sstevel@tonic-gate {
3167c478bd9Sstevel@tonic-gate struct ra_type_map **prevmap;
3177c478bd9Sstevel@tonic-gate struct ra_dip_type *dipmap, **prevdip;
3187c478bd9Sstevel@tonic-gate
3197c478bd9Sstevel@tonic-gate ASSERT(mutex_owned(&ra_lock));
3207c478bd9Sstevel@tonic-gate prevdip = NULL;
3217c478bd9Sstevel@tonic-gate dipmap = NULL;
3227c478bd9Sstevel@tonic-gate prevmap = &ra_map_list_head;
3237c478bd9Sstevel@tonic-gate
3247c478bd9Sstevel@tonic-gate while (*prevmap) {
3257c478bd9Sstevel@tonic-gate if (strcmp((*prevmap)->type, type) == 0)
3267c478bd9Sstevel@tonic-gate break;
3277c478bd9Sstevel@tonic-gate prevmap = &(*prevmap)->ra_next;
3287c478bd9Sstevel@tonic-gate }
3297c478bd9Sstevel@tonic-gate
3307c478bd9Sstevel@tonic-gate if (*prevmap) {
3317c478bd9Sstevel@tonic-gate for (; dip != NULL; dip = ddi_get_parent(dip)) {
3327c478bd9Sstevel@tonic-gate prevdip = &(*prevmap)->ra_dip_list;
3337c478bd9Sstevel@tonic-gate dipmap = *prevdip;
3347c478bd9Sstevel@tonic-gate
3357c478bd9Sstevel@tonic-gate while (dipmap) {
3367c478bd9Sstevel@tonic-gate if (dipmap->ra_dip == dip)
3377c478bd9Sstevel@tonic-gate break;
3387c478bd9Sstevel@tonic-gate prevdip = &dipmap->ra_next;
3397c478bd9Sstevel@tonic-gate dipmap = dipmap->ra_next;
3407c478bd9Sstevel@tonic-gate }
3417c478bd9Sstevel@tonic-gate
3427c478bd9Sstevel@tonic-gate if (dipmap != NULL) {
3437c478bd9Sstevel@tonic-gate /* found it */
3447c478bd9Sstevel@tonic-gate break;
3457c478bd9Sstevel@tonic-gate }
3467c478bd9Sstevel@tonic-gate
3477c478bd9Sstevel@tonic-gate if (!(flag & NDI_RA_PASS)) {
3487c478bd9Sstevel@tonic-gate break;
3497c478bd9Sstevel@tonic-gate }
3507c478bd9Sstevel@tonic-gate }
3517c478bd9Sstevel@tonic-gate }
3527c478bd9Sstevel@tonic-gate
3537c478bd9Sstevel@tonic-gate *backtype = (*prevmap == NULL) ? NULL: prevmap;
3547c478bd9Sstevel@tonic-gate *backdip = (dipmap == NULL) ? NULL: prevdip;
3557c478bd9Sstevel@tonic-gate
3567c478bd9Sstevel@tonic-gate return (dipmap);
3577c478bd9Sstevel@tonic-gate }
3587c478bd9Sstevel@tonic-gate
3597c478bd9Sstevel@tonic-gate int
ndi_ra_free(dev_info_t * dip,uint64_t base,uint64_t len,char * type,uint32_t flag)3607c478bd9Sstevel@tonic-gate ndi_ra_free(dev_info_t *dip, uint64_t base, uint64_t len, char *type,
3617c478bd9Sstevel@tonic-gate uint32_t flag)
3627c478bd9Sstevel@tonic-gate {
3637c478bd9Sstevel@tonic-gate struct ra_dip_type *dipmap;
3647c478bd9Sstevel@tonic-gate struct ra_resource *newmap, *overlapmap, *oldmap = NULL;
3657c478bd9Sstevel@tonic-gate struct ra_resource *mapp, **backp;
3667c478bd9Sstevel@tonic-gate uint64_t newend, mapend;
3677c478bd9Sstevel@tonic-gate struct ra_dip_type **backdip;
3687c478bd9Sstevel@tonic-gate struct ra_type_map **backtype;
3697c478bd9Sstevel@tonic-gate
3707c478bd9Sstevel@tonic-gate if (len == 0) {
3717c478bd9Sstevel@tonic-gate return (NDI_SUCCESS);
3727c478bd9Sstevel@tonic-gate }
3737c478bd9Sstevel@tonic-gate
3747c478bd9Sstevel@tonic-gate mutex_enter(&ra_lock);
3757c478bd9Sstevel@tonic-gate
3767c478bd9Sstevel@tonic-gate if ((dipmap = find_dip_map_resources(dip, type, &backdip, &backtype,
3777c478bd9Sstevel@tonic-gate flag)) == NULL) {
3787c478bd9Sstevel@tonic-gate mutex_exit(&ra_lock);
3797c478bd9Sstevel@tonic-gate return (NDI_FAILURE);
3807c478bd9Sstevel@tonic-gate }
3817c478bd9Sstevel@tonic-gate
3827c478bd9Sstevel@tonic-gate mapp = dipmap->ra_rangeset;
3837c478bd9Sstevel@tonic-gate backp = &dipmap->ra_rangeset;
3847c478bd9Sstevel@tonic-gate
3857c478bd9Sstevel@tonic-gate /* now find where range lies and fix things up */
3867c478bd9Sstevel@tonic-gate newend = base + len;
3877c478bd9Sstevel@tonic-gate for (; mapp != NULL; backp = &(mapp->ra_next), mapp = mapp->ra_next) {
3887c478bd9Sstevel@tonic-gate mapend = mapp->ra_base + mapp->ra_len;
3897c478bd9Sstevel@tonic-gate
3907c478bd9Sstevel@tonic-gate /* check for overlap first */
3917c478bd9Sstevel@tonic-gate if ((base <= mapp->ra_base && newend > mapp->ra_base) ||
3927c478bd9Sstevel@tonic-gate (base > mapp->ra_base && base < mapend)) {
3937c478bd9Sstevel@tonic-gate /* overlap with mapp */
3947c478bd9Sstevel@tonic-gate overlapmap = mapp;
3957c478bd9Sstevel@tonic-gate goto overlap;
3967c478bd9Sstevel@tonic-gate } else if ((base == mapend && mapp->ra_next) &&
3977c478bd9Sstevel@tonic-gate (newend > mapp->ra_next->ra_base)) {
3987c478bd9Sstevel@tonic-gate /* overlap with mapp->ra_next */
3997c478bd9Sstevel@tonic-gate overlapmap = mapp->ra_next;
4007c478bd9Sstevel@tonic-gate goto overlap;
4017c478bd9Sstevel@tonic-gate }
4027c478bd9Sstevel@tonic-gate
4037c478bd9Sstevel@tonic-gate if (newend == mapp->ra_base) {
4047c478bd9Sstevel@tonic-gate /* simple - on front */
4057c478bd9Sstevel@tonic-gate mapp->ra_base = base;
4067c478bd9Sstevel@tonic-gate mapp->ra_len += len;
4077c478bd9Sstevel@tonic-gate /*
4087c478bd9Sstevel@tonic-gate * don't need to check if it merges with
4097c478bd9Sstevel@tonic-gate * previous since that would match on on end
4107c478bd9Sstevel@tonic-gate */
4117c478bd9Sstevel@tonic-gate break;
4127c478bd9Sstevel@tonic-gate } else if (base == mapend) {
4137c478bd9Sstevel@tonic-gate /* simple - on end */
4147c478bd9Sstevel@tonic-gate mapp->ra_len += len;
4157c478bd9Sstevel@tonic-gate if (mapp->ra_next &&
4167c478bd9Sstevel@tonic-gate (newend == mapp->ra_next->ra_base)) {
4177c478bd9Sstevel@tonic-gate /* merge with next node */
4187c478bd9Sstevel@tonic-gate oldmap = mapp->ra_next;
4197c478bd9Sstevel@tonic-gate mapp->ra_len += oldmap->ra_len;
4207c478bd9Sstevel@tonic-gate RA_REMOVE(&mapp->ra_next, oldmap);
4217c478bd9Sstevel@tonic-gate kmem_free((caddr_t)oldmap, sizeof (*oldmap));
4227c478bd9Sstevel@tonic-gate }
4237c478bd9Sstevel@tonic-gate break;
4247c478bd9Sstevel@tonic-gate } else if (base < mapp->ra_base) {
4257c478bd9Sstevel@tonic-gate /* somewhere in between so just an insert */
4267c478bd9Sstevel@tonic-gate newmap = (struct ra_resource *)
42726947304SEvan Yan kmem_zalloc(sizeof (*newmap), KM_SLEEP);
4287c478bd9Sstevel@tonic-gate newmap->ra_base = base;
4297c478bd9Sstevel@tonic-gate newmap->ra_len = len;
4307c478bd9Sstevel@tonic-gate RA_INSERT(backp, newmap);
4317c478bd9Sstevel@tonic-gate break;
4327c478bd9Sstevel@tonic-gate }
4337c478bd9Sstevel@tonic-gate }
4347c478bd9Sstevel@tonic-gate if (mapp == NULL) {
4357c478bd9Sstevel@tonic-gate /* stick on end */
4367c478bd9Sstevel@tonic-gate newmap = (struct ra_resource *)
43726947304SEvan Yan kmem_zalloc(sizeof (*newmap), KM_SLEEP);
4387c478bd9Sstevel@tonic-gate newmap->ra_base = base;
4397c478bd9Sstevel@tonic-gate newmap->ra_len = len;
4407c478bd9Sstevel@tonic-gate RA_INSERT(backp, newmap);
4417c478bd9Sstevel@tonic-gate }
4427c478bd9Sstevel@tonic-gate
4437c478bd9Sstevel@tonic-gate mutex_exit(&ra_lock);
44426947304SEvan Yan
44526947304SEvan Yan /*
44626947304SEvan Yan * Update dip's "available" property, adding this piece of
44726947304SEvan Yan * resource to the pool.
44826947304SEvan Yan */
4490035d21cSmiao chen - Sun Microsystems - Beijing China (void) pci_put_available_prop(dipmap->ra_dip, base, len, type);
45026947304SEvan Yan done:
4517c478bd9Sstevel@tonic-gate return (NDI_SUCCESS);
4527c478bd9Sstevel@tonic-gate
4537c478bd9Sstevel@tonic-gate overlap:
4547c478bd9Sstevel@tonic-gate /*
4557c478bd9Sstevel@tonic-gate * Bad free may happen on some x86 platforms with BIOS exporting
4567c478bd9Sstevel@tonic-gate * incorrect resource maps. The system is otherwise functioning
4577c478bd9Sstevel@tonic-gate * normally. We send such messages to syslog only.
4587c478bd9Sstevel@tonic-gate */
4597c478bd9Sstevel@tonic-gate cmn_err(CE_NOTE, "!ndi_ra_free: bad free, dip %p, resource type %s \n",
4607c478bd9Sstevel@tonic-gate (void *)dip, type);
4617c478bd9Sstevel@tonic-gate cmn_err(CE_NOTE, "!ndi_ra_free: freeing base 0x%" PRIx64 ", len 0x%"
4627c478bd9Sstevel@tonic-gate PRIX64 " overlaps with existing resource base 0x%" PRIx64
4637c478bd9Sstevel@tonic-gate ", len 0x%" PRIx64 "\n", base, len, overlapmap->ra_base,
4647c478bd9Sstevel@tonic-gate overlapmap->ra_len);
4657c478bd9Sstevel@tonic-gate
4667c478bd9Sstevel@tonic-gate mutex_exit(&ra_lock);
4677c478bd9Sstevel@tonic-gate return (NDI_FAILURE);
4687c478bd9Sstevel@tonic-gate }
4697c478bd9Sstevel@tonic-gate
4707c478bd9Sstevel@tonic-gate /* check to see if value is power of 2 or not. */
4717c478bd9Sstevel@tonic-gate static int
isnot_pow2(uint64_t value)4727c478bd9Sstevel@tonic-gate isnot_pow2(uint64_t value)
4737c478bd9Sstevel@tonic-gate {
4747c478bd9Sstevel@tonic-gate uint32_t low;
4757c478bd9Sstevel@tonic-gate uint32_t hi;
4767c478bd9Sstevel@tonic-gate
4777c478bd9Sstevel@tonic-gate low = value & 0xffffffff;
4787c478bd9Sstevel@tonic-gate hi = value >> 32;
4797c478bd9Sstevel@tonic-gate
4807c478bd9Sstevel@tonic-gate /*
4817c478bd9Sstevel@tonic-gate * ddi_ffs and ddi_fls gets long values, so in 32bit environment
4827c478bd9Sstevel@tonic-gate * won't work correctly for 64bit values
4837c478bd9Sstevel@tonic-gate */
4847c478bd9Sstevel@tonic-gate if ((ddi_ffs(low) == ddi_fls(low)) &&
4857c478bd9Sstevel@tonic-gate (ddi_ffs(hi) == ddi_fls(hi)))
4867c478bd9Sstevel@tonic-gate return (0);
4877c478bd9Sstevel@tonic-gate return (1);
4887c478bd9Sstevel@tonic-gate }
4897c478bd9Sstevel@tonic-gate
4907c478bd9Sstevel@tonic-gate static void
adjust_link(struct ra_resource ** backp,struct ra_resource * mapp,uint64_t base,uint64_t len)4917c478bd9Sstevel@tonic-gate adjust_link(struct ra_resource **backp, struct ra_resource *mapp,
49286ef0a63SRichard Lowe uint64_t base, uint64_t len)
4937c478bd9Sstevel@tonic-gate {
4947c478bd9Sstevel@tonic-gate struct ra_resource *newmap;
4957c478bd9Sstevel@tonic-gate uint64_t newlen;
4967c478bd9Sstevel@tonic-gate
4977c478bd9Sstevel@tonic-gate if (base != mapp->ra_base) {
4987c478bd9Sstevel@tonic-gate /* in the middle or end */
4997c478bd9Sstevel@tonic-gate newlen = base - mapp->ra_base;
5007c478bd9Sstevel@tonic-gate if ((mapp->ra_len - newlen) == len) {
5017c478bd9Sstevel@tonic-gate /* on the end */
5027c478bd9Sstevel@tonic-gate mapp->ra_len = newlen;
5037c478bd9Sstevel@tonic-gate } else {
5047c478bd9Sstevel@tonic-gate /* in the middle */
5057c478bd9Sstevel@tonic-gate newmap = (struct ra_resource *)
50626947304SEvan Yan kmem_zalloc(sizeof (*newmap), KM_SLEEP);
5077c478bd9Sstevel@tonic-gate newmap->ra_base = base + len;
50826947304SEvan Yan newmap->ra_len = mapp->ra_len - (len + newlen);
5097c478bd9Sstevel@tonic-gate mapp->ra_len = newlen;
5107c478bd9Sstevel@tonic-gate RA_INSERT(&(mapp->ra_next), newmap);
5117c478bd9Sstevel@tonic-gate }
5127c478bd9Sstevel@tonic-gate } else {
5137c478bd9Sstevel@tonic-gate /* at the beginning */
5147c478bd9Sstevel@tonic-gate mapp->ra_base += len;
5157c478bd9Sstevel@tonic-gate mapp->ra_len -= len;
5167c478bd9Sstevel@tonic-gate if (mapp->ra_len == 0) {
5177c478bd9Sstevel@tonic-gate /* remove the whole node */
5187c478bd9Sstevel@tonic-gate RA_REMOVE(backp, mapp);
5197c478bd9Sstevel@tonic-gate kmem_free((caddr_t)mapp, sizeof (*mapp));
5207c478bd9Sstevel@tonic-gate }
5217c478bd9Sstevel@tonic-gate }
5227c478bd9Sstevel@tonic-gate }
5237c478bd9Sstevel@tonic-gate
5247c478bd9Sstevel@tonic-gate int
ndi_ra_alloc(dev_info_t * dip,ndi_ra_request_t * req,uint64_t * retbasep,uint64_t * retlenp,char * type,uint32_t flag)5257c478bd9Sstevel@tonic-gate ndi_ra_alloc(dev_info_t *dip, ndi_ra_request_t *req, uint64_t *retbasep,
5267c478bd9Sstevel@tonic-gate uint64_t *retlenp, char *type, uint32_t flag)
5277c478bd9Sstevel@tonic-gate {
5287c478bd9Sstevel@tonic-gate struct ra_dip_type *dipmap;
5297c478bd9Sstevel@tonic-gate struct ra_resource *mapp, **backp, **backlargestp;
5307c478bd9Sstevel@tonic-gate uint64_t mask = 0;
5317c478bd9Sstevel@tonic-gate uint64_t len, remlen, largestbase, largestlen;
5327c478bd9Sstevel@tonic-gate uint64_t base, oldbase, lower, upper;
5337c478bd9Sstevel@tonic-gate struct ra_dip_type **backdip;
5347c478bd9Sstevel@tonic-gate struct ra_type_map **backtype;
5357c478bd9Sstevel@tonic-gate int rval = NDI_FAILURE;
5367c478bd9Sstevel@tonic-gate
5377c478bd9Sstevel@tonic-gate
5387c478bd9Sstevel@tonic-gate len = req->ra_len;
5397c478bd9Sstevel@tonic-gate
5407c478bd9Sstevel@tonic-gate if (req->ra_flags & NDI_RA_ALIGN_SIZE) {
5417c478bd9Sstevel@tonic-gate if (isnot_pow2(req->ra_len)) {
5427c478bd9Sstevel@tonic-gate DEBUGPRT(CE_WARN, "ndi_ra_alloc: bad length(pow2) 0x%"
54326947304SEvan Yan PRIx64, req->ra_len);
5447c478bd9Sstevel@tonic-gate *retbasep = 0;
5457c478bd9Sstevel@tonic-gate *retlenp = 0;
5467c478bd9Sstevel@tonic-gate return (NDI_FAILURE);
5477c478bd9Sstevel@tonic-gate }
5487c478bd9Sstevel@tonic-gate }
5497c478bd9Sstevel@tonic-gate
5507c478bd9Sstevel@tonic-gate mask = (req->ra_flags & NDI_RA_ALIGN_SIZE) ? (len - 1) :
5517c478bd9Sstevel@tonic-gate req->ra_align_mask;
5527c478bd9Sstevel@tonic-gate
5537c478bd9Sstevel@tonic-gate
5547c478bd9Sstevel@tonic-gate mutex_enter(&ra_lock);
5557c478bd9Sstevel@tonic-gate dipmap = find_dip_map_resources(dip, type, &backdip, &backtype, flag);
5567c478bd9Sstevel@tonic-gate if ((dipmap == NULL) || ((mapp = dipmap->ra_rangeset) == NULL)) {
5577c478bd9Sstevel@tonic-gate mutex_exit(&ra_lock);
5587c478bd9Sstevel@tonic-gate DEBUGPRT(CE_CONT, "ndi_ra_alloc no map found for this type\n");
5597c478bd9Sstevel@tonic-gate return (NDI_FAILURE);
5607c478bd9Sstevel@tonic-gate }
5617c478bd9Sstevel@tonic-gate
5627c478bd9Sstevel@tonic-gate DEBUGPRT(CE_CONT, "ndi_ra_alloc: mapp = %p len=%" PRIx64 ", mask=%"
56326947304SEvan Yan PRIx64 "\n", (void *)mapp, len, mask);
5647c478bd9Sstevel@tonic-gate
5657c478bd9Sstevel@tonic-gate backp = &(dipmap->ra_rangeset);
5667c478bd9Sstevel@tonic-gate backlargestp = NULL;
5677c478bd9Sstevel@tonic-gate largestbase = 0;
5687c478bd9Sstevel@tonic-gate largestlen = 0;
5697c478bd9Sstevel@tonic-gate
5707c478bd9Sstevel@tonic-gate lower = 0;
5717c478bd9Sstevel@tonic-gate upper = ~(uint64_t)0;
5727c478bd9Sstevel@tonic-gate
5737c478bd9Sstevel@tonic-gate if (req->ra_flags & NDI_RA_ALLOC_BOUNDED) {
5747c478bd9Sstevel@tonic-gate /* bounded so skip to first possible */
5757c478bd9Sstevel@tonic-gate lower = req->ra_boundbase;
5767c478bd9Sstevel@tonic-gate upper = req->ra_boundlen + lower;
5777c478bd9Sstevel@tonic-gate if ((upper == 0) || (upper < req->ra_boundlen))
5787c478bd9Sstevel@tonic-gate upper = ~(uint64_t)0;
5797c478bd9Sstevel@tonic-gate DEBUGPRT(CE_CONT, "ndi_ra_alloc: ra_len = %" PRIx64 ", len = %"
58026947304SEvan Yan PRIx64 " ra_base=%" PRIx64 ", mask=%" PRIx64
58126947304SEvan Yan "\n", mapp->ra_len, len, mapp->ra_base, mask);
58226947304SEvan Yan for (; mapp != NULL && (mapp->ra_base + mapp->ra_len) < lower;
58326947304SEvan Yan backp = &(mapp->ra_next), mapp = mapp->ra_next) {
5847c478bd9Sstevel@tonic-gate if (((mapp->ra_len + mapp->ra_base) == 0) ||
5857c478bd9Sstevel@tonic-gate ((mapp->ra_len + mapp->ra_base) < mapp->ra_len))
5867c478bd9Sstevel@tonic-gate /*
5877c478bd9Sstevel@tonic-gate * This elements end goes beyond max uint64_t.
5887c478bd9Sstevel@tonic-gate * potential candidate, check end against lower
5897c478bd9Sstevel@tonic-gate * would not be precise.
5907c478bd9Sstevel@tonic-gate */
5917c478bd9Sstevel@tonic-gate break;
5927c478bd9Sstevel@tonic-gate
5937c478bd9Sstevel@tonic-gate DEBUGPRT(CE_CONT, " ra_len = %" PRIx64 ", ra_base=%"
5947c478bd9Sstevel@tonic-gate PRIx64 "\n", mapp->ra_len, mapp->ra_base);
5957c478bd9Sstevel@tonic-gate }
5967c478bd9Sstevel@tonic-gate
5977c478bd9Sstevel@tonic-gate }
5987c478bd9Sstevel@tonic-gate
5997c478bd9Sstevel@tonic-gate if (!(req->ra_flags & NDI_RA_ALLOC_SPECIFIED)) {
6007c478bd9Sstevel@tonic-gate /* first fit - not user specified */
6017c478bd9Sstevel@tonic-gate DEBUGPRT(CE_CONT, "ndi_ra_alloc(unspecified request)"
60226947304SEvan Yan "lower=%" PRIx64 ", upper=%" PRIx64 "\n", lower, upper);
6037c478bd9Sstevel@tonic-gate for (; mapp != NULL && mapp->ra_base <= upper;
60426947304SEvan Yan backp = &(mapp->ra_next), mapp = mapp->ra_next) {
6057c478bd9Sstevel@tonic-gate
6067c478bd9Sstevel@tonic-gate DEBUGPRT(CE_CONT, "ndi_ra_alloc: ra_len = %" PRIx64
6077c478bd9Sstevel@tonic-gate ", len = %" PRIx64 "", mapp->ra_len, len);
6087c478bd9Sstevel@tonic-gate base = mapp->ra_base;
6097c478bd9Sstevel@tonic-gate if (base < lower) {
6107c478bd9Sstevel@tonic-gate base = lower;
6117c478bd9Sstevel@tonic-gate DEBUGPRT(CE_CONT, "\tbase=%" PRIx64
6127c478bd9Sstevel@tonic-gate ", ra_base=%" PRIx64 ", mask=%" PRIx64,
6137c478bd9Sstevel@tonic-gate base, mapp->ra_base, mask);
6147c478bd9Sstevel@tonic-gate }
6157c478bd9Sstevel@tonic-gate
6167c478bd9Sstevel@tonic-gate if ((base & mask) != 0) {
6177c478bd9Sstevel@tonic-gate oldbase = base;
6187c478bd9Sstevel@tonic-gate /*
6197c478bd9Sstevel@tonic-gate * failed a critical constraint
6207c478bd9Sstevel@tonic-gate * adjust and see if it still fits
6217c478bd9Sstevel@tonic-gate */
6227c478bd9Sstevel@tonic-gate base = base & ~mask;
6237c478bd9Sstevel@tonic-gate base += (mask + 1);
6247c478bd9Sstevel@tonic-gate DEBUGPRT(CE_CONT, "\tnew base=%" PRIx64 "\n",
62526947304SEvan Yan base);
6267c478bd9Sstevel@tonic-gate
6277c478bd9Sstevel@tonic-gate /*
6287c478bd9Sstevel@tonic-gate * Check to see if the new base is past
6297c478bd9Sstevel@tonic-gate * the end of the resource.
6307c478bd9Sstevel@tonic-gate */
6317c478bd9Sstevel@tonic-gate if (base >= (oldbase + mapp->ra_len + 1)) {
6327c478bd9Sstevel@tonic-gate continue;
6337c478bd9Sstevel@tonic-gate }
6347c478bd9Sstevel@tonic-gate }
6357c478bd9Sstevel@tonic-gate
6367c478bd9Sstevel@tonic-gate if (req->ra_flags & NDI_RA_ALLOC_PARTIAL_OK) {
6377c478bd9Sstevel@tonic-gate if ((upper - mapp->ra_base) < mapp->ra_len)
6387c478bd9Sstevel@tonic-gate remlen = upper - base;
6397c478bd9Sstevel@tonic-gate else
6407c478bd9Sstevel@tonic-gate remlen = mapp->ra_len -
64126947304SEvan Yan (base - mapp->ra_base);
6427c478bd9Sstevel@tonic-gate
6437c478bd9Sstevel@tonic-gate if ((backlargestp == NULL) ||
6447c478bd9Sstevel@tonic-gate (largestlen < remlen)) {
6457c478bd9Sstevel@tonic-gate
6467c478bd9Sstevel@tonic-gate backlargestp = backp;
6477c478bd9Sstevel@tonic-gate largestbase = base;
6487c478bd9Sstevel@tonic-gate largestlen = remlen;
6497c478bd9Sstevel@tonic-gate }
6507c478bd9Sstevel@tonic-gate }
6517c478bd9Sstevel@tonic-gate
6527c478bd9Sstevel@tonic-gate if (mapp->ra_len >= len) {
6537c478bd9Sstevel@tonic-gate /* a candidate -- apply constraints */
6547c478bd9Sstevel@tonic-gate if ((len > (mapp->ra_len -
6557c478bd9Sstevel@tonic-gate (base - mapp->ra_base))) ||
6567c478bd9Sstevel@tonic-gate ((len - 1 + base) > upper)) {
6577c478bd9Sstevel@tonic-gate continue;
6587c478bd9Sstevel@tonic-gate }
6597c478bd9Sstevel@tonic-gate
6607c478bd9Sstevel@tonic-gate /* we have a fit */
6617c478bd9Sstevel@tonic-gate
6627c478bd9Sstevel@tonic-gate DEBUGPRT(CE_CONT, "\thave a fit\n");
6637c478bd9Sstevel@tonic-gate
6647c478bd9Sstevel@tonic-gate adjust_link(backp, mapp, base, len);
6657c478bd9Sstevel@tonic-gate rval = NDI_SUCCESS;
6667c478bd9Sstevel@tonic-gate break;
6677c478bd9Sstevel@tonic-gate
6687c478bd9Sstevel@tonic-gate }
6697c478bd9Sstevel@tonic-gate }
6707c478bd9Sstevel@tonic-gate } else {
6717c478bd9Sstevel@tonic-gate /* want an exact value/fit */
6727c478bd9Sstevel@tonic-gate base = req->ra_addr;
6737c478bd9Sstevel@tonic-gate len = req->ra_len;
6747c478bd9Sstevel@tonic-gate for (; mapp != NULL && mapp->ra_base <= upper;
67526947304SEvan Yan backp = &(mapp->ra_next), mapp = mapp->ra_next) {
6767c478bd9Sstevel@tonic-gate if (base >= mapp->ra_base &&
6777c478bd9Sstevel@tonic-gate ((base - mapp->ra_base) < mapp->ra_len)) {
6787c478bd9Sstevel@tonic-gate /*
67948bbca81SDaniel Hoffman * This is the node with the requested base in
6807c478bd9Sstevel@tonic-gate * its range
6817c478bd9Sstevel@tonic-gate */
6827c478bd9Sstevel@tonic-gate if ((len > mapp->ra_len) ||
6837c478bd9Sstevel@tonic-gate (base - mapp->ra_base >
6847c478bd9Sstevel@tonic-gate mapp->ra_len - len)) {
6857c478bd9Sstevel@tonic-gate /* length requirement not satisfied */
6867c478bd9Sstevel@tonic-gate if (req->ra_flags &
6877c478bd9Sstevel@tonic-gate NDI_RA_ALLOC_PARTIAL_OK) {
6887c478bd9Sstevel@tonic-gate if ((upper - mapp->ra_base)
6897c478bd9Sstevel@tonic-gate < mapp->ra_len)
6907c478bd9Sstevel@tonic-gate remlen = upper - base;
6917c478bd9Sstevel@tonic-gate else
6927c478bd9Sstevel@tonic-gate remlen =
6937c478bd9Sstevel@tonic-gate mapp->ra_len -
6947c478bd9Sstevel@tonic-gate (base -
6957c478bd9Sstevel@tonic-gate mapp->ra_base);
6967c478bd9Sstevel@tonic-gate }
6977c478bd9Sstevel@tonic-gate backlargestp = backp;
6987c478bd9Sstevel@tonic-gate largestbase = base;
6997c478bd9Sstevel@tonic-gate largestlen = remlen;
7007c478bd9Sstevel@tonic-gate base = 0;
7017c478bd9Sstevel@tonic-gate } else {
7027c478bd9Sstevel@tonic-gate /* We have a match */
7037c478bd9Sstevel@tonic-gate adjust_link(backp, mapp, base, len);
7047c478bd9Sstevel@tonic-gate rval = NDI_SUCCESS;
7057c478bd9Sstevel@tonic-gate }
7067c478bd9Sstevel@tonic-gate break;
7077c478bd9Sstevel@tonic-gate }
7087c478bd9Sstevel@tonic-gate }
7097c478bd9Sstevel@tonic-gate }
7107c478bd9Sstevel@tonic-gate
7117c478bd9Sstevel@tonic-gate if ((rval != NDI_SUCCESS) &&
7127c478bd9Sstevel@tonic-gate (req->ra_flags & NDI_RA_ALLOC_PARTIAL_OK) &&
7137c478bd9Sstevel@tonic-gate (backlargestp != NULL)) {
7147c478bd9Sstevel@tonic-gate adjust_link(backlargestp, *backlargestp, largestbase,
71526947304SEvan Yan largestlen);
7167c478bd9Sstevel@tonic-gate
7177c478bd9Sstevel@tonic-gate base = largestbase;
7187c478bd9Sstevel@tonic-gate len = largestlen;
7197c478bd9Sstevel@tonic-gate rval = NDI_RA_PARTIAL_REQ;
7207c478bd9Sstevel@tonic-gate }
7217c478bd9Sstevel@tonic-gate
7227c478bd9Sstevel@tonic-gate mutex_exit(&ra_lock);
7237c478bd9Sstevel@tonic-gate
7247c478bd9Sstevel@tonic-gate if (rval == NDI_FAILURE) {
7257c478bd9Sstevel@tonic-gate *retbasep = 0;
7267c478bd9Sstevel@tonic-gate *retlenp = 0;
7277c478bd9Sstevel@tonic-gate } else {
7287c478bd9Sstevel@tonic-gate *retbasep = base;
7297c478bd9Sstevel@tonic-gate *retlenp = len;
7307c478bd9Sstevel@tonic-gate }
73126947304SEvan Yan
73226947304SEvan Yan /*
73326947304SEvan Yan * Update dip's "available" property, substract this piece of
73426947304SEvan Yan * resource from the pool.
73526947304SEvan Yan */
73626947304SEvan Yan if ((rval == NDI_SUCCESS) || (rval == NDI_RA_PARTIAL_REQ))
7370035d21cSmiao chen - Sun Microsystems - Beijing China (void) pci_get_available_prop(dipmap->ra_dip,
7380035d21cSmiao chen - Sun Microsystems - Beijing China *retbasep, *retlenp, type);
73926947304SEvan Yan
7407c478bd9Sstevel@tonic-gate return (rval);
7417c478bd9Sstevel@tonic-gate }
7427c478bd9Sstevel@tonic-gate
7437c478bd9Sstevel@tonic-gate /*
7447c478bd9Sstevel@tonic-gate * isa_resource_setup
7457c478bd9Sstevel@tonic-gate * check for /used-resources and initialize
7467c478bd9Sstevel@tonic-gate * based on info there. If no /used-resources,
7477c478bd9Sstevel@tonic-gate * fail.
7487c478bd9Sstevel@tonic-gate */
7497c478bd9Sstevel@tonic-gate int
isa_resource_setup()7507c478bd9Sstevel@tonic-gate isa_resource_setup()
7517c478bd9Sstevel@tonic-gate {
7527c478bd9Sstevel@tonic-gate dev_info_t *used, *usedpdip;
7537c478bd9Sstevel@tonic-gate /*
7547c478bd9Sstevel@tonic-gate * note that at this time bootconf creates 32 bit properties for
7557c478bd9Sstevel@tonic-gate * io-space and device-memory
7567c478bd9Sstevel@tonic-gate */
7577c478bd9Sstevel@tonic-gate struct iorange {
7587c478bd9Sstevel@tonic-gate uint32_t base;
7597c478bd9Sstevel@tonic-gate uint32_t len;
7607c478bd9Sstevel@tonic-gate } *iorange;
7617c478bd9Sstevel@tonic-gate struct memrange {
7627c478bd9Sstevel@tonic-gate uint32_t base;
7637c478bd9Sstevel@tonic-gate uint32_t len;
7647c478bd9Sstevel@tonic-gate } *memrange;
7657c478bd9Sstevel@tonic-gate uint32_t *irq;
7667c478bd9Sstevel@tonic-gate int proplen;
7677c478bd9Sstevel@tonic-gate int i, len;
7687c478bd9Sstevel@tonic-gate int maxrange;
7697c478bd9Sstevel@tonic-gate ndi_ra_request_t req;
7707c478bd9Sstevel@tonic-gate uint64_t retbase;
7717c478bd9Sstevel@tonic-gate uint64_t retlen;
7727c478bd9Sstevel@tonic-gate
7737c478bd9Sstevel@tonic-gate used = ddi_find_devinfo("used-resources", -1, 0);
7747c478bd9Sstevel@tonic-gate if (used == NULL) {
7757c478bd9Sstevel@tonic-gate DEBUGPRT(CE_CONT,
77626947304SEvan Yan "isa_resource_setup: used-resources not found");
7777c478bd9Sstevel@tonic-gate return (NDI_FAILURE);
7787c478bd9Sstevel@tonic-gate }
7797c478bd9Sstevel@tonic-gate
7807c478bd9Sstevel@tonic-gate /*
7817c478bd9Sstevel@tonic-gate * initialize to all resources being present
7827c478bd9Sstevel@tonic-gate * and then remove the ones in use.
7837c478bd9Sstevel@tonic-gate */
7847c478bd9Sstevel@tonic-gate
7857c478bd9Sstevel@tonic-gate usedpdip = ddi_root_node();
7867c478bd9Sstevel@tonic-gate
7877c478bd9Sstevel@tonic-gate DEBUGPRT(CE_CONT, "isa_resource_setup: used = %p usedpdip = %p\n",
7887c478bd9Sstevel@tonic-gate (void *)used, (void *)usedpdip);
7897c478bd9Sstevel@tonic-gate
7907c478bd9Sstevel@tonic-gate if (ndi_ra_map_setup(usedpdip, NDI_RA_TYPE_IO) == NDI_FAILURE) {
7917c478bd9Sstevel@tonic-gate return (NDI_FAILURE);
7927c478bd9Sstevel@tonic-gate }
7937c478bd9Sstevel@tonic-gate
7947c478bd9Sstevel@tonic-gate /* initialize io space, highest end base is 0xffff */
7957c478bd9Sstevel@tonic-gate /* note that length is highest addr + 1 since starts from 0 */
7967c478bd9Sstevel@tonic-gate
7977c478bd9Sstevel@tonic-gate (void) ndi_ra_free(usedpdip, 0, 0xffff + 1, NDI_RA_TYPE_IO, 0);
7987c478bd9Sstevel@tonic-gate
799a3282898Scth if (ddi_getlongprop(DDI_DEV_T_ANY, used, DDI_PROP_DONTPASS,
8007c478bd9Sstevel@tonic-gate "io-space", (caddr_t)&iorange, &proplen) == DDI_SUCCESS) {
8017c478bd9Sstevel@tonic-gate maxrange = proplen / sizeof (struct iorange);
8027c478bd9Sstevel@tonic-gate /* remove the "used" I/O resources */
8037c478bd9Sstevel@tonic-gate for (i = 0; i < maxrange; i++) {
8047c478bd9Sstevel@tonic-gate bzero((caddr_t)&req, sizeof (req));
8057c478bd9Sstevel@tonic-gate req.ra_addr = (uint64_t)iorange[i].base;
8067c478bd9Sstevel@tonic-gate req.ra_len = (uint64_t)iorange[i].len;
8077c478bd9Sstevel@tonic-gate req.ra_flags = NDI_RA_ALLOC_SPECIFIED;
8087c478bd9Sstevel@tonic-gate (void) ndi_ra_alloc(usedpdip, &req, &retbase, &retlen,
8097c478bd9Sstevel@tonic-gate NDI_RA_TYPE_IO, 0);
8107c478bd9Sstevel@tonic-gate }
8117c478bd9Sstevel@tonic-gate
8127c478bd9Sstevel@tonic-gate kmem_free((caddr_t)iorange, proplen);
8137c478bd9Sstevel@tonic-gate }
8147c478bd9Sstevel@tonic-gate
8157c478bd9Sstevel@tonic-gate if (ndi_ra_map_setup(usedpdip, NDI_RA_TYPE_MEM) == NDI_FAILURE) {
8167c478bd9Sstevel@tonic-gate return (NDI_FAILURE);
8177c478bd9Sstevel@tonic-gate }
8187c478bd9Sstevel@tonic-gate /* initialize memory space where highest end base is 0xffffffff */
8197c478bd9Sstevel@tonic-gate /* note that length is highest addr + 1 since starts from 0 */
8207c478bd9Sstevel@tonic-gate (void) ndi_ra_free(usedpdip, 0, ((uint64_t)((uint32_t)~0)) + 1,
8217c478bd9Sstevel@tonic-gate NDI_RA_TYPE_MEM, 0);
8227c478bd9Sstevel@tonic-gate
823a3282898Scth if (ddi_getlongprop(DDI_DEV_T_ANY, used, DDI_PROP_DONTPASS,
8247c478bd9Sstevel@tonic-gate "device-memory", (caddr_t)&memrange, &proplen) == DDI_SUCCESS) {
8257c478bd9Sstevel@tonic-gate maxrange = proplen / sizeof (struct memrange);
8267c478bd9Sstevel@tonic-gate /* remove the "used" memory resources */
8277c478bd9Sstevel@tonic-gate for (i = 0; i < maxrange; i++) {
8287c478bd9Sstevel@tonic-gate bzero((caddr_t)&req, sizeof (req));
8297c478bd9Sstevel@tonic-gate req.ra_addr = (uint64_t)memrange[i].base;
8307c478bd9Sstevel@tonic-gate req.ra_len = (uint64_t)memrange[i].len;
8317c478bd9Sstevel@tonic-gate req.ra_flags = NDI_RA_ALLOC_SPECIFIED;
8327c478bd9Sstevel@tonic-gate (void) ndi_ra_alloc(usedpdip, &req, &retbase, &retlen,
8337c478bd9Sstevel@tonic-gate NDI_RA_TYPE_MEM, 0);
8347c478bd9Sstevel@tonic-gate }
8357c478bd9Sstevel@tonic-gate
8367c478bd9Sstevel@tonic-gate kmem_free((caddr_t)memrange, proplen);
8377c478bd9Sstevel@tonic-gate }
8387c478bd9Sstevel@tonic-gate
8397c478bd9Sstevel@tonic-gate if (ndi_ra_map_setup(usedpdip, NDI_RA_TYPE_INTR) == NDI_FAILURE) {
8407c478bd9Sstevel@tonic-gate return (NDI_FAILURE);
8417c478bd9Sstevel@tonic-gate }
8427c478bd9Sstevel@tonic-gate
8437c478bd9Sstevel@tonic-gate /* initialize the interrupt space */
8447c478bd9Sstevel@tonic-gate (void) ndi_ra_free(usedpdip, 0, 16, NDI_RA_TYPE_INTR, 0);
8457c478bd9Sstevel@tonic-gate
84686ef0a63SRichard Lowe #if defined(__x86)
8477c478bd9Sstevel@tonic-gate bzero(&req, sizeof (req));
8487c478bd9Sstevel@tonic-gate req.ra_addr = 2; /* 2 == 9 so never allow */
8497c478bd9Sstevel@tonic-gate req.ra_len = 1;
8507c478bd9Sstevel@tonic-gate req.ra_flags = NDI_RA_ALLOC_SPECIFIED;
8517c478bd9Sstevel@tonic-gate (void) ndi_ra_alloc(usedpdip, &req, &retbase, &retlen,
8527c478bd9Sstevel@tonic-gate NDI_RA_TYPE_INTR, 0);
8537c478bd9Sstevel@tonic-gate #endif
8547c478bd9Sstevel@tonic-gate
855a3282898Scth if (ddi_getlongprop(DDI_DEV_T_ANY, used, DDI_PROP_DONTPASS,
8567c478bd9Sstevel@tonic-gate "interrupts", (caddr_t)&irq, &proplen) == DDI_SUCCESS) {
8577c478bd9Sstevel@tonic-gate /* Initialize available interrupts by negating the used */
8587c478bd9Sstevel@tonic-gate len = (proplen / sizeof (uint32_t));
8597c478bd9Sstevel@tonic-gate for (i = 0; i < len; i++) {
8607c478bd9Sstevel@tonic-gate bzero((caddr_t)&req, sizeof (req));
8617c478bd9Sstevel@tonic-gate req.ra_addr = (uint64_t)irq[i];
8627c478bd9Sstevel@tonic-gate req.ra_len = 1;
8637c478bd9Sstevel@tonic-gate req.ra_flags = NDI_RA_ALLOC_SPECIFIED;
8647c478bd9Sstevel@tonic-gate (void) ndi_ra_alloc(usedpdip, &req, &retbase, &retlen,
8657c478bd9Sstevel@tonic-gate NDI_RA_TYPE_INTR, 0);
8667c478bd9Sstevel@tonic-gate }
8677c478bd9Sstevel@tonic-gate kmem_free((caddr_t)irq, proplen);
8687c478bd9Sstevel@tonic-gate }
8697c478bd9Sstevel@tonic-gate
8707c478bd9Sstevel@tonic-gate #ifdef BUSRA_DEBUG
8717c478bd9Sstevel@tonic-gate if (busra_debug) {
8727c478bd9Sstevel@tonic-gate (void) ra_dump_all(NULL, usedpdip);
8737c478bd9Sstevel@tonic-gate }
8747c478bd9Sstevel@tonic-gate #endif
8757c478bd9Sstevel@tonic-gate return (NDI_SUCCESS);
8767c478bd9Sstevel@tonic-gate
8777c478bd9Sstevel@tonic-gate }
8787c478bd9Sstevel@tonic-gate
8797c478bd9Sstevel@tonic-gate #ifdef BUSRA_DEBUG
8807c478bd9Sstevel@tonic-gate void
ra_dump_all(char * type,dev_info_t * dip)8817c478bd9Sstevel@tonic-gate ra_dump_all(char *type, dev_info_t *dip)
8827c478bd9Sstevel@tonic-gate {
8837c478bd9Sstevel@tonic-gate
8847c478bd9Sstevel@tonic-gate struct ra_type_map *typemap;
8857c478bd9Sstevel@tonic-gate struct ra_dip_type *dipmap;
8867c478bd9Sstevel@tonic-gate struct ra_resource *res;
8877c478bd9Sstevel@tonic-gate
8887c478bd9Sstevel@tonic-gate typemap = (struct ra_type_map *)ra_map_list_head;
8897c478bd9Sstevel@tonic-gate
8907c478bd9Sstevel@tonic-gate for (; typemap != NULL; typemap = typemap->ra_next) {
8917c478bd9Sstevel@tonic-gate if (type != NULL) {
8927c478bd9Sstevel@tonic-gate if (strcmp(typemap->type, type) != 0)
8937c478bd9Sstevel@tonic-gate continue;
8947c478bd9Sstevel@tonic-gate }
8957c478bd9Sstevel@tonic-gate cmn_err(CE_CONT, "type is %s\n", typemap->type);
8967c478bd9Sstevel@tonic-gate for (dipmap = typemap->ra_dip_list; dipmap != NULL;
89726947304SEvan Yan dipmap = dipmap->ra_next) {
8987c478bd9Sstevel@tonic-gate if (dip != NULL) {
8997c478bd9Sstevel@tonic-gate if ((dipmap->ra_dip) != dip)
9007c478bd9Sstevel@tonic-gate continue;
9017c478bd9Sstevel@tonic-gate }
9027c478bd9Sstevel@tonic-gate cmn_err(CE_CONT, " dip is %p\n",
9037c478bd9Sstevel@tonic-gate (void *)dipmap->ra_dip);
9047c478bd9Sstevel@tonic-gate for (res = dipmap->ra_rangeset; res != NULL;
90526947304SEvan Yan res = res->ra_next) {
9067c478bd9Sstevel@tonic-gate cmn_err(CE_CONT, "\t range is %" PRIx64
9077c478bd9Sstevel@tonic-gate " %" PRIx64 "\n", res->ra_base,
9087c478bd9Sstevel@tonic-gate res->ra_len);
9097c478bd9Sstevel@tonic-gate }
9107c478bd9Sstevel@tonic-gate if (dip != NULL)
9117c478bd9Sstevel@tonic-gate break;
9127c478bd9Sstevel@tonic-gate }
9137c478bd9Sstevel@tonic-gate if (type != NULL)
9147c478bd9Sstevel@tonic-gate break;
9157c478bd9Sstevel@tonic-gate }
9167c478bd9Sstevel@tonic-gate }
9177c478bd9Sstevel@tonic-gate #endif
9187c478bd9Sstevel@tonic-gate
9197c478bd9Sstevel@tonic-gate struct bus_range { /* 1275 "bus-range" property definition */
9207c478bd9Sstevel@tonic-gate uint32_t lo;
9217c478bd9Sstevel@tonic-gate uint32_t hi;
9227c478bd9Sstevel@tonic-gate } pci_bus_range;
9237c478bd9Sstevel@tonic-gate
9247c478bd9Sstevel@tonic-gate struct busnum_ctrl {
9257c478bd9Sstevel@tonic-gate int rv;
9267c478bd9Sstevel@tonic-gate dev_info_t *dip;
9277c478bd9Sstevel@tonic-gate struct bus_range *range;
9287c478bd9Sstevel@tonic-gate };
9297c478bd9Sstevel@tonic-gate
9307c478bd9Sstevel@tonic-gate
9317c478bd9Sstevel@tonic-gate /*
9327c478bd9Sstevel@tonic-gate * Setup resource map for the pci bus node based on the "available"
9337c478bd9Sstevel@tonic-gate * property and "bus-range" property.
9347c478bd9Sstevel@tonic-gate */
9357c478bd9Sstevel@tonic-gate int
pci_resource_setup(dev_info_t * dip)9367c478bd9Sstevel@tonic-gate pci_resource_setup(dev_info_t *dip)
9377c478bd9Sstevel@tonic-gate {
9387c478bd9Sstevel@tonic-gate pci_regspec_t *regs;
9397c478bd9Sstevel@tonic-gate int rlen, rcount, i;
9407c478bd9Sstevel@tonic-gate char bus_type[16] = "(unknown)";
9417c478bd9Sstevel@tonic-gate int len;
9427c478bd9Sstevel@tonic-gate struct busnum_ctrl ctrl;
9437c478bd9Sstevel@tonic-gate int rval = NDI_SUCCESS;
9447c478bd9Sstevel@tonic-gate
9457c478bd9Sstevel@tonic-gate /*
9467c478bd9Sstevel@tonic-gate * If this is a pci bus node then look for "available" property
9477c478bd9Sstevel@tonic-gate * to find the available resources on this bus.
9487c478bd9Sstevel@tonic-gate */
9497c478bd9Sstevel@tonic-gate len = sizeof (bus_type);
9507c478bd9Sstevel@tonic-gate if (ddi_prop_op(DDI_DEV_T_ANY, dip, PROP_LEN_AND_VAL_BUF,
9517c478bd9Sstevel@tonic-gate DDI_PROP_CANSLEEP | DDI_PROP_DONTPASS, "device_type",
9527c478bd9Sstevel@tonic-gate (caddr_t)&bus_type, &len) != DDI_SUCCESS)
9537c478bd9Sstevel@tonic-gate return (NDI_FAILURE);
9547c478bd9Sstevel@tonic-gate
95570025d76Sjohnny /* it is not a pci/pci-ex bus type */
956c9f965e3Set if ((strcmp(bus_type, "pci") != 0) && (strcmp(bus_type, "pciex") != 0))
9577c478bd9Sstevel@tonic-gate return (NDI_FAILURE);
9587c478bd9Sstevel@tonic-gate
9597c478bd9Sstevel@tonic-gate /*
9607c478bd9Sstevel@tonic-gate * The pci-hotplug project addresses adding the call
9617c478bd9Sstevel@tonic-gate * to pci_resource_setup from pci nexus driver.
9627c478bd9Sstevel@tonic-gate * However that project would initially be only for x86,
9637c478bd9Sstevel@tonic-gate * so for sparc pcmcia-pci support we still need to call
9647c478bd9Sstevel@tonic-gate * pci_resource_setup in pcic driver. Once all pci nexus drivers
9657c478bd9Sstevel@tonic-gate * are updated to call pci_resource_setup this portion of the
9667c478bd9Sstevel@tonic-gate * code would really become an assert to make sure this
9677c478bd9Sstevel@tonic-gate * function is not called for the same dip twice.
9687c478bd9Sstevel@tonic-gate */
96926947304SEvan Yan /*
97026947304SEvan Yan * Another user for the check below is hotplug PCI/PCIe bridges.
97126947304SEvan Yan *
97226947304SEvan Yan * For PCI/PCIE devices under a PCIE hierarchy, ndi_ra_alloc/free
97326947304SEvan Yan * will update the devinfo node's "available" property, to reflect
97426947304SEvan Yan * the fact that a piece of resource has been removed/added to
97526947304SEvan Yan * a devinfo node.
97626947304SEvan Yan * During probe of a new PCI bridge in the hotplug case, PCI
97726947304SEvan Yan * configurator firstly allocates maximum MEM/IO from its parent,
97826947304SEvan Yan * then calls ndi_ra_free() to use these resources to setup busra
97926947304SEvan Yan * pool for the new bridge, as well as adding these resources to
98026947304SEvan Yan * the "available" property of the new devinfo node. Then configu-
98126947304SEvan Yan * rator will attach driver for the bridge before probing its
98226947304SEvan Yan * children, and the bridge driver will then initialize its hotplug
98326947304SEvan Yan * contollers (if it supports hotplug) and HPC driver will call
98426947304SEvan Yan * this function to setup the busra pool, but the resource pool
98526947304SEvan Yan * has already been setup at the first of pcicfg_probe_bridge(),
98626947304SEvan Yan * thus we need the check below to return directly in this case.
98726947304SEvan Yan * Otherwise the ndi_ra_free() below will see overlapping resources.
98826947304SEvan Yan */
9897c478bd9Sstevel@tonic-gate {
9907c478bd9Sstevel@tonic-gate if (ra_map_exist(dip, NDI_RA_TYPE_MEM) == NDI_SUCCESS) {
9917c478bd9Sstevel@tonic-gate return (NDI_FAILURE);
9927c478bd9Sstevel@tonic-gate }
9937c478bd9Sstevel@tonic-gate }
9947c478bd9Sstevel@tonic-gate
9957c478bd9Sstevel@tonic-gate
99670025d76Sjohnny /*
99770025d76Sjohnny * Create empty resource maps first.
99870025d76Sjohnny *
99970025d76Sjohnny * NOTE: If all the allocated resources are already assigned to
100070025d76Sjohnny * device(s) in the hot plug slot then "available" property may not
100170025d76Sjohnny * be present. But, subsequent hot plug operation may unconfigure
100270025d76Sjohnny * the device in the slot and try to free up it's resources. So,
100370025d76Sjohnny * at the minimum we should create empty maps here.
100470025d76Sjohnny */
10057c478bd9Sstevel@tonic-gate if (ndi_ra_map_setup(dip, NDI_RA_TYPE_MEM) == NDI_FAILURE) {
10067c478bd9Sstevel@tonic-gate return (NDI_FAILURE);
10077c478bd9Sstevel@tonic-gate }
10087c478bd9Sstevel@tonic-gate
10097c478bd9Sstevel@tonic-gate if (ndi_ra_map_setup(dip, NDI_RA_TYPE_IO) == NDI_FAILURE) {
10107c478bd9Sstevel@tonic-gate return (NDI_FAILURE);
10117c478bd9Sstevel@tonic-gate }
10127c478bd9Sstevel@tonic-gate
10137c478bd9Sstevel@tonic-gate if (ndi_ra_map_setup(dip, NDI_RA_TYPE_PCI_BUSNUM) == NDI_FAILURE) {
10147c478bd9Sstevel@tonic-gate return (NDI_FAILURE);
10157c478bd9Sstevel@tonic-gate }
10167c478bd9Sstevel@tonic-gate
10177c478bd9Sstevel@tonic-gate if (ndi_ra_map_setup(dip, NDI_RA_TYPE_PCI_PREFETCH_MEM) ==
10187c478bd9Sstevel@tonic-gate NDI_FAILURE) {
10197c478bd9Sstevel@tonic-gate return (NDI_FAILURE);
10207c478bd9Sstevel@tonic-gate }
10217c478bd9Sstevel@tonic-gate
102270025d76Sjohnny /* read the "available" property if it is available */
102370025d76Sjohnny if (ddi_getlongprop(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS,
102470025d76Sjohnny "available", (caddr_t)®s, &rlen) == DDI_SUCCESS) {
102526947304SEvan Yan /*
102626947304SEvan Yan * Remove "available" property as the entries will be
102726947304SEvan Yan * re-created in ndi_ra_free() below, note prom based
102826947304SEvan Yan * property will not be removed. But in ndi_ra_free()
102926947304SEvan Yan * we'll be creating non prom based property entries.
103026947304SEvan Yan */
103126947304SEvan Yan (void) ndi_prop_remove(DDI_DEV_T_NONE, dip, "available");
103270025d76Sjohnny /*
103370025d76Sjohnny * create the available resource list for both memory and
103470025d76Sjohnny * io space
103570025d76Sjohnny */
103670025d76Sjohnny rcount = rlen / sizeof (pci_regspec_t);
103770025d76Sjohnny for (i = 0; i < rcount; i++) {
103826947304SEvan Yan switch (PCI_REG_ADDR_G(regs[i].pci_phys_hi)) {
103926947304SEvan Yan case PCI_REG_ADDR_G(PCI_ADDR_MEM32):
104026947304SEvan Yan (void) ndi_ra_free(dip,
104126947304SEvan Yan (uint64_t)regs[i].pci_phys_low,
104226947304SEvan Yan (uint64_t)regs[i].pci_size_low,
104326947304SEvan Yan (regs[i].pci_phys_hi & PCI_REG_PF_M) ?
104426947304SEvan Yan NDI_RA_TYPE_PCI_PREFETCH_MEM :
104526947304SEvan Yan NDI_RA_TYPE_MEM,
104626947304SEvan Yan 0);
104726947304SEvan Yan break;
104826947304SEvan Yan case PCI_REG_ADDR_G(PCI_ADDR_MEM64):
104926947304SEvan Yan (void) ndi_ra_free(dip,
105026947304SEvan Yan ((uint64_t)(regs[i].pci_phys_mid) << 32) |
105126947304SEvan Yan ((uint64_t)(regs[i].pci_phys_low)),
105226947304SEvan Yan ((uint64_t)(regs[i].pci_size_hi) << 32) |
105326947304SEvan Yan ((uint64_t)(regs[i].pci_size_low)),
105426947304SEvan Yan (regs[i].pci_phys_hi & PCI_REG_PF_M) ?
105526947304SEvan Yan NDI_RA_TYPE_PCI_PREFETCH_MEM :
105626947304SEvan Yan NDI_RA_TYPE_MEM,
105726947304SEvan Yan 0);
105826947304SEvan Yan break;
105926947304SEvan Yan case PCI_REG_ADDR_G(PCI_ADDR_IO):
106026947304SEvan Yan (void) ndi_ra_free(dip,
106126947304SEvan Yan (uint64_t)regs[i].pci_phys_low,
106226947304SEvan Yan (uint64_t)regs[i].pci_size_low,
106326947304SEvan Yan NDI_RA_TYPE_IO,
106426947304SEvan Yan 0);
106526947304SEvan Yan break;
106626947304SEvan Yan case PCI_REG_ADDR_G(PCI_ADDR_CONFIG):
106726947304SEvan Yan break;
106826947304SEvan Yan default:
106926947304SEvan Yan cmn_err(CE_WARN,
107026947304SEvan Yan "pci_resource_setup: bad addr type: %x\n",
107126947304SEvan Yan PCI_REG_ADDR_G(regs[i].pci_phys_hi));
107226947304SEvan Yan break;
107326947304SEvan Yan }
10747c478bd9Sstevel@tonic-gate }
1075ae115bc7Smrj kmem_free(regs, rlen);
10767c478bd9Sstevel@tonic-gate }
10777c478bd9Sstevel@tonic-gate
10787c478bd9Sstevel@tonic-gate /*
107970025d76Sjohnny * update resource map for available bus numbers if the node
10807c478bd9Sstevel@tonic-gate * has available-bus-range or bus-range property.
10817c478bd9Sstevel@tonic-gate */
10827c478bd9Sstevel@tonic-gate len = sizeof (struct bus_range);
1083a3282898Scth if (ddi_getlongprop_buf(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS,
10847c478bd9Sstevel@tonic-gate "available-bus-range", (caddr_t)&pci_bus_range, &len) ==
10857c478bd9Sstevel@tonic-gate DDI_SUCCESS) {
10867c478bd9Sstevel@tonic-gate /*
10877c478bd9Sstevel@tonic-gate * Add bus numbers in the range to the free list.
10887c478bd9Sstevel@tonic-gate */
10897c478bd9Sstevel@tonic-gate (void) ndi_ra_free(dip, (uint64_t)pci_bus_range.lo,
10907c478bd9Sstevel@tonic-gate (uint64_t)pci_bus_range.hi - (uint64_t)pci_bus_range.lo +
10917c478bd9Sstevel@tonic-gate 1, NDI_RA_TYPE_PCI_BUSNUM, 0);
10927c478bd9Sstevel@tonic-gate } else {
10937c478bd9Sstevel@tonic-gate /*
10947c478bd9Sstevel@tonic-gate * We don't have an available-bus-range property. If, instead,
10957c478bd9Sstevel@tonic-gate * we have a bus-range property we add all the bus numbers
10967c478bd9Sstevel@tonic-gate * in that range to the free list but we must then scan
10977c478bd9Sstevel@tonic-gate * for pci-pci bridges on this bus to find out the if there
10987c478bd9Sstevel@tonic-gate * are any of those bus numbers already in use. If so, we can
10997c478bd9Sstevel@tonic-gate * reclaim them.
11007c478bd9Sstevel@tonic-gate */
11017c478bd9Sstevel@tonic-gate len = sizeof (struct bus_range);
1102a3282898Scth if (ddi_getlongprop_buf(DDI_DEV_T_ANY, dip,
11037c478bd9Sstevel@tonic-gate DDI_PROP_DONTPASS, "bus-range", (caddr_t)&pci_bus_range,
11047c478bd9Sstevel@tonic-gate &len) == DDI_SUCCESS) {
11057c478bd9Sstevel@tonic-gate if (pci_bus_range.lo != pci_bus_range.hi) {
11067c478bd9Sstevel@tonic-gate /*
11077c478bd9Sstevel@tonic-gate * Add bus numbers other than the secondary
11087c478bd9Sstevel@tonic-gate * bus number to the free list.
11097c478bd9Sstevel@tonic-gate */
11107c478bd9Sstevel@tonic-gate (void) ndi_ra_free(dip,
11117c478bd9Sstevel@tonic-gate (uint64_t)pci_bus_range.lo + 1,
11127c478bd9Sstevel@tonic-gate (uint64_t)pci_bus_range.hi -
11137c478bd9Sstevel@tonic-gate (uint64_t)pci_bus_range.lo,
11147c478bd9Sstevel@tonic-gate NDI_RA_TYPE_PCI_BUSNUM, 0);
11157c478bd9Sstevel@tonic-gate
11167c478bd9Sstevel@tonic-gate /* scan for pci-pci bridges */
11177c478bd9Sstevel@tonic-gate ctrl.rv = DDI_SUCCESS;
11187c478bd9Sstevel@tonic-gate ctrl.dip = dip;
11197c478bd9Sstevel@tonic-gate ctrl.range = &pci_bus_range;
1120*3fe80ca4SDan Cross ndi_devi_enter(dip);
11217c478bd9Sstevel@tonic-gate ddi_walk_devs(ddi_get_child(dip),
11227c478bd9Sstevel@tonic-gate claim_pci_busnum, (void *)&ctrl);
1123*3fe80ca4SDan Cross ndi_devi_exit(dip);
11247c478bd9Sstevel@tonic-gate if (ctrl.rv != DDI_SUCCESS) {
11257c478bd9Sstevel@tonic-gate /* failed to create the map */
11267c478bd9Sstevel@tonic-gate (void) ndi_ra_map_destroy(dip,
11277c478bd9Sstevel@tonic-gate NDI_RA_TYPE_PCI_BUSNUM);
11287c478bd9Sstevel@tonic-gate rval = NDI_FAILURE;
11297c478bd9Sstevel@tonic-gate }
11307c478bd9Sstevel@tonic-gate }
11317c478bd9Sstevel@tonic-gate }
11327c478bd9Sstevel@tonic-gate }
11337c478bd9Sstevel@tonic-gate
11347c478bd9Sstevel@tonic-gate #ifdef BUSRA_DEBUG
11357c478bd9Sstevel@tonic-gate if (busra_debug) {
11367c478bd9Sstevel@tonic-gate (void) ra_dump_all(NULL, dip);
11377c478bd9Sstevel@tonic-gate }
11387c478bd9Sstevel@tonic-gate #endif
11397c478bd9Sstevel@tonic-gate
11407c478bd9Sstevel@tonic-gate return (rval);
11417c478bd9Sstevel@tonic-gate }
11427c478bd9Sstevel@tonic-gate
11437c478bd9Sstevel@tonic-gate /*
11447c478bd9Sstevel@tonic-gate * If the device is a PCI bus device (i.e bus-range property exists) then
11457c478bd9Sstevel@tonic-gate * claim the bus numbers used by the device from the specified bus
11467c478bd9Sstevel@tonic-gate * resource map.
11477c478bd9Sstevel@tonic-gate */
11487c478bd9Sstevel@tonic-gate static int
claim_pci_busnum(dev_info_t * dip,void * arg)11497c478bd9Sstevel@tonic-gate claim_pci_busnum(dev_info_t *dip, void *arg)
11507c478bd9Sstevel@tonic-gate {
11517c478bd9Sstevel@tonic-gate struct bus_range pci_bus_range;
11527c478bd9Sstevel@tonic-gate struct busnum_ctrl *ctrl;
11537c478bd9Sstevel@tonic-gate ndi_ra_request_t req;
11547c478bd9Sstevel@tonic-gate char bus_type[16] = "(unknown)";
11557c478bd9Sstevel@tonic-gate int len;
11567c478bd9Sstevel@tonic-gate uint64_t base;
11577c478bd9Sstevel@tonic-gate uint64_t retlen;
11587c478bd9Sstevel@tonic-gate
11597c478bd9Sstevel@tonic-gate ctrl = (struct busnum_ctrl *)arg;
11607c478bd9Sstevel@tonic-gate
11617c478bd9Sstevel@tonic-gate /* check if this is a PCI bus node */
11627c478bd9Sstevel@tonic-gate len = sizeof (bus_type);
11637c478bd9Sstevel@tonic-gate if (ddi_prop_op(DDI_DEV_T_ANY, dip, PROP_LEN_AND_VAL_BUF,
11647c478bd9Sstevel@tonic-gate DDI_PROP_CANSLEEP | DDI_PROP_DONTPASS, "device_type",
11657c478bd9Sstevel@tonic-gate (caddr_t)&bus_type, &len) != DDI_SUCCESS)
11667c478bd9Sstevel@tonic-gate return (DDI_WALK_PRUNECHILD);
11677c478bd9Sstevel@tonic-gate
116870025d76Sjohnny /* it is not a pci/pci-ex bus type */
1169c9f965e3Set if ((strcmp(bus_type, "pci") != 0) && (strcmp(bus_type, "pciex") != 0))
11707c478bd9Sstevel@tonic-gate return (DDI_WALK_PRUNECHILD);
11717c478bd9Sstevel@tonic-gate
11727c478bd9Sstevel@tonic-gate /* look for the bus-range property */
11737c478bd9Sstevel@tonic-gate len = sizeof (struct bus_range);
1174a3282898Scth if (ddi_getlongprop_buf(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS,
11757c478bd9Sstevel@tonic-gate "bus-range", (caddr_t)&pci_bus_range, &len) == DDI_SUCCESS) {
11767c478bd9Sstevel@tonic-gate if ((pci_bus_range.lo >= ctrl->range->lo) &&
11777c478bd9Sstevel@tonic-gate (pci_bus_range.hi <= ctrl->range->hi)) {
11787c478bd9Sstevel@tonic-gate
11797c478bd9Sstevel@tonic-gate /* claim the bus range from the bus resource map */
11807c478bd9Sstevel@tonic-gate bzero((caddr_t)&req, sizeof (req));
11817c478bd9Sstevel@tonic-gate req.ra_addr = (uint64_t)pci_bus_range.lo;
11827c478bd9Sstevel@tonic-gate req.ra_flags |= NDI_RA_ALLOC_SPECIFIED;
11837c478bd9Sstevel@tonic-gate req.ra_len = (uint64_t)pci_bus_range.hi -
11847c478bd9Sstevel@tonic-gate (uint64_t)pci_bus_range.lo + 1;
11857c478bd9Sstevel@tonic-gate if (ndi_ra_alloc(ctrl->dip, &req, &base, &retlen,
11867c478bd9Sstevel@tonic-gate NDI_RA_TYPE_PCI_BUSNUM, 0) == NDI_SUCCESS)
11877c478bd9Sstevel@tonic-gate return (DDI_WALK_PRUNECHILD);
11887c478bd9Sstevel@tonic-gate }
11897c478bd9Sstevel@tonic-gate }
11907c478bd9Sstevel@tonic-gate
11917c478bd9Sstevel@tonic-gate /*
11927c478bd9Sstevel@tonic-gate * Error return.
11937c478bd9Sstevel@tonic-gate */
11947c478bd9Sstevel@tonic-gate ctrl->rv = DDI_FAILURE;
11957c478bd9Sstevel@tonic-gate return (DDI_WALK_TERMINATE);
11967c478bd9Sstevel@tonic-gate }
11977c478bd9Sstevel@tonic-gate
11987c478bd9Sstevel@tonic-gate void
pci_resource_destroy(dev_info_t * dip)11997c478bd9Sstevel@tonic-gate pci_resource_destroy(dev_info_t *dip)
12007c478bd9Sstevel@tonic-gate {
12017c478bd9Sstevel@tonic-gate (void) ndi_ra_map_destroy(dip, NDI_RA_TYPE_IO);
12027c478bd9Sstevel@tonic-gate
12037c478bd9Sstevel@tonic-gate (void) ndi_ra_map_destroy(dip, NDI_RA_TYPE_MEM);
12047c478bd9Sstevel@tonic-gate
12057c478bd9Sstevel@tonic-gate (void) ndi_ra_map_destroy(dip, NDI_RA_TYPE_PCI_BUSNUM);
12067c478bd9Sstevel@tonic-gate
12077c478bd9Sstevel@tonic-gate (void) ndi_ra_map_destroy(dip, NDI_RA_TYPE_PCI_PREFETCH_MEM);
12087c478bd9Sstevel@tonic-gate }
12097c478bd9Sstevel@tonic-gate
12107c478bd9Sstevel@tonic-gate
12117c478bd9Sstevel@tonic-gate int
pci_resource_setup_avail(dev_info_t * dip,pci_regspec_t * avail_p,int entries)12127c478bd9Sstevel@tonic-gate pci_resource_setup_avail(dev_info_t *dip, pci_regspec_t *avail_p, int entries)
12137c478bd9Sstevel@tonic-gate {
12147c478bd9Sstevel@tonic-gate int i;
12157c478bd9Sstevel@tonic-gate
12167c478bd9Sstevel@tonic-gate if (ndi_ra_map_setup(dip, NDI_RA_TYPE_MEM) == NDI_FAILURE)
12177c478bd9Sstevel@tonic-gate return (NDI_FAILURE);
12187c478bd9Sstevel@tonic-gate if (ndi_ra_map_setup(dip, NDI_RA_TYPE_IO) == NDI_FAILURE)
12197c478bd9Sstevel@tonic-gate return (NDI_FAILURE);
12207c478bd9Sstevel@tonic-gate if (ndi_ra_map_setup(dip, NDI_RA_TYPE_PCI_PREFETCH_MEM) == NDI_FAILURE)
12217c478bd9Sstevel@tonic-gate return (NDI_FAILURE);
12227c478bd9Sstevel@tonic-gate
12237c478bd9Sstevel@tonic-gate /* for each entry in the PCI "available" property */
12247c478bd9Sstevel@tonic-gate for (i = 0; i < entries; i++, avail_p++) {
12257c478bd9Sstevel@tonic-gate if (avail_p->pci_phys_hi == -1u)
12267c478bd9Sstevel@tonic-gate goto err;
12277c478bd9Sstevel@tonic-gate
12287c478bd9Sstevel@tonic-gate switch (PCI_REG_ADDR_G(avail_p->pci_phys_hi)) {
12297c478bd9Sstevel@tonic-gate case PCI_REG_ADDR_G(PCI_ADDR_MEM32): {
123026947304SEvan Yan (void) ndi_ra_free(dip, (uint64_t)avail_p->pci_phys_low,
123126947304SEvan Yan (uint64_t)avail_p->pci_size_low,
123226947304SEvan Yan (avail_p->pci_phys_hi & PCI_REG_PF_M) ?
123326947304SEvan Yan NDI_RA_TYPE_PCI_PREFETCH_MEM : NDI_RA_TYPE_MEM,
123426947304SEvan Yan 0);
12357c478bd9Sstevel@tonic-gate }
12367c478bd9Sstevel@tonic-gate break;
12377c478bd9Sstevel@tonic-gate case PCI_REG_ADDR_G(PCI_ADDR_IO):
123826947304SEvan Yan (void) ndi_ra_free(dip, (uint64_t)avail_p->pci_phys_low,
123926947304SEvan Yan (uint64_t)avail_p->pci_size_low, NDI_RA_TYPE_IO, 0);
12407c478bd9Sstevel@tonic-gate break;
12417c478bd9Sstevel@tonic-gate default:
12427c478bd9Sstevel@tonic-gate goto err;
12437c478bd9Sstevel@tonic-gate }
12447c478bd9Sstevel@tonic-gate }
12457c478bd9Sstevel@tonic-gate #ifdef BUSRA_DEBUG
12467c478bd9Sstevel@tonic-gate if (busra_debug) {
12477c478bd9Sstevel@tonic-gate (void) ra_dump_all(NULL, dip);
12487c478bd9Sstevel@tonic-gate }
12497c478bd9Sstevel@tonic-gate #endif
12507c478bd9Sstevel@tonic-gate return (NDI_SUCCESS);
12517c478bd9Sstevel@tonic-gate
12527c478bd9Sstevel@tonic-gate err:
12537c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "pci_resource_setup_avail: bad entry[%d]=%x\n",
125426947304SEvan Yan i, avail_p->pci_phys_hi);
12557c478bd9Sstevel@tonic-gate return (NDI_FAILURE);
12567c478bd9Sstevel@tonic-gate }
125726947304SEvan Yan
125826947304SEvan Yan /*
125926947304SEvan Yan * Return true if the devinfo node resides on PCI or PCI Express bus,
126026947304SEvan Yan * sitting in a PCI Express hierarchy.
126126947304SEvan Yan */
126226947304SEvan Yan static boolean_t
is_pcie_fabric(dev_info_t * dip)126326947304SEvan Yan is_pcie_fabric(dev_info_t *dip)
126426947304SEvan Yan {
126526947304SEvan Yan dev_info_t *root = ddi_root_node();
126626947304SEvan Yan dev_info_t *pdip;
126726947304SEvan Yan boolean_t found = B_FALSE;
126826947304SEvan Yan char *bus;
126926947304SEvan Yan
127026947304SEvan Yan /*
127126947304SEvan Yan * Is this pci/pcie ?
127226947304SEvan Yan */
127326947304SEvan Yan if (ddi_prop_lookup_string(DDI_DEV_T_ANY, dip,
127426947304SEvan Yan DDI_PROP_DONTPASS, "device_type", &bus) !=
127526947304SEvan Yan DDI_PROP_SUCCESS) {
127626947304SEvan Yan DEBUGPRT(CE_WARN, "is_pcie_fabric: cannot find "
127726947304SEvan Yan "\"device_type\" property for dip %p\n", (void *)dip);
127826947304SEvan Yan return (B_FALSE);
127926947304SEvan Yan }
128026947304SEvan Yan
128126947304SEvan Yan if (strcmp(bus, "pciex") == 0) {
128226947304SEvan Yan /* pcie bus, done */
128326947304SEvan Yan ddi_prop_free(bus);
128426947304SEvan Yan return (B_TRUE);
128526947304SEvan Yan } else if (strcmp(bus, "pci") == 0) {
128626947304SEvan Yan /*
128726947304SEvan Yan * pci bus, fall through to check if it resides in
128826947304SEvan Yan * a pcie hierarchy.
128926947304SEvan Yan */
129026947304SEvan Yan ddi_prop_free(bus);
129126947304SEvan Yan } else {
129226947304SEvan Yan /* other bus, return failure */
129326947304SEvan Yan ddi_prop_free(bus);
129426947304SEvan Yan return (B_FALSE);
129526947304SEvan Yan }
129626947304SEvan Yan
129726947304SEvan Yan /*
129826947304SEvan Yan * Does this device reside in a pcie fabric ?
129926947304SEvan Yan */
130026947304SEvan Yan for (pdip = ddi_get_parent(dip); pdip && (pdip != root) &&
130126947304SEvan Yan !found; pdip = ddi_get_parent(pdip)) {
130226947304SEvan Yan if (ddi_prop_lookup_string(DDI_DEV_T_ANY, pdip,
130326947304SEvan Yan DDI_PROP_DONTPASS, "device_type", &bus) !=
130426947304SEvan Yan DDI_PROP_SUCCESS)
130526947304SEvan Yan break;
130626947304SEvan Yan
130726947304SEvan Yan if (strcmp(bus, "pciex") == 0)
130826947304SEvan Yan found = B_TRUE;
130926947304SEvan Yan
131026947304SEvan Yan ddi_prop_free(bus);
131126947304SEvan Yan }
131226947304SEvan Yan
131326947304SEvan Yan return (found);
131426947304SEvan Yan }
131526947304SEvan Yan
131626947304SEvan Yan /*
131726947304SEvan Yan * Remove a piece of IO/MEM resource from "available" property of 'dip'.
131826947304SEvan Yan */
131926947304SEvan Yan static int
pci_get_available_prop(dev_info_t * dip,uint64_t base,uint64_t len,char * busra_type)132026947304SEvan Yan pci_get_available_prop(dev_info_t *dip, uint64_t base, uint64_t len,
132126947304SEvan Yan char *busra_type)
132226947304SEvan Yan {
132326947304SEvan Yan pci_regspec_t *regs, *newregs;
132426947304SEvan Yan uint_t status;
132526947304SEvan Yan int rlen, rcount;
132626947304SEvan Yan int i, j, k;
132726947304SEvan Yan uint64_t dlen;
132826947304SEvan Yan boolean_t found = B_FALSE;
132926947304SEvan Yan uint32_t type;
133026947304SEvan Yan
133126947304SEvan Yan /* check if we're manipulating MEM/IO resource */
133226947304SEvan Yan if ((type = pci_type_ra2pci(busra_type)) == PCI_ADDR_TYPE_INVAL)
133326947304SEvan Yan return (DDI_SUCCESS);
133426947304SEvan Yan
133526947304SEvan Yan /* check if dip is a pci/pcie device resides in a pcie fabric */
133626947304SEvan Yan if (!is_pcie_fabric(dip))
133726947304SEvan Yan return (DDI_SUCCESS);
133826947304SEvan Yan
133926947304SEvan Yan status = ddi_getlongprop(DDI_DEV_T_ANY, dip,
134026947304SEvan Yan DDI_PROP_DONTPASS | DDI_PROP_NOTPROM,
134126947304SEvan Yan "available", (caddr_t)®s, &rlen);
134226947304SEvan Yan
134326947304SEvan Yan ASSERT(status == DDI_SUCCESS);
134426947304SEvan Yan if (status != DDI_SUCCESS)
134526947304SEvan Yan return (status);
134626947304SEvan Yan
134726947304SEvan Yan /*
134826947304SEvan Yan * The updated "available" property will at most have one more entry
134926947304SEvan Yan * than existing one (when the requested range is in the middle of
135026947304SEvan Yan * the matched property entry)
135126947304SEvan Yan */
135226947304SEvan Yan newregs = kmem_alloc(rlen + sizeof (pci_regspec_t), KM_SLEEP);
135326947304SEvan Yan
135426947304SEvan Yan rcount = rlen / sizeof (pci_regspec_t);
135526947304SEvan Yan for (i = 0, j = 0; i < rcount; i++) {
135626947304SEvan Yan if (type == (regs[i].pci_phys_hi & PCI_ADDR_TYPE_MASK)) {
135726947304SEvan Yan uint64_t range_base, range_len;
135826947304SEvan Yan
135926947304SEvan Yan range_base = ((uint64_t)(regs[i].pci_phys_mid) << 32) |
136026947304SEvan Yan ((uint64_t)(regs[i].pci_phys_low));
136126947304SEvan Yan range_len = ((uint64_t)(regs[i].pci_size_hi) << 32) |
136226947304SEvan Yan ((uint64_t)(regs[i].pci_size_low));
136326947304SEvan Yan
136426947304SEvan Yan if ((base < range_base) ||
136526947304SEvan Yan (base + len > range_base + range_len)) {
136626947304SEvan Yan /*
136726947304SEvan Yan * not a match, copy the entry
136826947304SEvan Yan */
136926947304SEvan Yan goto copy_entry;
137026947304SEvan Yan }
137126947304SEvan Yan
137226947304SEvan Yan /*
137326947304SEvan Yan * range_base base base+len range_base
137426947304SEvan Yan * +range_len
137526947304SEvan Yan * +------------+-----------+----------+
137626947304SEvan Yan * | |///////////| |
137726947304SEvan Yan * +------------+-----------+----------+
137826947304SEvan Yan */
137926947304SEvan Yan /*
138026947304SEvan Yan * Found a match, remove the range out of this entry.
138126947304SEvan Yan */
138226947304SEvan Yan found = B_TRUE;
138326947304SEvan Yan
138426947304SEvan Yan dlen = base - range_base;
138526947304SEvan Yan if (dlen != 0) {
138626947304SEvan Yan newregs[j].pci_phys_hi = regs[i].pci_phys_hi;
138726947304SEvan Yan newregs[j].pci_phys_mid =
138826947304SEvan Yan (uint32_t)(range_base >> 32);
138926947304SEvan Yan newregs[j].pci_phys_low =
139026947304SEvan Yan (uint32_t)(range_base);
139126947304SEvan Yan newregs[j].pci_size_hi = (uint32_t)(dlen >> 32);
139226947304SEvan Yan newregs[j].pci_size_low = (uint32_t)dlen;
139326947304SEvan Yan j++;
139426947304SEvan Yan }
139526947304SEvan Yan
139626947304SEvan Yan dlen = (range_base + range_len) - (base + len);
139726947304SEvan Yan if (dlen != 0) {
139826947304SEvan Yan newregs[j].pci_phys_hi = regs[i].pci_phys_hi;
139926947304SEvan Yan newregs[j].pci_phys_mid =
140026947304SEvan Yan (uint32_t)((base + len)>> 32);
140126947304SEvan Yan newregs[j].pci_phys_low =
140226947304SEvan Yan (uint32_t)(base + len);
140326947304SEvan Yan newregs[j].pci_size_hi = (uint32_t)(dlen >> 32);
140426947304SEvan Yan newregs[j].pci_size_low = (uint32_t)dlen;
140526947304SEvan Yan j++;
140626947304SEvan Yan }
140726947304SEvan Yan
140826947304SEvan Yan /*
140926947304SEvan Yan * We've allocated the resource from the matched
141026947304SEvan Yan * entry, almost finished but still need to copy
141126947304SEvan Yan * the rest entries from the original property
141226947304SEvan Yan * array.
141326947304SEvan Yan */
141426947304SEvan Yan for (k = i + 1; k < rcount; k++) {
141526947304SEvan Yan newregs[j] = regs[k];
141626947304SEvan Yan j++;
141726947304SEvan Yan }
141826947304SEvan Yan
141926947304SEvan Yan goto done;
142026947304SEvan Yan
142126947304SEvan Yan } else {
142226947304SEvan Yan copy_entry:
142326947304SEvan Yan newregs[j] = regs[i];
142426947304SEvan Yan j++;
142526947304SEvan Yan }
142626947304SEvan Yan }
142726947304SEvan Yan
142826947304SEvan Yan done:
142926947304SEvan Yan /*
143026947304SEvan Yan * This should not fail so assert it. For non-debug kernel we don't
143126947304SEvan Yan * want to panic thus only logging a warning message.
143226947304SEvan Yan */
143326947304SEvan Yan ASSERT(found == B_TRUE);
143426947304SEvan Yan if (!found) {
143526947304SEvan Yan cmn_err(CE_WARN, "pci_get_available_prop: failed to remove "
143626947304SEvan Yan "resource from dip %p : base 0x%" PRIx64 ", len 0x%" PRIX64
143726947304SEvan Yan ", type 0x%x\n", (void *)dip, base, len, type);
143826947304SEvan Yan kmem_free(newregs, rlen + sizeof (pci_regspec_t));
143926947304SEvan Yan kmem_free(regs, rlen);
144026947304SEvan Yan
144126947304SEvan Yan return (DDI_FAILURE);
144226947304SEvan Yan }
144326947304SEvan Yan
144426947304SEvan Yan /*
144526947304SEvan Yan * Found the resources from parent, update the "available"
144626947304SEvan Yan * property.
144726947304SEvan Yan */
144826947304SEvan Yan if (j == 0) {
144926947304SEvan Yan /* all the resources are consumed, remove the property */
145026947304SEvan Yan (void) ndi_prop_remove(DDI_DEV_T_NONE, dip, "available");
145126947304SEvan Yan } else {
145226947304SEvan Yan /*
145326947304SEvan Yan * There are still resource available in the parent dip,
145426947304SEvan Yan * update with the remaining resources.
145526947304SEvan Yan */
145626947304SEvan Yan (void) ndi_prop_update_int_array(DDI_DEV_T_NONE, dip,
145726947304SEvan Yan "available", (int *)newregs,
145826947304SEvan Yan (j * sizeof (pci_regspec_t)) / sizeof (int));
145926947304SEvan Yan }
146026947304SEvan Yan
146126947304SEvan Yan kmem_free(newregs, rlen + sizeof (pci_regspec_t));
146226947304SEvan Yan kmem_free(regs, rlen);
146326947304SEvan Yan
146426947304SEvan Yan return (DDI_SUCCESS);
146526947304SEvan Yan }
146626947304SEvan Yan
146726947304SEvan Yan /*
146826947304SEvan Yan * Add a piece of IO/MEM resource to "available" property of 'dip'.
146926947304SEvan Yan */
147026947304SEvan Yan static int
pci_put_available_prop(dev_info_t * dip,uint64_t base,uint64_t len,char * busra_type)147126947304SEvan Yan pci_put_available_prop(dev_info_t *dip, uint64_t base, uint64_t len,
147226947304SEvan Yan char *busra_type)
147326947304SEvan Yan {
147426947304SEvan Yan pci_regspec_t *regs, *newregs;
147526947304SEvan Yan uint_t status;
147626947304SEvan Yan int rlen, rcount;
147726947304SEvan Yan int i, j, k;
147826947304SEvan Yan int matched = 0;
147926947304SEvan Yan uint64_t orig_base = base;
148026947304SEvan Yan uint64_t orig_len = len;
148126947304SEvan Yan uint32_t type;
148226947304SEvan Yan
148326947304SEvan Yan /* check if we're manipulating MEM/IO resource */
148426947304SEvan Yan if ((type = pci_type_ra2pci(busra_type)) == PCI_ADDR_TYPE_INVAL)
148526947304SEvan Yan return (DDI_SUCCESS);
148626947304SEvan Yan
148726947304SEvan Yan /* check if dip is a pci/pcie device resides in a pcie fabric */
148826947304SEvan Yan if (!is_pcie_fabric(dip))
148926947304SEvan Yan return (DDI_SUCCESS);
149026947304SEvan Yan
149126947304SEvan Yan status = ddi_getlongprop(DDI_DEV_T_ANY, dip,
149226947304SEvan Yan DDI_PROP_DONTPASS | DDI_PROP_NOTPROM,
149326947304SEvan Yan "available", (caddr_t)®s, &rlen);
149426947304SEvan Yan
149526947304SEvan Yan switch (status) {
149626947304SEvan Yan case DDI_PROP_NOT_FOUND:
149726947304SEvan Yan goto not_found;
149826947304SEvan Yan
149926947304SEvan Yan case DDI_PROP_SUCCESS:
150026947304SEvan Yan break;
150126947304SEvan Yan
150226947304SEvan Yan default:
150326947304SEvan Yan return (status);
150426947304SEvan Yan }
150526947304SEvan Yan
150626947304SEvan Yan /*
150726947304SEvan Yan * The "available" property exist on the node, try to put this
150826947304SEvan Yan * resource back, merge if there are adjacent resources.
150926947304SEvan Yan *
151026947304SEvan Yan * The updated "available" property will at most have one more entry
151126947304SEvan Yan * than existing one (when there is no adjacent entries thus the new
151226947304SEvan Yan * resource is appended at the end)
151326947304SEvan Yan */
151426947304SEvan Yan newregs = kmem_alloc(rlen + sizeof (pci_regspec_t), KM_SLEEP);
151526947304SEvan Yan
151626947304SEvan Yan rcount = rlen / sizeof (pci_regspec_t);
151726947304SEvan Yan for (i = 0, j = 0; i < rcount; i++) {
151826947304SEvan Yan if (type == (regs[i].pci_phys_hi & PCI_ADDR_TYPE_MASK)) {
151926947304SEvan Yan uint64_t range_base, range_len;
152026947304SEvan Yan
152126947304SEvan Yan range_base = ((uint64_t)(regs[i].pci_phys_mid) << 32) |
152226947304SEvan Yan ((uint64_t)(regs[i].pci_phys_low));
152326947304SEvan Yan range_len = ((uint64_t)(regs[i].pci_size_hi) << 32) |
152426947304SEvan Yan ((uint64_t)(regs[i].pci_size_low));
152526947304SEvan Yan
152626947304SEvan Yan if ((base + len < range_base) ||
152726947304SEvan Yan (base > range_base + range_len)) {
152826947304SEvan Yan /*
152926947304SEvan Yan * Not adjacent, copy the entry and contiue
153026947304SEvan Yan */
153126947304SEvan Yan goto copy_entry;
153226947304SEvan Yan }
153326947304SEvan Yan
153426947304SEvan Yan /*
153526947304SEvan Yan * Adjacent or overlap?
153626947304SEvan Yan *
153726947304SEvan Yan * Should not have overlapping resources so assert it.
153826947304SEvan Yan * For non-debug kernel we don't want to panic thus
153926947304SEvan Yan * only logging a warning message.
154026947304SEvan Yan */
154126947304SEvan Yan #if 0
154226947304SEvan Yan ASSERT((base + len == range_base) ||
154326947304SEvan Yan (base == range_base + range_len));
154426947304SEvan Yan #endif
154526947304SEvan Yan if ((base + len != range_base) &&
154626947304SEvan Yan (base != range_base + range_len)) {
154726947304SEvan Yan cmn_err(CE_WARN, "pci_put_available_prop: "
154826947304SEvan Yan "failed to add resource to dip %p : "
154926947304SEvan Yan "base 0x%" PRIx64 ", len 0x%" PRIx64 " "
155026947304SEvan Yan "overlaps with existing resource "
155126947304SEvan Yan "base 0x%" PRIx64 ", len 0x%" PRIx64 "\n",
155226947304SEvan Yan (void *)dip, orig_base, orig_len,
155326947304SEvan Yan range_base, range_len);
155426947304SEvan Yan
155526947304SEvan Yan goto failure;
155626947304SEvan Yan }
155726947304SEvan Yan
155826947304SEvan Yan /*
155926947304SEvan Yan * On the left:
156026947304SEvan Yan *
156126947304SEvan Yan * base range_base
156226947304SEvan Yan * +-------------+-------------+
156326947304SEvan Yan * |/////////////| |
156426947304SEvan Yan * +-------------+-------------+
156526947304SEvan Yan * len range_len
156626947304SEvan Yan *
156726947304SEvan Yan * On the right:
156826947304SEvan Yan *
156926947304SEvan Yan * range_base base
157026947304SEvan Yan * +-------------+-------------+
157126947304SEvan Yan * | |/////////////|
157226947304SEvan Yan * +-------------+-------------+
157326947304SEvan Yan * range_len len
157426947304SEvan Yan */
157526947304SEvan Yan /*
157626947304SEvan Yan * There are at most two piece of resources adjacent
157726947304SEvan Yan * with this resource, assert it.
157826947304SEvan Yan */
157926947304SEvan Yan ASSERT(matched < 2);
158026947304SEvan Yan
158126947304SEvan Yan if (!(matched < 2)) {
158226947304SEvan Yan cmn_err(CE_WARN, "pci_put_available_prop: "
158326947304SEvan Yan "failed to add resource to dip %p : "
158426947304SEvan Yan "base 0x%" PRIx64 ", len 0x%" PRIx64 " "
158526947304SEvan Yan "found overlaps in existing resources\n",
158626947304SEvan Yan (void *)dip, orig_base, orig_len);
158726947304SEvan Yan
158826947304SEvan Yan goto failure;
158926947304SEvan Yan }
159026947304SEvan Yan
159126947304SEvan Yan /* setup base & len to refer to the merged range */
159226947304SEvan Yan len += range_len;
159326947304SEvan Yan if (base == range_base + range_len)
159426947304SEvan Yan base = range_base;
159526947304SEvan Yan
159626947304SEvan Yan if (matched == 0) {
159726947304SEvan Yan /*
159826947304SEvan Yan * One adjacent entry, add this resource in
159926947304SEvan Yan */
160026947304SEvan Yan newregs[j].pci_phys_hi = regs[i].pci_phys_hi;
160126947304SEvan Yan newregs[j].pci_phys_mid =
160226947304SEvan Yan (uint32_t)(base >> 32);
160326947304SEvan Yan newregs[j].pci_phys_low = (uint32_t)(base);
160426947304SEvan Yan newregs[j].pci_size_hi = (uint32_t)(len >> 32);
160526947304SEvan Yan newregs[j].pci_size_low = (uint32_t)len;
160626947304SEvan Yan
160726947304SEvan Yan matched = 1;
160826947304SEvan Yan k = j;
160926947304SEvan Yan j++;
161026947304SEvan Yan } else { /* matched == 1 */
161126947304SEvan Yan /*
161226947304SEvan Yan * Two adjacent entries, merge them together
161326947304SEvan Yan */
161426947304SEvan Yan newregs[k].pci_phys_hi = regs[i].pci_phys_hi;
161526947304SEvan Yan newregs[k].pci_phys_mid =
161626947304SEvan Yan (uint32_t)(base >> 32);
161726947304SEvan Yan newregs[k].pci_phys_low = (uint32_t)(base);
161826947304SEvan Yan newregs[k].pci_size_hi = (uint32_t)(len >> 32);
161926947304SEvan Yan newregs[k].pci_size_low = (uint32_t)len;
162026947304SEvan Yan
162126947304SEvan Yan matched = 2;
162226947304SEvan Yan }
162326947304SEvan Yan } else {
162426947304SEvan Yan copy_entry:
162526947304SEvan Yan newregs[j] = regs[i];
162626947304SEvan Yan j++;
162726947304SEvan Yan }
162826947304SEvan Yan }
162926947304SEvan Yan
163026947304SEvan Yan if (matched == 0) {
163126947304SEvan Yan /* No adjacent entries, append at end */
163226947304SEvan Yan ASSERT(j == rcount);
163326947304SEvan Yan
163426947304SEvan Yan /*
163526947304SEvan Yan * According to page 15 of 1275 spec, bit "n" of "available"
163626947304SEvan Yan * should be set to 1.
163726947304SEvan Yan */
163826947304SEvan Yan newregs[j].pci_phys_hi = type;
163926947304SEvan Yan newregs[j].pci_phys_hi |= PCI_REG_REL_M;
164026947304SEvan Yan
164126947304SEvan Yan newregs[j].pci_phys_mid = (uint32_t)(base >> 32);
164226947304SEvan Yan newregs[j].pci_phys_low = (uint32_t)base;
164326947304SEvan Yan newregs[j].pci_size_hi = (uint32_t)(len >> 32);
164426947304SEvan Yan newregs[j].pci_size_low = (uint32_t)len;
164526947304SEvan Yan
164626947304SEvan Yan j++;
164726947304SEvan Yan }
164826947304SEvan Yan
164926947304SEvan Yan (void) ndi_prop_update_int_array(DDI_DEV_T_NONE, dip,
165026947304SEvan Yan "available", (int *)newregs,
165126947304SEvan Yan (j * sizeof (pci_regspec_t)) / sizeof (int));
165226947304SEvan Yan
165326947304SEvan Yan kmem_free(newregs, rlen + sizeof (pci_regspec_t));
165426947304SEvan Yan kmem_free(regs, rlen);
165526947304SEvan Yan return (DDI_SUCCESS);
165626947304SEvan Yan
165726947304SEvan Yan not_found:
165826947304SEvan Yan /*
165926947304SEvan Yan * There is no "available" property on the parent node, create it.
166026947304SEvan Yan */
166126947304SEvan Yan newregs = kmem_alloc(sizeof (pci_regspec_t), KM_SLEEP);
166226947304SEvan Yan
166326947304SEvan Yan /*
166426947304SEvan Yan * According to page 15 of 1275 spec, bit "n" of "available" should
166526947304SEvan Yan * be set to 1.
166626947304SEvan Yan */
166726947304SEvan Yan newregs[0].pci_phys_hi = type;
166826947304SEvan Yan newregs[0].pci_phys_hi |= PCI_REG_REL_M;
166926947304SEvan Yan
167026947304SEvan Yan newregs[0].pci_phys_mid = (uint32_t)(base >> 32);
167126947304SEvan Yan newregs[0].pci_phys_low = (uint32_t)base;
167226947304SEvan Yan newregs[0].pci_size_hi = (uint32_t)(len >> 32);
167326947304SEvan Yan newregs[0].pci_size_low = (uint32_t)len;
167426947304SEvan Yan
167526947304SEvan Yan (void) ndi_prop_update_int_array(DDI_DEV_T_NONE, dip,
167626947304SEvan Yan "available", (int *)newregs,
167726947304SEvan Yan sizeof (pci_regspec_t) / sizeof (int));
167826947304SEvan Yan kmem_free(newregs, sizeof (pci_regspec_t));
167926947304SEvan Yan return (DDI_SUCCESS);
168026947304SEvan Yan
168126947304SEvan Yan failure:
168226947304SEvan Yan kmem_free(newregs, rlen + sizeof (pci_regspec_t));
168326947304SEvan Yan kmem_free(regs, rlen);
168426947304SEvan Yan return (DDI_FAILURE);
168526947304SEvan Yan }
168626947304SEvan Yan
168726947304SEvan Yan static uint32_t
pci_type_ra2pci(char * type)168826947304SEvan Yan pci_type_ra2pci(char *type)
168926947304SEvan Yan {
169026947304SEvan Yan uint32_t pci_type = PCI_ADDR_TYPE_INVAL;
169126947304SEvan Yan
169226947304SEvan Yan /*
169326947304SEvan Yan * No 64 bit mem support for now
169426947304SEvan Yan */
169526947304SEvan Yan if (strcmp(type, NDI_RA_TYPE_IO) == 0) {
169626947304SEvan Yan pci_type = PCI_ADDR_IO;
169726947304SEvan Yan
169826947304SEvan Yan } else if (strcmp(type, NDI_RA_TYPE_MEM) == 0) {
169926947304SEvan Yan pci_type = PCI_ADDR_MEM32;
170026947304SEvan Yan
170126947304SEvan Yan } else if (strcmp(type, NDI_RA_TYPE_PCI_PREFETCH_MEM) == 0) {
170226947304SEvan Yan pci_type = PCI_ADDR_MEM32;
170326947304SEvan Yan pci_type |= PCI_REG_PF_M;
170426947304SEvan Yan }
170526947304SEvan Yan
170626947304SEvan Yan return (pci_type);
170726947304SEvan Yan }
1708