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