xref: /illumos-gate/usr/src/uts/common/io/busra.c (revision 3fe80ca4)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 /*
22  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
23  * Use is subject to license terms.
24  * Copyright 2012 Milan Jurik. All rights reserved.
25  * Copyright (c) 2016 by Delphix. All rights reserved.
26  * Copyright 2023 Oxide Computer Company
27  */
28 
29 #if defined(DEBUG)
30 #define	BUSRA_DEBUG
31 #endif
32 
33 /*
34  * This module provides a set of resource management interfaces
35  * to manage bus resources globally in the system.
36  *
37  * The bus nexus drivers are typically responsible to setup resource
38  * maps for the bus resources available for a bus instance. However
39  * this module also provides resource setup functions for PCI bus
40  * (used by both SPARC and X86 platforms) and ISA bus instances (used
41  * only for X86 platforms).
42  */
43 
44 #include <sys/types.h>
45 #include <sys/systm.h>
46 #include <sys/ddi.h>
47 #include <sys/sunddi.h>
48 #include <sys/sunndi.h>
49 #include <sys/ddi_impldefs.h>
50 #include <sys/ndi_impldefs.h>
51 #include <sys/kmem.h>
52 #include <sys/pctypes.h>
53 #include <sys/modctl.h>
54 #include <sys/debug.h>
55 #include <sys/spl.h>
56 #include <sys/pci.h>
57 #include <sys/autoconf.h>
58 
59 #if defined(BUSRA_DEBUG)
60 int busra_debug = 0;
61 #define	DEBUGPRT \
62 	if (busra_debug) cmn_err
63 
64 #else
65 #define	DEBUGPRT \
66 	if (0) cmn_err
67 #endif
68 
69 
70 /*
71  * global mutex that protects the global list of resource maps.
72  */
73 kmutex_t ra_lock;
74 
75 /*
76  * basic resource element
77  */
78 struct ra_resource {
79 	struct ra_resource *ra_next;
80 	uint64_t	ra_base;
81 	uint64_t	ra_len;
82 };
83 
84 /*
85  * link list element for the list of dips (and their resource ranges)
86  * for a particular resource type.
87  * ra_rangeset points to the list of resources available
88  * for this type and this dip.
89  */
90 struct ra_dip_type  {
91 	struct ra_dip_type *ra_next;
92 	struct ra_resource  *ra_rangeset;
93 	dev_info_t *ra_dip;
94 };
95 
96 
97 /*
98  * link list element for list of types resources. Each element
99  * has all resources for a particular type.
100  */
101 struct ra_type_map {
102 	struct ra_type_map *ra_next;
103 	struct ra_dip_type *ra_dip_list;
104 	char *type;
105 };
106 
107 
108 /*
109  * place holder to keep the head of the whole global list.
110  * the address of the first typemap would be stored in it.
111  */
112 static struct ra_type_map	*ra_map_list_head = NULL;
113 
114 
115 /*
116  * This is the loadable module wrapper.
117  * It is essentially boilerplate so isn't documented
118  */
119 extern struct mod_ops mod_miscops;
120 
121 #ifdef BUSRA_DEBUG
122 void ra_dump_all(char *, dev_info_t *);
123 #endif
124 
125 /* internal function prototypes */
126 static struct ra_dip_type *find_dip_map_resources(dev_info_t *dip, char *type,
127     struct ra_dip_type ***backdip, struct ra_type_map ***backtype,
128     uint32_t flag);
129 static int isnot_pow2(uint64_t value);
130 static int claim_pci_busnum(dev_info_t *dip, void *arg);
131 static int ra_map_exist(dev_info_t *dip, char *type);
132 
133 static int pci_get_available_prop(dev_info_t *dip, uint64_t base,
134     uint64_t len, char *busra_type);
135 static int pci_put_available_prop(dev_info_t *dip, uint64_t base,
136     uint64_t len, char *busra_type);
137 static uint32_t pci_type_ra2pci(char *type);
138 static boolean_t is_pcie_fabric(dev_info_t *dip);
139 
140 #define	PCI_ADDR_TYPE_MASK	(PCI_REG_ADDR_M | PCI_REG_PF_M)
141 #define	PCI_ADDR_TYPE_INVAL	0xffffffff
142 
143 #define	RA_INSERT(prev, el) \
144 	el->ra_next = *prev; \
145 	*prev = el;
146 
147 #define	RA_REMOVE(prev, el) \
148 	*prev = el->ra_next;
149 
150 
151 static struct modlmisc modlmisc = {
152 	&mod_miscops,		/* Type of module. This one is a module */
153 	"Bus Resource Allocator (BUSRA)",	/* Name of the module. */
154 };
155 
156 static struct modlinkage modlinkage = {
157 	MODREV_1, (void *)&modlmisc, NULL
158 };
159 
160 int
_init()161 _init()
162 {
163 	int	ret;
164 
165 	mutex_init(&ra_lock, NULL, MUTEX_DRIVER,
166 	    (void *)(intptr_t)__ipltospl(SPL7 - 1));
167 	if ((ret = mod_install(&modlinkage)) != 0) {
168 		mutex_destroy(&ra_lock);
169 	}
170 	return (ret);
171 }
172 
173 int
_fini()174 _fini()
175 {
176 	int	ret;
177 
178 	mutex_enter(&ra_lock);
179 
180 	if (ra_map_list_head != NULL) {
181 		mutex_exit(&ra_lock);
182 		return (EBUSY);
183 	}
184 
185 	ret = mod_remove(&modlinkage);
186 
187 	mutex_exit(&ra_lock);
188 
189 	if (ret == 0)
190 		mutex_destroy(&ra_lock);
191 
192 	return (ret);
193 }
194 
195 int
_info(struct modinfo * modinfop)196 _info(struct modinfo *modinfop)
197 {
198 	return (mod_info(&modlinkage, modinfop));
199 }
200 
201 /*
202  * set up an empty resource map for a given type and dip
203  */
204 int
ndi_ra_map_setup(dev_info_t * dip,char * type)205 ndi_ra_map_setup(dev_info_t *dip, char *type)
206 {
207 	struct ra_type_map  *typemapp;
208 	struct ra_dip_type  *dipmap;
209 	struct ra_dip_type  **backdip;
210 	struct ra_type_map  **backtype;
211 
212 
213 	mutex_enter(&ra_lock);
214 
215 	dipmap = find_dip_map_resources(dip, type, &backdip, &backtype, 0);
216 
217 	if (dipmap == NULL) {
218 		if (backtype == NULL) {
219 			typemapp = (struct ra_type_map *)
220 			    kmem_zalloc(sizeof (*typemapp), KM_SLEEP);
221 			typemapp->type = (char *)kmem_zalloc(strlen(type) + 1,
222 			    KM_SLEEP);
223 			(void) strcpy(typemapp->type, type);
224 			RA_INSERT(&ra_map_list_head, typemapp);
225 		} else {
226 			typemapp = *backtype;
227 		}
228 		if (backdip == NULL) {
229 			/* allocate and insert in list of dips for this type */
230 			dipmap = (struct ra_dip_type *)
231 			    kmem_zalloc(sizeof (*dipmap), KM_SLEEP);
232 			dipmap->ra_dip = dip;
233 			RA_INSERT(&typemapp->ra_dip_list, dipmap);
234 		}
235 	}
236 
237 	mutex_exit(&ra_lock);
238 	return (NDI_SUCCESS);
239 }
240 
241 /*
242  * destroys a resource map for a given dip and type
243  */
244 int
ndi_ra_map_destroy(dev_info_t * dip,char * type)245 ndi_ra_map_destroy(dev_info_t *dip, char *type)
246 {
247 	struct ra_dip_type	*dipmap;
248 	struct ra_dip_type	**backdip;
249 	struct ra_type_map	**backtype, *typemap;
250 	struct ra_resource	*range;
251 
252 	mutex_enter(&ra_lock);
253 	dipmap = find_dip_map_resources(dip, type, &backdip, &backtype, 0);
254 
255 	if (dipmap == NULL) {
256 		mutex_exit(&ra_lock);
257 		return (NDI_FAILURE);
258 	}
259 
260 	/*
261 	 * destroy all resources for this dip
262 	 * remove dip from type list
263 	 */
264 	ASSERT((backdip != NULL) && (backtype != NULL));
265 	while (dipmap->ra_rangeset != NULL) {
266 		range = dipmap->ra_rangeset;
267 		RA_REMOVE(&dipmap->ra_rangeset, range);
268 		kmem_free((caddr_t)range, sizeof (*range));
269 	}
270 	/* remove from dip list */
271 	RA_REMOVE(backdip, dipmap);
272 	kmem_free((caddr_t)dipmap, sizeof (*dipmap));
273 	if ((*backtype)->ra_dip_list == NULL) {
274 		/*
275 		 * This was the last dip with this resource type.
276 		 * Remove the type from the global list.
277 		 */
278 		typemap = *backtype;
279 		RA_REMOVE(backtype, (*backtype));
280 		kmem_free((caddr_t)typemap->type, strlen(typemap->type) + 1);
281 		kmem_free((caddr_t)typemap, sizeof (*typemap));
282 	}
283 
284 	mutex_exit(&ra_lock);
285 	return (NDI_SUCCESS);
286 }
287 
288 static int
ra_map_exist(dev_info_t * dip,char * type)289 ra_map_exist(dev_info_t *dip, char *type)
290 {
291 	struct ra_dip_type  **backdip;
292 	struct ra_type_map  **backtype;
293 
294 	mutex_enter(&ra_lock);
295 	if (find_dip_map_resources(dip, type, &backdip, &backtype, 0) == NULL) {
296 		mutex_exit(&ra_lock);
297 		return (NDI_FAILURE);
298 	}
299 
300 	mutex_exit(&ra_lock);
301 	return (NDI_SUCCESS);
302 }
303 /*
304  * Find a dip map for the specified type, if NDI_RA_PASS will go up on dev tree
305  * if found, backdip and backtype will be updated to point to the previous
306  * dip in the list and previous type for this dip in the list.
307  * If no such type at all in the resource list both backdip and backtype
308  * will be null. If the type found but no dip, back dip will be null.
309  */
310 
311 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)312 find_dip_map_resources(dev_info_t *dip, char *type,
313     struct ra_dip_type ***backdip, struct ra_type_map ***backtype,
314     uint32_t flag)
315 {
316 	struct ra_type_map **prevmap;
317 	struct ra_dip_type *dipmap, **prevdip;
318 
319 	ASSERT(mutex_owned(&ra_lock));
320 	prevdip = NULL;
321 	dipmap = NULL;
322 	prevmap = &ra_map_list_head;
323 
324 	while (*prevmap) {
325 		if (strcmp((*prevmap)->type, type) == 0)
326 			break;
327 		prevmap = &(*prevmap)->ra_next;
328 	}
329 
330 	if (*prevmap) {
331 		for (; dip != NULL; dip = ddi_get_parent(dip)) {
332 			prevdip = &(*prevmap)->ra_dip_list;
333 			dipmap = *prevdip;
334 
335 			while (dipmap) {
336 				if (dipmap->ra_dip == dip)
337 					break;
338 				prevdip =  &dipmap->ra_next;
339 				dipmap = dipmap->ra_next;
340 			}
341 
342 			if (dipmap != NULL) {
343 				/* found it */
344 				break;
345 			}
346 
347 			if (!(flag & NDI_RA_PASS)) {
348 				break;
349 			}
350 		}
351 	}
352 
353 	*backtype = (*prevmap == NULL) ?  NULL: prevmap;
354 	*backdip = (dipmap == NULL) ?  NULL: prevdip;
355 
356 	return (dipmap);
357 }
358 
359 int
ndi_ra_free(dev_info_t * dip,uint64_t base,uint64_t len,char * type,uint32_t flag)360 ndi_ra_free(dev_info_t *dip, uint64_t base, uint64_t len, char *type,
361     uint32_t flag)
362 {
363 	struct ra_dip_type *dipmap;
364 	struct ra_resource *newmap, *overlapmap, *oldmap = NULL;
365 	struct ra_resource  *mapp, **backp;
366 	uint64_t newend, mapend;
367 	struct ra_dip_type **backdip;
368 	struct ra_type_map **backtype;
369 
370 	if (len == 0) {
371 		return (NDI_SUCCESS);
372 	}
373 
374 	mutex_enter(&ra_lock);
375 
376 	if ((dipmap = find_dip_map_resources(dip, type, &backdip, &backtype,
377 	    flag)) == NULL) {
378 		mutex_exit(&ra_lock);
379 		return (NDI_FAILURE);
380 	}
381 
382 	mapp = dipmap->ra_rangeset;
383 	backp = &dipmap->ra_rangeset;
384 
385 	/* now find where range lies and fix things up */
386 	newend = base + len;
387 	for (; mapp != NULL; backp = &(mapp->ra_next), mapp = mapp->ra_next) {
388 		mapend = mapp->ra_base + mapp->ra_len;
389 
390 		/* check for overlap first */
391 		if ((base <= mapp->ra_base && newend > mapp->ra_base) ||
392 		    (base > mapp->ra_base && base < mapend)) {
393 			/* overlap with mapp */
394 			overlapmap = mapp;
395 			goto overlap;
396 		} else if ((base == mapend && mapp->ra_next) &&
397 		    (newend > mapp->ra_next->ra_base)) {
398 			/* overlap with mapp->ra_next */
399 			overlapmap = mapp->ra_next;
400 			goto overlap;
401 		}
402 
403 		if (newend == mapp->ra_base) {
404 			/* simple - on front */
405 			mapp->ra_base = base;
406 			mapp->ra_len += len;
407 			/*
408 			 * don't need to check if it merges with
409 			 * previous since that would match on on end
410 			 */
411 			break;
412 		} else if (base == mapend) {
413 			/* simple - on end */
414 			mapp->ra_len += len;
415 			if (mapp->ra_next &&
416 			    (newend == mapp->ra_next->ra_base)) {
417 				/* merge with next node */
418 				oldmap = mapp->ra_next;
419 				mapp->ra_len += oldmap->ra_len;
420 				RA_REMOVE(&mapp->ra_next, oldmap);
421 				kmem_free((caddr_t)oldmap, sizeof (*oldmap));
422 			}
423 			break;
424 		} else if (base < mapp->ra_base) {
425 			/* somewhere in between so just an insert */
426 			newmap = (struct ra_resource *)
427 			    kmem_zalloc(sizeof (*newmap), KM_SLEEP);
428 			newmap->ra_base = base;
429 			newmap->ra_len = len;
430 			RA_INSERT(backp, newmap);
431 			break;
432 		}
433 	}
434 	if (mapp == NULL) {
435 		/* stick on end */
436 		newmap = (struct ra_resource *)
437 		    kmem_zalloc(sizeof (*newmap), KM_SLEEP);
438 		newmap->ra_base = base;
439 		newmap->ra_len = len;
440 		RA_INSERT(backp, newmap);
441 	}
442 
443 	mutex_exit(&ra_lock);
444 
445 	/*
446 	 * Update dip's "available" property, adding this piece of
447 	 * resource to the pool.
448 	 */
449 	(void) pci_put_available_prop(dipmap->ra_dip, base, len, type);
450 done:
451 	return (NDI_SUCCESS);
452 
453 overlap:
454 	/*
455 	 * Bad free may happen on some x86 platforms with BIOS exporting
456 	 * incorrect resource maps. The system is otherwise functioning
457 	 * normally. We send such messages to syslog only.
458 	 */
459 	cmn_err(CE_NOTE, "!ndi_ra_free: bad free, dip %p, resource type %s \n",
460 	    (void *)dip, type);
461 	cmn_err(CE_NOTE, "!ndi_ra_free: freeing base 0x%" PRIx64 ", len 0x%"
462 	    PRIX64 " overlaps with existing resource base 0x%" PRIx64
463 	    ", len 0x%" PRIx64 "\n", base, len, overlapmap->ra_base,
464 	    overlapmap->ra_len);
465 
466 	mutex_exit(&ra_lock);
467 	return (NDI_FAILURE);
468 }
469 
470 /* check to see if value is power of 2 or not. */
471 static int
isnot_pow2(uint64_t value)472 isnot_pow2(uint64_t value)
473 {
474 	uint32_t low;
475 	uint32_t hi;
476 
477 	low = value & 0xffffffff;
478 	hi = value >> 32;
479 
480 	/*
481 	 * ddi_ffs and ddi_fls gets long values, so in 32bit environment
482 	 * won't work correctly for 64bit values
483 	 */
484 	if ((ddi_ffs(low) == ddi_fls(low)) &&
485 	    (ddi_ffs(hi) == ddi_fls(hi)))
486 		return (0);
487 	return (1);
488 }
489 
490 static  void
adjust_link(struct ra_resource ** backp,struct ra_resource * mapp,uint64_t base,uint64_t len)491 adjust_link(struct ra_resource **backp, struct ra_resource *mapp,
492     uint64_t base, uint64_t len)
493 {
494 	struct ra_resource *newmap;
495 	uint64_t newlen;
496 
497 	if (base != mapp->ra_base) {
498 		/* in the middle or end */
499 		newlen = base - mapp->ra_base;
500 		if ((mapp->ra_len - newlen) == len) {
501 			/* on the end */
502 			mapp->ra_len = newlen;
503 		} else {
504 			/* in the middle */
505 			newmap = (struct ra_resource *)
506 			    kmem_zalloc(sizeof (*newmap), KM_SLEEP);
507 			newmap->ra_base = base + len;
508 			newmap->ra_len = mapp->ra_len - (len + newlen);
509 			mapp->ra_len = newlen;
510 			RA_INSERT(&(mapp->ra_next), newmap);
511 		}
512 	} else {
513 		/* at the beginning */
514 		mapp->ra_base += len;
515 		mapp->ra_len -= len;
516 		if (mapp->ra_len == 0) {
517 			/* remove the whole node */
518 			RA_REMOVE(backp, mapp);
519 			kmem_free((caddr_t)mapp, sizeof (*mapp));
520 		}
521 	}
522 }
523 
524 int
ndi_ra_alloc(dev_info_t * dip,ndi_ra_request_t * req,uint64_t * retbasep,uint64_t * retlenp,char * type,uint32_t flag)525 ndi_ra_alloc(dev_info_t *dip, ndi_ra_request_t *req, uint64_t *retbasep,
526     uint64_t *retlenp, char *type, uint32_t flag)
527 {
528 	struct ra_dip_type *dipmap;
529 	struct ra_resource *mapp, **backp, **backlargestp;
530 	uint64_t mask = 0;
531 	uint64_t len, remlen, largestbase, largestlen;
532 	uint64_t base, oldbase, lower, upper;
533 	struct ra_dip_type  **backdip;
534 	struct ra_type_map  **backtype;
535 	int  rval = NDI_FAILURE;
536 
537 
538 	len = req->ra_len;
539 
540 	if (req->ra_flags & NDI_RA_ALIGN_SIZE) {
541 		if (isnot_pow2(req->ra_len)) {
542 			DEBUGPRT(CE_WARN, "ndi_ra_alloc: bad length(pow2) 0x%"
543 			    PRIx64, req->ra_len);
544 			*retbasep = 0;
545 			*retlenp = 0;
546 			return (NDI_FAILURE);
547 		}
548 	}
549 
550 	mask = (req->ra_flags & NDI_RA_ALIGN_SIZE) ? (len - 1) :
551 	    req->ra_align_mask;
552 
553 
554 	mutex_enter(&ra_lock);
555 	dipmap = find_dip_map_resources(dip, type, &backdip, &backtype, flag);
556 	if ((dipmap == NULL) || ((mapp = dipmap->ra_rangeset) == NULL)) {
557 		mutex_exit(&ra_lock);
558 		DEBUGPRT(CE_CONT, "ndi_ra_alloc no map found for this type\n");
559 		return (NDI_FAILURE);
560 	}
561 
562 	DEBUGPRT(CE_CONT, "ndi_ra_alloc: mapp = %p len=%" PRIx64 ", mask=%"
563 	    PRIx64 "\n", (void *)mapp, len, mask);
564 
565 	backp = &(dipmap->ra_rangeset);
566 	backlargestp = NULL;
567 	largestbase = 0;
568 	largestlen = 0;
569 
570 	lower = 0;
571 	upper = ~(uint64_t)0;
572 
573 	if (req->ra_flags & NDI_RA_ALLOC_BOUNDED) {
574 		/* bounded so skip to first possible */
575 		lower = req->ra_boundbase;
576 		upper = req->ra_boundlen + lower;
577 		if ((upper == 0) || (upper < req->ra_boundlen))
578 			upper = ~(uint64_t)0;
579 		DEBUGPRT(CE_CONT, "ndi_ra_alloc: ra_len = %" PRIx64 ", len = %"
580 		    PRIx64 " ra_base=%" PRIx64 ", mask=%" PRIx64
581 		    "\n", mapp->ra_len, len, mapp->ra_base, mask);
582 		for (; mapp != NULL && (mapp->ra_base + mapp->ra_len) < lower;
583 		    backp = &(mapp->ra_next), mapp = mapp->ra_next) {
584 			if (((mapp->ra_len + mapp->ra_base) == 0) ||
585 			    ((mapp->ra_len + mapp->ra_base) < mapp->ra_len))
586 				/*
587 				 * This elements end goes beyond max uint64_t.
588 				 * potential candidate, check end against lower
589 				 * would not be precise.
590 				 */
591 				break;
592 
593 			DEBUGPRT(CE_CONT, " ra_len = %" PRIx64 ", ra_base=%"
594 			    PRIx64 "\n", mapp->ra_len, mapp->ra_base);
595 			}
596 
597 	}
598 
599 	if (!(req->ra_flags & NDI_RA_ALLOC_SPECIFIED)) {
600 		/* first fit - not user specified */
601 		DEBUGPRT(CE_CONT, "ndi_ra_alloc(unspecified request)"
602 		    "lower=%" PRIx64 ", upper=%" PRIx64 "\n", lower, upper);
603 		for (; mapp != NULL && mapp->ra_base <= upper;
604 		    backp = &(mapp->ra_next), mapp = mapp->ra_next) {
605 
606 			DEBUGPRT(CE_CONT, "ndi_ra_alloc: ra_len = %" PRIx64
607 			    ", len = %" PRIx64 "", mapp->ra_len, len);
608 			base = mapp->ra_base;
609 			if (base < lower) {
610 				base = lower;
611 				DEBUGPRT(CE_CONT, "\tbase=%" PRIx64
612 				    ", ra_base=%" PRIx64 ", mask=%" PRIx64,
613 				    base, mapp->ra_base, mask);
614 			}
615 
616 			if ((base & mask) != 0) {
617 				oldbase = base;
618 				/*
619 				 * failed a critical constraint
620 				 * adjust and see if it still fits
621 				 */
622 				base = base & ~mask;
623 				base += (mask + 1);
624 				DEBUGPRT(CE_CONT, "\tnew base=%" PRIx64 "\n",
625 				    base);
626 
627 				/*
628 				 * Check to see if the new base is past
629 				 * the end of the resource.
630 				 */
631 				if (base >= (oldbase + mapp->ra_len + 1)) {
632 					continue;
633 				}
634 			}
635 
636 			if (req->ra_flags & NDI_RA_ALLOC_PARTIAL_OK) {
637 				if ((upper - mapp->ra_base)  <  mapp->ra_len)
638 					remlen = upper - base;
639 				else
640 					remlen = mapp->ra_len -
641 					    (base - mapp->ra_base);
642 
643 				if ((backlargestp == NULL) ||
644 				    (largestlen < remlen)) {
645 
646 					backlargestp = backp;
647 					largestbase = base;
648 					largestlen = remlen;
649 				}
650 			}
651 
652 			if (mapp->ra_len >= len) {
653 				/* a candidate -- apply constraints */
654 				if ((len > (mapp->ra_len -
655 				    (base - mapp->ra_base))) ||
656 				    ((len - 1 + base) > upper)) {
657 					continue;
658 				}
659 
660 				/* we have a fit */
661 
662 				DEBUGPRT(CE_CONT, "\thave a fit\n");
663 
664 				adjust_link(backp, mapp, base, len);
665 				rval = NDI_SUCCESS;
666 				break;
667 
668 			}
669 		}
670 	} else {
671 		/* want an exact value/fit */
672 		base = req->ra_addr;
673 		len = req->ra_len;
674 		for (; mapp != NULL && mapp->ra_base <= upper;
675 		    backp = &(mapp->ra_next), mapp = mapp->ra_next) {
676 			if (base >= mapp->ra_base &&
677 			    ((base - mapp->ra_base) < mapp->ra_len)) {
678 				/*
679 				 * This is the node with the requested base in
680 				 * its range
681 				 */
682 				if ((len > mapp->ra_len) ||
683 				    (base - mapp->ra_base >
684 				    mapp->ra_len - len)) {
685 					/* length requirement not satisfied */
686 					if (req->ra_flags &
687 					    NDI_RA_ALLOC_PARTIAL_OK) {
688 						if ((upper - mapp->ra_base)
689 						    < mapp->ra_len)
690 							remlen = upper - base;
691 						else
692 							remlen =
693 							    mapp->ra_len -
694 							    (base -
695 							    mapp->ra_base);
696 					}
697 					backlargestp = backp;
698 					largestbase = base;
699 					largestlen = remlen;
700 					base = 0;
701 				} else {
702 					/* We have a match */
703 					adjust_link(backp, mapp, base, len);
704 					rval = NDI_SUCCESS;
705 				}
706 				break;
707 			}
708 		}
709 	}
710 
711 	if ((rval != NDI_SUCCESS) &&
712 	    (req->ra_flags & NDI_RA_ALLOC_PARTIAL_OK) &&
713 	    (backlargestp != NULL)) {
714 		adjust_link(backlargestp, *backlargestp, largestbase,
715 		    largestlen);
716 
717 		base = largestbase;
718 		len = largestlen;
719 		rval = NDI_RA_PARTIAL_REQ;
720 	}
721 
722 	mutex_exit(&ra_lock);
723 
724 	if (rval == NDI_FAILURE) {
725 		*retbasep = 0;
726 		*retlenp = 0;
727 	} else {
728 		*retbasep = base;
729 		*retlenp = len;
730 	}
731 
732 	/*
733 	 * Update dip's "available" property, substract this piece of
734 	 * resource from the pool.
735 	 */
736 	if ((rval == NDI_SUCCESS) || (rval == NDI_RA_PARTIAL_REQ))
737 		(void) pci_get_available_prop(dipmap->ra_dip,
738 		    *retbasep, *retlenp, type);
739 
740 	return (rval);
741 }
742 
743 /*
744  * isa_resource_setup
745  *	check for /used-resources and initialize
746  *	based on info there.  If no /used-resources,
747  *	fail.
748  */
749 int
isa_resource_setup()750 isa_resource_setup()
751 {
752 	dev_info_t *used, *usedpdip;
753 	/*
754 	 * note that at this time bootconf creates 32 bit properties for
755 	 * io-space and device-memory
756 	 */
757 	struct iorange {
758 		uint32_t	base;
759 		uint32_t	len;
760 	} *iorange;
761 	struct memrange {
762 		uint32_t	base;
763 		uint32_t	len;
764 	} *memrange;
765 	uint32_t *irq;
766 	int proplen;
767 	int i, len;
768 	int maxrange;
769 	ndi_ra_request_t req;
770 	uint64_t retbase;
771 	uint64_t retlen;
772 
773 	used = ddi_find_devinfo("used-resources", -1, 0);
774 	if (used == NULL) {
775 		DEBUGPRT(CE_CONT,
776 		    "isa_resource_setup: used-resources not found");
777 		return (NDI_FAILURE);
778 	}
779 
780 	/*
781 	 * initialize to all resources being present
782 	 * and then remove the ones in use.
783 	 */
784 
785 	usedpdip = ddi_root_node();
786 
787 	DEBUGPRT(CE_CONT, "isa_resource_setup: used = %p usedpdip = %p\n",
788 	    (void *)used, (void *)usedpdip);
789 
790 	if (ndi_ra_map_setup(usedpdip, NDI_RA_TYPE_IO) == NDI_FAILURE) {
791 		return (NDI_FAILURE);
792 	}
793 
794 	/* initialize io space, highest end base is 0xffff */
795 	/* note that length is highest addr + 1 since starts from 0 */
796 
797 	(void) ndi_ra_free(usedpdip, 0, 0xffff + 1,  NDI_RA_TYPE_IO, 0);
798 
799 	if (ddi_getlongprop(DDI_DEV_T_ANY, used, DDI_PROP_DONTPASS,
800 	    "io-space", (caddr_t)&iorange, &proplen) == DDI_SUCCESS) {
801 		maxrange = proplen / sizeof (struct iorange);
802 		/* remove the "used" I/O resources */
803 		for (i = 0; i < maxrange; i++) {
804 			bzero((caddr_t)&req, sizeof (req));
805 			req.ra_addr =  (uint64_t)iorange[i].base;
806 			req.ra_len = (uint64_t)iorange[i].len;
807 			req.ra_flags = NDI_RA_ALLOC_SPECIFIED;
808 			(void) ndi_ra_alloc(usedpdip, &req, &retbase, &retlen,
809 			    NDI_RA_TYPE_IO, 0);
810 		}
811 
812 		kmem_free((caddr_t)iorange, proplen);
813 	}
814 
815 	if (ndi_ra_map_setup(usedpdip, NDI_RA_TYPE_MEM) == NDI_FAILURE) {
816 		return (NDI_FAILURE);
817 	}
818 	/* initialize memory space where highest end base is 0xffffffff */
819 	/* note that length is highest addr + 1 since starts from 0 */
820 	(void) ndi_ra_free(usedpdip, 0, ((uint64_t)((uint32_t)~0)) + 1,
821 	    NDI_RA_TYPE_MEM, 0);
822 
823 	if (ddi_getlongprop(DDI_DEV_T_ANY, used, DDI_PROP_DONTPASS,
824 	    "device-memory", (caddr_t)&memrange, &proplen) == DDI_SUCCESS) {
825 		maxrange = proplen / sizeof (struct memrange);
826 		/* remove the "used" memory resources */
827 		for (i = 0; i < maxrange; i++) {
828 			bzero((caddr_t)&req, sizeof (req));
829 			req.ra_addr = (uint64_t)memrange[i].base;
830 			req.ra_len = (uint64_t)memrange[i].len;
831 			req.ra_flags = NDI_RA_ALLOC_SPECIFIED;
832 			(void) ndi_ra_alloc(usedpdip, &req, &retbase, &retlen,
833 			    NDI_RA_TYPE_MEM, 0);
834 		}
835 
836 		kmem_free((caddr_t)memrange, proplen);
837 	}
838 
839 	if (ndi_ra_map_setup(usedpdip, NDI_RA_TYPE_INTR) == NDI_FAILURE) {
840 		return (NDI_FAILURE);
841 	}
842 
843 	/* initialize the interrupt space */
844 	(void) ndi_ra_free(usedpdip, 0, 16, NDI_RA_TYPE_INTR, 0);
845 
846 #if defined(__x86)
847 	bzero(&req, sizeof (req));
848 	req.ra_addr = 2;	/* 2 == 9 so never allow */
849 	req.ra_len = 1;
850 	req.ra_flags = NDI_RA_ALLOC_SPECIFIED;
851 	(void) ndi_ra_alloc(usedpdip, &req, &retbase, &retlen,
852 	    NDI_RA_TYPE_INTR, 0);
853 #endif
854 
855 	if (ddi_getlongprop(DDI_DEV_T_ANY, used, DDI_PROP_DONTPASS,
856 	    "interrupts", (caddr_t)&irq, &proplen) == DDI_SUCCESS) {
857 		/* Initialize available interrupts by negating the used */
858 		len = (proplen / sizeof (uint32_t));
859 		for (i = 0; i < len; i++) {
860 			bzero((caddr_t)&req, sizeof (req));
861 			req.ra_addr = (uint64_t)irq[i];
862 			req.ra_len = 1;
863 			req.ra_flags = NDI_RA_ALLOC_SPECIFIED;
864 			(void) ndi_ra_alloc(usedpdip, &req, &retbase, &retlen,
865 			    NDI_RA_TYPE_INTR, 0);
866 		}
867 		kmem_free((caddr_t)irq, proplen);
868 	}
869 
870 #ifdef BUSRA_DEBUG
871 	if (busra_debug) {
872 		(void) ra_dump_all(NULL, usedpdip);
873 	}
874 #endif
875 	return (NDI_SUCCESS);
876 
877 }
878 
879 #ifdef BUSRA_DEBUG
880 void
ra_dump_all(char * type,dev_info_t * dip)881 ra_dump_all(char *type, dev_info_t *dip)
882 {
883 
884 	struct ra_type_map *typemap;
885 	struct ra_dip_type *dipmap;
886 	struct ra_resource *res;
887 
888 	typemap =  (struct ra_type_map *)ra_map_list_head;
889 
890 	for (; typemap != NULL; typemap = typemap->ra_next) {
891 		if (type != NULL) {
892 			if (strcmp(typemap->type, type) != 0)
893 				continue;
894 		}
895 		cmn_err(CE_CONT, "type is %s\n", typemap->type);
896 		for (dipmap = typemap->ra_dip_list; dipmap != NULL;
897 		    dipmap = dipmap->ra_next) {
898 			if (dip != NULL) {
899 				if ((dipmap->ra_dip) != dip)
900 					continue;
901 			}
902 			cmn_err(CE_CONT, "  dip is %p\n",
903 			    (void *)dipmap->ra_dip);
904 			for (res = dipmap->ra_rangeset; res != NULL;
905 			    res = res->ra_next) {
906 				cmn_err(CE_CONT, "\t  range is %" PRIx64
907 				    " %" PRIx64 "\n", res->ra_base,
908 				    res->ra_len);
909 			}
910 			if (dip != NULL)
911 				break;
912 		}
913 		if (type != NULL)
914 			break;
915 	}
916 }
917 #endif
918 
919 struct bus_range {	/* 1275 "bus-range" property definition */
920 	uint32_t lo;
921 	uint32_t hi;
922 } pci_bus_range;
923 
924 struct busnum_ctrl {
925 	int	rv;
926 	dev_info_t *dip;
927 	struct	bus_range *range;
928 };
929 
930 
931 /*
932  * Setup resource map for the pci bus node based on the "available"
933  * property and "bus-range" property.
934  */
935 int
pci_resource_setup(dev_info_t * dip)936 pci_resource_setup(dev_info_t *dip)
937 {
938 	pci_regspec_t *regs;
939 	int rlen, rcount, i;
940 	char bus_type[16] = "(unknown)";
941 	int len;
942 	struct busnum_ctrl ctrl;
943 	int rval = NDI_SUCCESS;
944 
945 	/*
946 	 * If this is a pci bus node then look for "available" property
947 	 * to find the available resources on this bus.
948 	 */
949 	len = sizeof (bus_type);
950 	if (ddi_prop_op(DDI_DEV_T_ANY, dip, PROP_LEN_AND_VAL_BUF,
951 	    DDI_PROP_CANSLEEP | DDI_PROP_DONTPASS, "device_type",
952 	    (caddr_t)&bus_type, &len) != DDI_SUCCESS)
953 		return (NDI_FAILURE);
954 
955 	/* it is not a pci/pci-ex bus type */
956 	if ((strcmp(bus_type, "pci") != 0) && (strcmp(bus_type, "pciex") != 0))
957 		return (NDI_FAILURE);
958 
959 	/*
960 	 * The pci-hotplug project addresses adding the call
961 	 * to pci_resource_setup from pci nexus driver.
962 	 * However that project would initially be only for x86,
963 	 * so for sparc pcmcia-pci support we still need to call
964 	 * pci_resource_setup in pcic driver. Once all pci nexus drivers
965 	 * are updated to call pci_resource_setup this portion of the
966 	 * code would really become an assert to make sure this
967 	 * function is not called for the same dip twice.
968 	 */
969 	/*
970 	 * Another user for the check below is hotplug PCI/PCIe bridges.
971 	 *
972 	 * For PCI/PCIE devices under a PCIE hierarchy, ndi_ra_alloc/free
973 	 * will update the devinfo node's "available" property, to reflect
974 	 * the fact that a piece of resource has been removed/added to
975 	 * a devinfo node.
976 	 * During probe of a new PCI bridge in the hotplug case, PCI
977 	 * configurator firstly allocates maximum MEM/IO from its parent,
978 	 * then calls ndi_ra_free() to use these resources to setup busra
979 	 * pool for the new bridge, as well as adding these resources to
980 	 * the "available" property of the new devinfo node. Then configu-
981 	 * rator will attach driver for the bridge before probing its
982 	 * children, and the bridge driver will then initialize its hotplug
983 	 * contollers (if it supports hotplug) and HPC driver will call
984 	 * this function to setup the busra pool, but the resource pool
985 	 * has already been setup at the first of pcicfg_probe_bridge(),
986 	 * thus we need the check below to return directly in this case.
987 	 * Otherwise the ndi_ra_free() below will see overlapping resources.
988 	 */
989 	{
990 		if (ra_map_exist(dip, NDI_RA_TYPE_MEM) == NDI_SUCCESS) {
991 			return (NDI_FAILURE);
992 		}
993 	}
994 
995 
996 	/*
997 	 * Create empty resource maps first.
998 	 *
999 	 * NOTE: If all the allocated resources are already assigned to
1000 	 * device(s) in the hot plug slot then "available" property may not
1001 	 * be present. But, subsequent hot plug operation may unconfigure
1002 	 * the device in the slot and try to free up it's resources. So,
1003 	 * at the minimum we should create empty maps here.
1004 	 */
1005 	if (ndi_ra_map_setup(dip, NDI_RA_TYPE_MEM) == NDI_FAILURE) {
1006 		return (NDI_FAILURE);
1007 	}
1008 
1009 	if (ndi_ra_map_setup(dip, NDI_RA_TYPE_IO) == NDI_FAILURE) {
1010 		return (NDI_FAILURE);
1011 	}
1012 
1013 	if (ndi_ra_map_setup(dip, NDI_RA_TYPE_PCI_BUSNUM) == NDI_FAILURE) {
1014 		return (NDI_FAILURE);
1015 	}
1016 
1017 	if (ndi_ra_map_setup(dip, NDI_RA_TYPE_PCI_PREFETCH_MEM) ==
1018 	    NDI_FAILURE) {
1019 		return (NDI_FAILURE);
1020 	}
1021 
1022 	/* read the "available" property if it is available */
1023 	if (ddi_getlongprop(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS,
1024 	    "available", (caddr_t)&regs, &rlen) == DDI_SUCCESS) {
1025 		/*
1026 		 * Remove "available" property as the entries will be
1027 		 * re-created in ndi_ra_free() below, note prom based
1028 		 * property will not be removed. But in ndi_ra_free()
1029 		 * we'll be creating non prom based property entries.
1030 		 */
1031 		(void) ndi_prop_remove(DDI_DEV_T_NONE, dip, "available");
1032 		/*
1033 		 * create the available resource list for both memory and
1034 		 * io space
1035 		 */
1036 		rcount = rlen / sizeof (pci_regspec_t);
1037 		for (i = 0; i < rcount; i++) {
1038 			switch (PCI_REG_ADDR_G(regs[i].pci_phys_hi)) {
1039 			case PCI_REG_ADDR_G(PCI_ADDR_MEM32):
1040 				(void) ndi_ra_free(dip,
1041 				    (uint64_t)regs[i].pci_phys_low,
1042 				    (uint64_t)regs[i].pci_size_low,
1043 				    (regs[i].pci_phys_hi & PCI_REG_PF_M) ?
1044 				    NDI_RA_TYPE_PCI_PREFETCH_MEM :
1045 				    NDI_RA_TYPE_MEM,
1046 				    0);
1047 				break;
1048 			case PCI_REG_ADDR_G(PCI_ADDR_MEM64):
1049 				(void) ndi_ra_free(dip,
1050 				    ((uint64_t)(regs[i].pci_phys_mid) << 32) |
1051 				    ((uint64_t)(regs[i].pci_phys_low)),
1052 				    ((uint64_t)(regs[i].pci_size_hi) << 32) |
1053 				    ((uint64_t)(regs[i].pci_size_low)),
1054 				    (regs[i].pci_phys_hi & PCI_REG_PF_M) ?
1055 				    NDI_RA_TYPE_PCI_PREFETCH_MEM :
1056 				    NDI_RA_TYPE_MEM,
1057 				    0);
1058 				break;
1059 			case PCI_REG_ADDR_G(PCI_ADDR_IO):
1060 				(void) ndi_ra_free(dip,
1061 				    (uint64_t)regs[i].pci_phys_low,
1062 				    (uint64_t)regs[i].pci_size_low,
1063 				    NDI_RA_TYPE_IO,
1064 				    0);
1065 				break;
1066 			case PCI_REG_ADDR_G(PCI_ADDR_CONFIG):
1067 				break;
1068 			default:
1069 				cmn_err(CE_WARN,
1070 				    "pci_resource_setup: bad addr type: %x\n",
1071 				    PCI_REG_ADDR_G(regs[i].pci_phys_hi));
1072 				break;
1073 			}
1074 		}
1075 		kmem_free(regs, rlen);
1076 	}
1077 
1078 	/*
1079 	 * update resource map for available bus numbers if the node
1080 	 * has available-bus-range or bus-range property.
1081 	 */
1082 	len = sizeof (struct bus_range);
1083 	if (ddi_getlongprop_buf(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS,
1084 	    "available-bus-range", (caddr_t)&pci_bus_range, &len) ==
1085 	    DDI_SUCCESS) {
1086 		/*
1087 		 * Add bus numbers in the range to the free list.
1088 		 */
1089 		(void) ndi_ra_free(dip, (uint64_t)pci_bus_range.lo,
1090 		    (uint64_t)pci_bus_range.hi - (uint64_t)pci_bus_range.lo +
1091 		    1, NDI_RA_TYPE_PCI_BUSNUM, 0);
1092 	} else {
1093 		/*
1094 		 * We don't have an available-bus-range property. If, instead,
1095 		 * we have a bus-range property we add all the bus numbers
1096 		 * in that range to the free list but we must then scan
1097 		 * for pci-pci bridges on this bus to find out the if there
1098 		 * are any of those bus numbers already in use. If so, we can
1099 		 * reclaim them.
1100 		 */
1101 		len = sizeof (struct bus_range);
1102 		if (ddi_getlongprop_buf(DDI_DEV_T_ANY, dip,
1103 		    DDI_PROP_DONTPASS, "bus-range", (caddr_t)&pci_bus_range,
1104 		    &len) == DDI_SUCCESS) {
1105 			if (pci_bus_range.lo != pci_bus_range.hi) {
1106 				/*
1107 				 * Add bus numbers other than the secondary
1108 				 * bus number to the free list.
1109 				 */
1110 				(void) ndi_ra_free(dip,
1111 				    (uint64_t)pci_bus_range.lo + 1,
1112 				    (uint64_t)pci_bus_range.hi -
1113 				    (uint64_t)pci_bus_range.lo,
1114 				    NDI_RA_TYPE_PCI_BUSNUM, 0);
1115 
1116 				/* scan for pci-pci bridges */
1117 				ctrl.rv = DDI_SUCCESS;
1118 				ctrl.dip = dip;
1119 				ctrl.range = &pci_bus_range;
1120 				ndi_devi_enter(dip);
1121 				ddi_walk_devs(ddi_get_child(dip),
1122 				    claim_pci_busnum, (void *)&ctrl);
1123 				ndi_devi_exit(dip);
1124 				if (ctrl.rv != DDI_SUCCESS) {
1125 					/* failed to create the map */
1126 					(void) ndi_ra_map_destroy(dip,
1127 					    NDI_RA_TYPE_PCI_BUSNUM);
1128 					rval = NDI_FAILURE;
1129 				}
1130 			}
1131 		}
1132 	}
1133 
1134 #ifdef BUSRA_DEBUG
1135 	if (busra_debug) {
1136 		(void) ra_dump_all(NULL, dip);
1137 	}
1138 #endif
1139 
1140 	return (rval);
1141 }
1142 
1143 /*
1144  * If the device is a PCI bus device (i.e bus-range property exists) then
1145  * claim the bus numbers used by the device from the specified bus
1146  * resource map.
1147  */
1148 static int
claim_pci_busnum(dev_info_t * dip,void * arg)1149 claim_pci_busnum(dev_info_t *dip, void *arg)
1150 {
1151 	struct bus_range pci_bus_range;
1152 	struct busnum_ctrl *ctrl;
1153 	ndi_ra_request_t req;
1154 	char bus_type[16] = "(unknown)";
1155 	int len;
1156 	uint64_t base;
1157 	uint64_t retlen;
1158 
1159 	ctrl = (struct busnum_ctrl *)arg;
1160 
1161 	/* check if this is a PCI bus node */
1162 	len = sizeof (bus_type);
1163 	if (ddi_prop_op(DDI_DEV_T_ANY, dip, PROP_LEN_AND_VAL_BUF,
1164 	    DDI_PROP_CANSLEEP | DDI_PROP_DONTPASS, "device_type",
1165 	    (caddr_t)&bus_type, &len) != DDI_SUCCESS)
1166 		return (DDI_WALK_PRUNECHILD);
1167 
1168 	/* it is not a pci/pci-ex bus type */
1169 	if ((strcmp(bus_type, "pci") != 0) && (strcmp(bus_type, "pciex") != 0))
1170 		return (DDI_WALK_PRUNECHILD);
1171 
1172 	/* look for the bus-range property */
1173 	len = sizeof (struct bus_range);
1174 	if (ddi_getlongprop_buf(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS,
1175 	    "bus-range", (caddr_t)&pci_bus_range, &len) == DDI_SUCCESS) {
1176 		if ((pci_bus_range.lo >= ctrl->range->lo) &&
1177 		    (pci_bus_range.hi <= ctrl->range->hi)) {
1178 
1179 			/* claim the bus range from the bus resource map */
1180 			bzero((caddr_t)&req, sizeof (req));
1181 			req.ra_addr = (uint64_t)pci_bus_range.lo;
1182 			req.ra_flags |= NDI_RA_ALLOC_SPECIFIED;
1183 			req.ra_len = (uint64_t)pci_bus_range.hi -
1184 			    (uint64_t)pci_bus_range.lo + 1;
1185 			if (ndi_ra_alloc(ctrl->dip, &req, &base, &retlen,
1186 			    NDI_RA_TYPE_PCI_BUSNUM, 0) == NDI_SUCCESS)
1187 				return (DDI_WALK_PRUNECHILD);
1188 		}
1189 	}
1190 
1191 	/*
1192 	 * Error return.
1193 	 */
1194 	ctrl->rv = DDI_FAILURE;
1195 	return (DDI_WALK_TERMINATE);
1196 }
1197 
1198 void
pci_resource_destroy(dev_info_t * dip)1199 pci_resource_destroy(dev_info_t *dip)
1200 {
1201 	(void) ndi_ra_map_destroy(dip, NDI_RA_TYPE_IO);
1202 
1203 	(void) ndi_ra_map_destroy(dip, NDI_RA_TYPE_MEM);
1204 
1205 	(void) ndi_ra_map_destroy(dip, NDI_RA_TYPE_PCI_BUSNUM);
1206 
1207 	(void) ndi_ra_map_destroy(dip, NDI_RA_TYPE_PCI_PREFETCH_MEM);
1208 }
1209 
1210 
1211 int
pci_resource_setup_avail(dev_info_t * dip,pci_regspec_t * avail_p,int entries)1212 pci_resource_setup_avail(dev_info_t *dip, pci_regspec_t *avail_p, int entries)
1213 {
1214 	int i;
1215 
1216 	if (ndi_ra_map_setup(dip, NDI_RA_TYPE_MEM) == NDI_FAILURE)
1217 		return (NDI_FAILURE);
1218 	if (ndi_ra_map_setup(dip, NDI_RA_TYPE_IO) == NDI_FAILURE)
1219 		return (NDI_FAILURE);
1220 	if (ndi_ra_map_setup(dip, NDI_RA_TYPE_PCI_PREFETCH_MEM) == NDI_FAILURE)
1221 		return (NDI_FAILURE);
1222 
1223 	/* for each entry in the PCI "available" property */
1224 	for (i = 0; i < entries; i++, avail_p++) {
1225 		if (avail_p->pci_phys_hi == -1u)
1226 			goto err;
1227 
1228 		switch (PCI_REG_ADDR_G(avail_p->pci_phys_hi)) {
1229 		case PCI_REG_ADDR_G(PCI_ADDR_MEM32): {
1230 			(void) ndi_ra_free(dip, (uint64_t)avail_p->pci_phys_low,
1231 			    (uint64_t)avail_p->pci_size_low,
1232 			    (avail_p->pci_phys_hi & PCI_REG_PF_M) ?
1233 			    NDI_RA_TYPE_PCI_PREFETCH_MEM : NDI_RA_TYPE_MEM,
1234 			    0);
1235 			}
1236 			break;
1237 		case PCI_REG_ADDR_G(PCI_ADDR_IO):
1238 			(void) ndi_ra_free(dip, (uint64_t)avail_p->pci_phys_low,
1239 			    (uint64_t)avail_p->pci_size_low, NDI_RA_TYPE_IO, 0);
1240 			break;
1241 		default:
1242 			goto err;
1243 		}
1244 	}
1245 #ifdef BUSRA_DEBUG
1246 	if (busra_debug) {
1247 		(void) ra_dump_all(NULL, dip);
1248 	}
1249 #endif
1250 	return (NDI_SUCCESS);
1251 
1252 err:
1253 	cmn_err(CE_WARN, "pci_resource_setup_avail: bad entry[%d]=%x\n",
1254 	    i, avail_p->pci_phys_hi);
1255 	return (NDI_FAILURE);
1256 }
1257 
1258 /*
1259  * Return true if the devinfo node resides on PCI or PCI Express bus,
1260  * sitting in a PCI Express hierarchy.
1261  */
1262 static boolean_t
is_pcie_fabric(dev_info_t * dip)1263 is_pcie_fabric(dev_info_t *dip)
1264 {
1265 	dev_info_t *root = ddi_root_node();
1266 	dev_info_t *pdip;
1267 	boolean_t found = B_FALSE;
1268 	char *bus;
1269 
1270 	/*
1271 	 * Is this pci/pcie ?
1272 	 */
1273 	if (ddi_prop_lookup_string(DDI_DEV_T_ANY, dip,
1274 	    DDI_PROP_DONTPASS, "device_type", &bus) !=
1275 	    DDI_PROP_SUCCESS) {
1276 		DEBUGPRT(CE_WARN, "is_pcie_fabric: cannot find "
1277 		    "\"device_type\" property for dip %p\n", (void *)dip);
1278 		return (B_FALSE);
1279 	}
1280 
1281 	if (strcmp(bus, "pciex") == 0) {
1282 		/* pcie bus, done */
1283 		ddi_prop_free(bus);
1284 		return (B_TRUE);
1285 	} else if (strcmp(bus, "pci") == 0) {
1286 		/*
1287 		 * pci bus, fall through to check if it resides in
1288 		 * a pcie hierarchy.
1289 		 */
1290 		ddi_prop_free(bus);
1291 	} else {
1292 		/* other bus, return failure */
1293 		ddi_prop_free(bus);
1294 		return (B_FALSE);
1295 	}
1296 
1297 	/*
1298 	 * Does this device reside in a pcie fabric ?
1299 	 */
1300 	for (pdip = ddi_get_parent(dip); pdip && (pdip != root) &&
1301 	    !found; pdip = ddi_get_parent(pdip)) {
1302 		if (ddi_prop_lookup_string(DDI_DEV_T_ANY, pdip,
1303 		    DDI_PROP_DONTPASS, "device_type", &bus) !=
1304 		    DDI_PROP_SUCCESS)
1305 			break;
1306 
1307 		if (strcmp(bus, "pciex") == 0)
1308 			found = B_TRUE;
1309 
1310 		ddi_prop_free(bus);
1311 	}
1312 
1313 	return (found);
1314 }
1315 
1316 /*
1317  * Remove a piece of IO/MEM resource from "available" property of 'dip'.
1318  */
1319 static int
pci_get_available_prop(dev_info_t * dip,uint64_t base,uint64_t len,char * busra_type)1320 pci_get_available_prop(dev_info_t *dip, uint64_t base, uint64_t len,
1321     char *busra_type)
1322 {
1323 	pci_regspec_t	*regs, *newregs;
1324 	uint_t		status;
1325 	int		rlen, rcount;
1326 	int		i, j, k;
1327 	uint64_t	dlen;
1328 	boolean_t	found = B_FALSE;
1329 	uint32_t	type;
1330 
1331 	/* check if we're manipulating MEM/IO resource */
1332 	if ((type = pci_type_ra2pci(busra_type)) == PCI_ADDR_TYPE_INVAL)
1333 		return (DDI_SUCCESS);
1334 
1335 	/* check if dip is a pci/pcie device resides in a pcie fabric */
1336 	if (!is_pcie_fabric(dip))
1337 		return (DDI_SUCCESS);
1338 
1339 	status = ddi_getlongprop(DDI_DEV_T_ANY, dip,
1340 	    DDI_PROP_DONTPASS | DDI_PROP_NOTPROM,
1341 	    "available", (caddr_t)&regs, &rlen);
1342 
1343 	ASSERT(status == DDI_SUCCESS);
1344 	if (status != DDI_SUCCESS)
1345 		return (status);
1346 
1347 	/*
1348 	 * The updated "available" property will at most have one more entry
1349 	 * than existing one (when the requested range is in the middle of
1350 	 * the matched property entry)
1351 	 */
1352 	newregs = kmem_alloc(rlen + sizeof (pci_regspec_t), KM_SLEEP);
1353 
1354 	rcount = rlen / sizeof (pci_regspec_t);
1355 	for (i = 0, j = 0; i < rcount; i++) {
1356 		if (type == (regs[i].pci_phys_hi & PCI_ADDR_TYPE_MASK)) {
1357 			uint64_t range_base, range_len;
1358 
1359 			range_base = ((uint64_t)(regs[i].pci_phys_mid) << 32) |
1360 			    ((uint64_t)(regs[i].pci_phys_low));
1361 			range_len = ((uint64_t)(regs[i].pci_size_hi) << 32) |
1362 			    ((uint64_t)(regs[i].pci_size_low));
1363 
1364 			if ((base < range_base) ||
1365 			    (base + len > range_base + range_len)) {
1366 				/*
1367 				 * not a match, copy the entry
1368 				 */
1369 				goto copy_entry;
1370 			}
1371 
1372 			/*
1373 			 * range_base	base	base+len	range_base
1374 			 *					+range_len
1375 			 *   +------------+-----------+----------+
1376 			 *   |		  |///////////|		 |
1377 			 *   +------------+-----------+----------+
1378 			 */
1379 			/*
1380 			 * Found a match, remove the range out of this entry.
1381 			 */
1382 			found = B_TRUE;
1383 
1384 			dlen = base - range_base;
1385 			if (dlen != 0) {
1386 				newregs[j].pci_phys_hi = regs[i].pci_phys_hi;
1387 				newregs[j].pci_phys_mid =
1388 				    (uint32_t)(range_base >> 32);
1389 				newregs[j].pci_phys_low =
1390 				    (uint32_t)(range_base);
1391 				newregs[j].pci_size_hi = (uint32_t)(dlen >> 32);
1392 				newregs[j].pci_size_low = (uint32_t)dlen;
1393 				j++;
1394 			}
1395 
1396 			dlen = (range_base + range_len) - (base + len);
1397 			if (dlen != 0) {
1398 				newregs[j].pci_phys_hi = regs[i].pci_phys_hi;
1399 				newregs[j].pci_phys_mid =
1400 				    (uint32_t)((base + len)>> 32);
1401 				newregs[j].pci_phys_low =
1402 				    (uint32_t)(base + len);
1403 				newregs[j].pci_size_hi = (uint32_t)(dlen >> 32);
1404 				newregs[j].pci_size_low = (uint32_t)dlen;
1405 				j++;
1406 			}
1407 
1408 			/*
1409 			 * We've allocated the resource from the matched
1410 			 * entry, almost finished but still need to copy
1411 			 * the rest entries from the original property
1412 			 * array.
1413 			 */
1414 			for (k = i + 1; k < rcount; k++) {
1415 				newregs[j] = regs[k];
1416 				j++;
1417 			}
1418 
1419 			goto done;
1420 
1421 		} else {
1422 copy_entry:
1423 			newregs[j] = regs[i];
1424 			j++;
1425 		}
1426 	}
1427 
1428 done:
1429 	/*
1430 	 * This should not fail so assert it. For non-debug kernel we don't
1431 	 * want to panic thus only logging a warning message.
1432 	 */
1433 	ASSERT(found == B_TRUE);
1434 	if (!found) {
1435 		cmn_err(CE_WARN, "pci_get_available_prop: failed to remove "
1436 		    "resource from dip %p : base 0x%" PRIx64 ", len 0x%" PRIX64
1437 		    ", type 0x%x\n", (void *)dip, base, len, type);
1438 		kmem_free(newregs, rlen + sizeof (pci_regspec_t));
1439 		kmem_free(regs, rlen);
1440 
1441 		return (DDI_FAILURE);
1442 	}
1443 
1444 	/*
1445 	 * Found the resources from parent, update the "available"
1446 	 * property.
1447 	 */
1448 	if (j == 0) {
1449 		/* all the resources are consumed, remove the property */
1450 		(void) ndi_prop_remove(DDI_DEV_T_NONE, dip, "available");
1451 	} else {
1452 		/*
1453 		 * There are still resource available in the parent dip,
1454 		 * update with the remaining resources.
1455 		 */
1456 		(void) ndi_prop_update_int_array(DDI_DEV_T_NONE, dip,
1457 		    "available", (int *)newregs,
1458 		    (j * sizeof (pci_regspec_t)) / sizeof (int));
1459 	}
1460 
1461 	kmem_free(newregs, rlen + sizeof (pci_regspec_t));
1462 	kmem_free(regs, rlen);
1463 
1464 	return (DDI_SUCCESS);
1465 }
1466 
1467 /*
1468  * Add a piece of IO/MEM resource to "available" property of 'dip'.
1469  */
1470 static int
pci_put_available_prop(dev_info_t * dip,uint64_t base,uint64_t len,char * busra_type)1471 pci_put_available_prop(dev_info_t *dip, uint64_t base, uint64_t len,
1472     char *busra_type)
1473 {
1474 	pci_regspec_t	*regs, *newregs;
1475 	uint_t		status;
1476 	int		rlen, rcount;
1477 	int		i, j, k;
1478 	int		matched = 0;
1479 	uint64_t	orig_base = base;
1480 	uint64_t	orig_len = len;
1481 	uint32_t	type;
1482 
1483 	/* check if we're manipulating MEM/IO resource */
1484 	if ((type = pci_type_ra2pci(busra_type)) == PCI_ADDR_TYPE_INVAL)
1485 		return (DDI_SUCCESS);
1486 
1487 	/* check if dip is a pci/pcie device resides in a pcie fabric */
1488 	if (!is_pcie_fabric(dip))
1489 		return (DDI_SUCCESS);
1490 
1491 	status = ddi_getlongprop(DDI_DEV_T_ANY, dip,
1492 	    DDI_PROP_DONTPASS | DDI_PROP_NOTPROM,
1493 	    "available", (caddr_t)&regs, &rlen);
1494 
1495 	switch (status) {
1496 		case DDI_PROP_NOT_FOUND:
1497 			goto not_found;
1498 
1499 		case DDI_PROP_SUCCESS:
1500 			break;
1501 
1502 		default:
1503 			return (status);
1504 	}
1505 
1506 	/*
1507 	 * The "available" property exist on the node, try to put this
1508 	 * resource back, merge if there are adjacent resources.
1509 	 *
1510 	 * The updated "available" property will at most have one more entry
1511 	 * than existing one (when there is no adjacent entries thus the new
1512 	 * resource is appended at the end)
1513 	 */
1514 	newregs = kmem_alloc(rlen + sizeof (pci_regspec_t), KM_SLEEP);
1515 
1516 	rcount = rlen / sizeof (pci_regspec_t);
1517 	for (i = 0, j = 0; i < rcount; i++) {
1518 		if (type == (regs[i].pci_phys_hi & PCI_ADDR_TYPE_MASK)) {
1519 			uint64_t range_base, range_len;
1520 
1521 			range_base = ((uint64_t)(regs[i].pci_phys_mid) << 32) |
1522 			    ((uint64_t)(regs[i].pci_phys_low));
1523 			range_len = ((uint64_t)(regs[i].pci_size_hi) << 32) |
1524 			    ((uint64_t)(regs[i].pci_size_low));
1525 
1526 			if ((base + len < range_base) ||
1527 			    (base > range_base + range_len)) {
1528 				/*
1529 				 * Not adjacent, copy the entry and contiue
1530 				 */
1531 				goto copy_entry;
1532 			}
1533 
1534 			/*
1535 			 * Adjacent or overlap?
1536 			 *
1537 			 * Should not have overlapping resources so assert it.
1538 			 * For non-debug kernel we don't want to panic thus
1539 			 * only logging a warning message.
1540 			 */
1541 #if 0
1542 			ASSERT((base + len == range_base) ||
1543 			    (base == range_base + range_len));
1544 #endif
1545 			if ((base + len != range_base) &&
1546 			    (base != range_base + range_len)) {
1547 				cmn_err(CE_WARN, "pci_put_available_prop: "
1548 				    "failed to add resource to dip %p : "
1549 				    "base 0x%" PRIx64 ", len 0x%" PRIx64 " "
1550 				    "overlaps with existing resource "
1551 				    "base 0x%" PRIx64 ", len 0x%" PRIx64 "\n",
1552 				    (void *)dip, orig_base, orig_len,
1553 				    range_base, range_len);
1554 
1555 				goto failure;
1556 			}
1557 
1558 			/*
1559 			 * On the left:
1560 			 *
1561 			 * base		range_base
1562 			 *   +-------------+-------------+
1563 			 *   |/////////////|		 |
1564 			 *   +-------------+-------------+
1565 			 *	len		range_len
1566 			 *
1567 			 * On the right:
1568 			 *
1569 			 * range_base	 base
1570 			 *   +-------------+-------------+
1571 			 *   |		   |/////////////|
1572 			 *   +-------------+-------------+
1573 			 *	range_len	len
1574 			 */
1575 			/*
1576 			 * There are at most two piece of resources adjacent
1577 			 * with this resource, assert it.
1578 			 */
1579 			ASSERT(matched < 2);
1580 
1581 			if (!(matched < 2)) {
1582 				cmn_err(CE_WARN, "pci_put_available_prop: "
1583 				    "failed to add resource to dip %p : "
1584 				    "base 0x%" PRIx64 ", len 0x%" PRIx64 " "
1585 				    "found overlaps in existing resources\n",
1586 				    (void *)dip, orig_base, orig_len);
1587 
1588 				goto failure;
1589 			}
1590 
1591 			/* setup base & len to refer to the merged range */
1592 			len += range_len;
1593 			if (base == range_base + range_len)
1594 				base = range_base;
1595 
1596 			if (matched == 0) {
1597 				/*
1598 				 * One adjacent entry, add this resource in
1599 				 */
1600 				newregs[j].pci_phys_hi = regs[i].pci_phys_hi;
1601 				newregs[j].pci_phys_mid =
1602 				    (uint32_t)(base >> 32);
1603 				newregs[j].pci_phys_low = (uint32_t)(base);
1604 				newregs[j].pci_size_hi = (uint32_t)(len >> 32);
1605 				newregs[j].pci_size_low = (uint32_t)len;
1606 
1607 				matched = 1;
1608 				k = j;
1609 				j++;
1610 			} else { /* matched == 1 */
1611 				/*
1612 				 * Two adjacent entries, merge them together
1613 				 */
1614 				newregs[k].pci_phys_hi = regs[i].pci_phys_hi;
1615 				newregs[k].pci_phys_mid =
1616 				    (uint32_t)(base >> 32);
1617 				newregs[k].pci_phys_low = (uint32_t)(base);
1618 				newregs[k].pci_size_hi = (uint32_t)(len >> 32);
1619 				newregs[k].pci_size_low = (uint32_t)len;
1620 
1621 				matched = 2;
1622 			}
1623 		} else {
1624 copy_entry:
1625 			newregs[j] = regs[i];
1626 			j++;
1627 		}
1628 	}
1629 
1630 	if (matched == 0) {
1631 		/* No adjacent entries, append at end */
1632 		ASSERT(j == rcount);
1633 
1634 		/*
1635 		 * According to page 15 of 1275 spec, bit "n" of "available"
1636 		 * should be set to 1.
1637 		 */
1638 		newregs[j].pci_phys_hi = type;
1639 		newregs[j].pci_phys_hi |= PCI_REG_REL_M;
1640 
1641 		newregs[j].pci_phys_mid = (uint32_t)(base >> 32);
1642 		newregs[j].pci_phys_low = (uint32_t)base;
1643 		newregs[j].pci_size_hi = (uint32_t)(len >> 32);
1644 		newregs[j].pci_size_low = (uint32_t)len;
1645 
1646 		j++;
1647 	}
1648 
1649 	(void) ndi_prop_update_int_array(DDI_DEV_T_NONE, dip,
1650 	    "available", (int *)newregs,
1651 	    (j * sizeof (pci_regspec_t)) / sizeof (int));
1652 
1653 	kmem_free(newregs, rlen + sizeof (pci_regspec_t));
1654 	kmem_free(regs, rlen);
1655 	return (DDI_SUCCESS);
1656 
1657 not_found:
1658 	/*
1659 	 * There is no "available" property on the parent node, create it.
1660 	 */
1661 	newregs = kmem_alloc(sizeof (pci_regspec_t), KM_SLEEP);
1662 
1663 	/*
1664 	 * According to page 15 of 1275 spec, bit "n" of "available" should
1665 	 * be set to 1.
1666 	 */
1667 	newregs[0].pci_phys_hi = type;
1668 	newregs[0].pci_phys_hi |= PCI_REG_REL_M;
1669 
1670 	newregs[0].pci_phys_mid = (uint32_t)(base >> 32);
1671 	newregs[0].pci_phys_low = (uint32_t)base;
1672 	newregs[0].pci_size_hi = (uint32_t)(len >> 32);
1673 	newregs[0].pci_size_low = (uint32_t)len;
1674 
1675 	(void) ndi_prop_update_int_array(DDI_DEV_T_NONE, dip,
1676 	    "available", (int *)newregs,
1677 	    sizeof (pci_regspec_t) / sizeof (int));
1678 	kmem_free(newregs, sizeof (pci_regspec_t));
1679 	return (DDI_SUCCESS);
1680 
1681 failure:
1682 	kmem_free(newregs, rlen + sizeof (pci_regspec_t));
1683 	kmem_free(regs, rlen);
1684 	return (DDI_FAILURE);
1685 }
1686 
1687 static uint32_t
pci_type_ra2pci(char * type)1688 pci_type_ra2pci(char *type)
1689 {
1690 	uint32_t	pci_type = PCI_ADDR_TYPE_INVAL;
1691 
1692 	/*
1693 	 * No 64 bit mem support for now
1694 	 */
1695 	if (strcmp(type, NDI_RA_TYPE_IO) == 0) {
1696 		pci_type = PCI_ADDR_IO;
1697 
1698 	} else if (strcmp(type, NDI_RA_TYPE_MEM) == 0) {
1699 		pci_type = PCI_ADDR_MEM32;
1700 
1701 	} else if (strcmp(type, NDI_RA_TYPE_PCI_PREFETCH_MEM)  == 0) {
1702 		pci_type = PCI_ADDR_MEM32;
1703 		pci_type |= PCI_REG_PF_M;
1704 	}
1705 
1706 	return (pci_type);
1707 }
1708