xref: /illumos-gate/usr/src/uts/i86pc/os/ddi_impl.c (revision cdd3e9a818787b4def17c9f707f435885ce0ed31)
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 /*
23  * Copyright (c) 1992, 2010, Oracle and/or its affiliates. All rights reserved.
24  * Copyright 2012 Garrett D'Amore <garrett@damore.org>
25  * Copyright 2014 Pluribus Networks, Inc.
26  * Copyright 2016 Nexenta Systems, Inc.
27  * Copyright 2018 Joyent, Inc.
28  */
29 
30 /*
31  * PC specific DDI implementation
32  */
33 #include <sys/types.h>
34 #include <sys/autoconf.h>
35 #include <sys/avintr.h>
36 #include <sys/bootconf.h>
37 #include <sys/conf.h>
38 #include <sys/cpuvar.h>
39 #include <sys/ddi_impldefs.h>
40 #include <sys/ddi_subrdefs.h>
41 #include <sys/ethernet.h>
42 #include <sys/fp.h>
43 #include <sys/instance.h>
44 #include <sys/kmem.h>
45 #include <sys/machsystm.h>
46 #include <sys/modctl.h>
47 #include <sys/promif.h>
48 #include <sys/prom_plat.h>
49 #include <sys/sunndi.h>
50 #include <sys/ndi_impldefs.h>
51 #include <sys/ddi_impldefs.h>
52 #include <sys/sysmacros.h>
53 #include <sys/systeminfo.h>
54 #include <sys/utsname.h>
55 #include <sys/atomic.h>
56 #include <sys/spl.h>
57 #include <sys/archsystm.h>
58 #include <vm/seg_kmem.h>
59 #include <sys/ontrap.h>
60 #include <sys/fm/protocol.h>
61 #include <sys/ramdisk.h>
62 #include <sys/sunndi.h>
63 #include <sys/vmem.h>
64 #include <sys/pci_impl.h>
65 #if defined(__xpv)
66 #include <sys/hypervisor.h>
67 #endif
68 #include <sys/mach_intr.h>
69 #include <vm/hat_i86.h>
70 #include <sys/x86_archext.h>
71 #include <sys/avl.h>
72 #include <sys/font.h>
73 
74 /*
75  * DDI Boot Configuration
76  */
77 
78 /*
79  * Platform drivers on this platform
80  */
81 char *platform_module_list[] = {
82 	"acpippm",
83 	"ppm",
84 	(char *)0
85 };
86 
87 /* pci bus resource maps */
88 struct pci_bus_resource *pci_bus_res;
89 
90 size_t dma_max_copybuf_size = 0x101000;		/* 1M + 4K */
91 
92 uint64_t ramdisk_start, ramdisk_end;
93 
94 int pseudo_isa = 0;
95 
96 /*
97  * Forward declarations
98  */
99 static int getlongprop_buf();
100 static void get_boot_properties(void);
101 static void impl_bus_initialprobe(void);
102 static void impl_bus_reprobe(void);
103 
104 static int poke_mem(peekpoke_ctlops_t *in_args);
105 static int peek_mem(peekpoke_ctlops_t *in_args);
106 
107 static int kmem_override_cache_attrs(caddr_t, size_t, uint_t);
108 
109 #if !defined(__xpv)
110 extern void immu_init(void);
111 #endif
112 
113 /*
114  * We use an AVL tree to store contiguous address allocations made with the
115  * kalloca() routine, so that we can return the size to free with kfreea().
116  * Note that in the future it would be vastly faster if we could eliminate
117  * this lookup by insisting that all callers keep track of their own sizes,
118  * just as for kmem_alloc().
119  */
120 struct ctgas {
121 	avl_node_t ctg_link;
122 	void *ctg_addr;
123 	size_t ctg_size;
124 };
125 
126 static avl_tree_t ctgtree;
127 
128 static kmutex_t		ctgmutex;
129 #define	CTGLOCK()	mutex_enter(&ctgmutex)
130 #define	CTGUNLOCK()	mutex_exit(&ctgmutex)
131 
132 /*
133  * Minimum pfn value of page_t's put on the free list.  This is to simplify
134  * support of ddi dma memory requests which specify small, non-zero addr_lo
135  * values.
136  *
137  * The default value of 2, which corresponds to the only known non-zero addr_lo
138  * value used, means a single page will be sacrificed (pfn typically starts
139  * at 1).  ddiphysmin can be set to 0 to disable. It cannot be set above 0x100
140  * otherwise mp startup panics.
141  */
142 pfn_t	ddiphysmin = 2;
143 
144 static void
check_driver_disable(void)145 check_driver_disable(void)
146 {
147 	int proplen = 128;
148 	char *prop_name;
149 	char *drv_name, *propval;
150 	major_t major;
151 
152 	prop_name = kmem_alloc(proplen, KM_SLEEP);
153 	for (major = 0; major < devcnt; major++) {
154 		drv_name = ddi_major_to_name(major);
155 		if (drv_name == NULL)
156 			continue;
157 		(void) snprintf(prop_name, proplen, "disable-%s", drv_name);
158 		if (ddi_prop_lookup_string(DDI_DEV_T_ANY, ddi_root_node(),
159 		    DDI_PROP_DONTPASS, prop_name, &propval) == DDI_SUCCESS) {
160 			if (strcmp(propval, "true") == 0) {
161 				devnamesp[major].dn_flags |= DN_DRIVER_REMOVED;
162 				cmn_err(CE_NOTE, "driver %s disabled",
163 				    drv_name);
164 			}
165 			ddi_prop_free(propval);
166 		}
167 	}
168 	kmem_free(prop_name, proplen);
169 }
170 
171 
172 /*
173  * Configure the hardware on the system.
174  * Called before the rootfs is mounted
175  */
176 void
configure(void)177 configure(void)
178 {
179 	extern void i_ddi_init_root();
180 
181 	extern int fpu_ignored;
182 
183 	/*
184 	 * Determine if an FPU is attached
185 	 */
186 
187 	fpu_probe();
188 
189 
190 	if (fpu_ignored) {
191 		printf("FP hardware will not be used\n");
192 	} else if (!fpu_exists) {
193 		printf("No FPU in configuration\n");
194 	}
195 
196 	/*
197 	 * Initialize devices on the machine.
198 	 * Uses configuration tree built by the PROMs to determine what
199 	 * is present, and builds a tree of prototype dev_info nodes
200 	 * corresponding to the hardware which identified itself.
201 	 */
202 
203 	/*
204 	 * Initialize root node.
205 	 */
206 	i_ddi_init_root();
207 
208 	/* reprogram devices not set up by firmware (BIOS) */
209 	impl_bus_reprobe();
210 
211 #if !defined(__xpv)
212 	/*
213 	 * Setup but don't startup the IOMMU
214 	 * Startup happens later via a direct call
215 	 * to IOMMU code by boot code.
216 	 * At this point, all PCI bus renumbering
217 	 * is done, so safe to init the IMMU
218 	 * AKA Intel IOMMU.
219 	 */
220 	immu_init();
221 #endif
222 
223 	/*
224 	 * attach the isa nexus to get ACPI resource usage
225 	 * isa is "kind of" a pseudo node
226 	 */
227 #if defined(__xpv)
228 	if (DOMAIN_IS_INITDOMAIN(xen_info)) {
229 		if (pseudo_isa)
230 			(void) i_ddi_attach_pseudo_node("isa");
231 		else
232 			(void) i_ddi_attach_hw_nodes("isa");
233 	}
234 #else
235 	if (pseudo_isa)
236 		(void) i_ddi_attach_pseudo_node("isa");
237 	else
238 		(void) i_ddi_attach_hw_nodes("isa");
239 #endif
240 }
241 
242 /*
243  * The "status" property indicates the operational status of a device.
244  * If this property is present, the value is a string indicating the
245  * status of the device as follows:
246  *
247  *	"okay"		operational.
248  *	"disabled"	not operational, but might become operational.
249  *	"fail"		not operational because a fault has been detected,
250  *			and it is unlikely that the device will become
251  *			operational without repair. no additional details
252  *			are available.
253  *	"fail-xxx"	not operational because a fault has been detected,
254  *			and it is unlikely that the device will become
255  *			operational without repair. "xxx" is additional
256  *			human-readable information about the particular
257  *			fault condition that was detected.
258  *
259  * The absence of this property means that the operational status is
260  * unknown or okay.
261  *
262  * This routine checks the status property of the specified device node
263  * and returns 0 if the operational status indicates failure, and 1 otherwise.
264  *
265  * The property may exist on plug-in cards the existed before IEEE 1275-1994.
266  * And, in that case, the property may not even be a string. So we carefully
267  * check for the value "fail", in the beginning of the string, noting
268  * the property length.
269  */
270 int
status_okay(int id,char * buf,int buflen)271 status_okay(int id, char *buf, int buflen)
272 {
273 	char status_buf[OBP_MAXPROPNAME];
274 	char *bufp = buf;
275 	int len = buflen;
276 	int proplen;
277 	static const char *status = "status";
278 	static const char *fail = "fail";
279 	int fail_len = (int)strlen(fail);
280 
281 	/*
282 	 * Get the proplen ... if it's smaller than "fail",
283 	 * or doesn't exist ... then we don't care, since
284 	 * the value can't begin with the char string "fail".
285 	 *
286 	 * NB: proplen, if it's a string, includes the NULL in the
287 	 * the size of the property, and fail_len does not.
288 	 */
289 	proplen = prom_getproplen((pnode_t)id, (caddr_t)status);
290 	if (proplen <= fail_len)	/* nonexistant or uninteresting len */
291 		return (1);
292 
293 	/*
294 	 * if a buffer was provided, use it
295 	 */
296 	if ((buf == (char *)NULL) || (buflen <= 0)) {
297 		bufp = status_buf;
298 		len = sizeof (status_buf);
299 	}
300 	*bufp = (char)0;
301 
302 	/*
303 	 * Get the property into the buffer, to the extent of the buffer,
304 	 * and in case the buffer is smaller than the property size,
305 	 * NULL terminate the buffer. (This handles the case where
306 	 * a buffer was passed in and the caller wants to print the
307 	 * value, but the buffer was too small).
308 	 */
309 	(void) prom_bounded_getprop((pnode_t)id, (caddr_t)status,
310 	    (caddr_t)bufp, len);
311 	*(bufp + len - 1) = (char)0;
312 
313 	/*
314 	 * If the value begins with the char string "fail",
315 	 * then it means the node is failed. We don't care
316 	 * about any other values. We assume the node is ok
317 	 * although it might be 'disabled'.
318 	 */
319 	if (strncmp(bufp, fail, fail_len) == 0)
320 		return (0);
321 
322 	return (1);
323 }
324 
325 /*
326  * Check the status of the device node passed as an argument.
327  *
328  *	if ((status is OKAY) || (status is DISABLED))
329  *		return DDI_SUCCESS
330  *	else
331  *		print a warning and return DDI_FAILURE
332  */
333 /*ARGSUSED1*/
334 int
check_status(int id,char * name,dev_info_t * parent)335 check_status(int id, char *name, dev_info_t *parent)
336 {
337 	char status_buf[64];
338 	char devtype_buf[OBP_MAXPROPNAME];
339 	int retval = DDI_FAILURE;
340 
341 	/*
342 	 * is the status okay?
343 	 */
344 	if (status_okay(id, status_buf, sizeof (status_buf)))
345 		return (DDI_SUCCESS);
346 
347 	/*
348 	 * a status property indicating bad memory will be associated
349 	 * with a node which has a "device_type" property with a value of
350 	 * "memory-controller". in this situation, return DDI_SUCCESS
351 	 */
352 	if (getlongprop_buf(id, OBP_DEVICETYPE, devtype_buf,
353 	    sizeof (devtype_buf)) > 0) {
354 		if (strcmp(devtype_buf, "memory-controller") == 0)
355 			retval = DDI_SUCCESS;
356 	}
357 
358 	/*
359 	 * print the status property information
360 	 */
361 	cmn_err(CE_WARN, "status '%s' for '%s'", status_buf, name);
362 	return (retval);
363 }
364 
365 /*ARGSUSED*/
366 uint_t
softlevel1(caddr_t arg1,caddr_t arg2)367 softlevel1(caddr_t arg1, caddr_t arg2)
368 {
369 	softint();
370 	return (1);
371 }
372 
373 /*
374  * Allow for implementation specific correction of PROM property values.
375  */
376 
377 /*ARGSUSED*/
378 void
impl_fix_props(dev_info_t * dip,dev_info_t * ch_dip,char * name,int len,caddr_t buffer)379 impl_fix_props(dev_info_t *dip, dev_info_t *ch_dip, char *name, int len,
380     caddr_t buffer)
381 {
382 	/*
383 	 * There are no adjustments needed in this implementation.
384 	 */
385 }
386 
387 static int
getlongprop_buf(int id,char * name,char * buf,int maxlen)388 getlongprop_buf(int id, char *name, char *buf, int maxlen)
389 {
390 	int size;
391 
392 	size = prom_getproplen((pnode_t)id, name);
393 	if (size <= 0 || (size > maxlen - 1))
394 		return (-1);
395 
396 	if (-1 == prom_getprop((pnode_t)id, name, buf))
397 		return (-1);
398 
399 	if (strcmp("name", name) == 0) {
400 		if (buf[size - 1] != '\0') {
401 			buf[size] = '\0';
402 			size += 1;
403 		}
404 	}
405 
406 	return (size);
407 }
408 
409 static int
get_prop_int_array(dev_info_t * di,char * pname,int ** pval,uint_t * plen)410 get_prop_int_array(dev_info_t *di, char *pname, int **pval, uint_t *plen)
411 {
412 	int ret;
413 
414 	if ((ret = ddi_prop_lookup_int_array(DDI_DEV_T_ANY, di,
415 	    DDI_PROP_DONTPASS, pname, pval, plen))
416 	    == DDI_PROP_SUCCESS) {
417 		*plen = (*plen) * (sizeof (int));
418 	}
419 	return (ret);
420 }
421 
422 
423 /*
424  * Node Configuration
425  */
426 
427 struct prop_ispec {
428 	uint_t	pri, vec;
429 };
430 
431 /*
432  * For the x86, we're prepared to claim that the interrupt string
433  * is in the form of a list of <ipl,vec> specifications.
434  */
435 
436 #define	VEC_MIN	1
437 #define	VEC_MAX	255
438 
439 static int
impl_xlate_intrs(dev_info_t * child,int * in,struct ddi_parent_private_data * pdptr)440 impl_xlate_intrs(dev_info_t *child, int *in,
441     struct ddi_parent_private_data *pdptr)
442 {
443 	size_t size;
444 	int n;
445 	struct intrspec *new;
446 	caddr_t got_prop;
447 	int *inpri;
448 	int got_len;
449 	extern int ignore_hardware_nodes;	/* force flag from ddi_impl.c */
450 
451 	static char bad_intr_fmt[] =
452 	    "bad interrupt spec from %s%d - ipl %d, irq %d\n";
453 
454 	/*
455 	 * determine if the driver is expecting the new style "interrupts"
456 	 * property which just contains the IRQ, or the old style which
457 	 * contains pairs of <IPL,IRQ>.  if it is the new style, we always
458 	 * assign IPL 5 unless an "interrupt-priorities" property exists.
459 	 * in that case, the "interrupt-priorities" property contains the
460 	 * IPL values that match, one for one, the IRQ values in the
461 	 * "interrupts" property.
462 	 */
463 	inpri = NULL;
464 	if ((ddi_getprop(DDI_DEV_T_ANY, child, DDI_PROP_DONTPASS,
465 	    "ignore-hardware-nodes", -1) != -1) || ignore_hardware_nodes) {
466 		/* the old style "interrupts" property... */
467 
468 		/*
469 		 * The list consists of <ipl,vec> elements
470 		 */
471 		if ((n = (*in++ >> 1)) < 1)
472 			return (DDI_FAILURE);
473 
474 		pdptr->par_nintr = n;
475 		size = n * sizeof (struct intrspec);
476 		new = pdptr->par_intr = kmem_zalloc(size, KM_SLEEP);
477 
478 		while (n--) {
479 			int level = *in++;
480 			int vec = *in++;
481 
482 			if (level < 1 || level > MAXIPL ||
483 			    vec < VEC_MIN || vec > VEC_MAX) {
484 				cmn_err(CE_CONT, bad_intr_fmt,
485 				    DEVI(child)->devi_name,
486 				    DEVI(child)->devi_instance, level, vec);
487 				goto broken;
488 			}
489 			new->intrspec_pri = level;
490 			if (vec != 2)
491 				new->intrspec_vec = vec;
492 			else
493 				/*
494 				 * irq 2 on the PC bus is tied to irq 9
495 				 * on ISA, EISA and MicroChannel
496 				 */
497 				new->intrspec_vec = 9;
498 			new++;
499 		}
500 
501 		return (DDI_SUCCESS);
502 	} else {
503 		/* the new style "interrupts" property... */
504 
505 		/*
506 		 * The list consists of <vec> elements
507 		 */
508 		if ((n = (*in++)) < 1)
509 			return (DDI_FAILURE);
510 
511 		pdptr->par_nintr = n;
512 		size = n * sizeof (struct intrspec);
513 		new = pdptr->par_intr = kmem_zalloc(size, KM_SLEEP);
514 
515 		/* XXX check for "interrupt-priorities" property... */
516 		if (ddi_getlongprop(DDI_DEV_T_ANY, child, DDI_PROP_DONTPASS,
517 		    "interrupt-priorities", (caddr_t)&got_prop, &got_len)
518 		    == DDI_PROP_SUCCESS) {
519 			if (n != (got_len / sizeof (int))) {
520 				cmn_err(CE_CONT,
521 				    "bad interrupt-priorities length"
522 				    " from %s%d: expected %d, got %d\n",
523 				    DEVI(child)->devi_name,
524 				    DEVI(child)->devi_instance, n,
525 				    (int)(got_len / sizeof (int)));
526 				goto broken;
527 			}
528 			inpri = (int *)got_prop;
529 		}
530 
531 		while (n--) {
532 			int level;
533 			int vec = *in++;
534 
535 			if (inpri == NULL)
536 				level = 5;
537 			else
538 				level = *inpri++;
539 
540 			if (level < 1 || level > MAXIPL ||
541 			    vec < VEC_MIN || vec > VEC_MAX) {
542 				cmn_err(CE_CONT, bad_intr_fmt,
543 				    DEVI(child)->devi_name,
544 				    DEVI(child)->devi_instance, level, vec);
545 				goto broken;
546 			}
547 			new->intrspec_pri = level;
548 			if (vec != 2)
549 				new->intrspec_vec = vec;
550 			else
551 				/*
552 				 * irq 2 on the PC bus is tied to irq 9
553 				 * on ISA, EISA and MicroChannel
554 				 */
555 				new->intrspec_vec = 9;
556 			new++;
557 		}
558 
559 		if (inpri != NULL)
560 			kmem_free(got_prop, got_len);
561 		return (DDI_SUCCESS);
562 	}
563 
564 broken:
565 	kmem_free(pdptr->par_intr, size);
566 	pdptr->par_intr = NULL;
567 	pdptr->par_nintr = 0;
568 	if (inpri != NULL)
569 		kmem_free(got_prop, got_len);
570 
571 	return (DDI_FAILURE);
572 }
573 
574 /*
575  * Create a ddi_parent_private_data structure from the ddi properties of
576  * the dev_info node.
577  *
578  * The "reg" and either an "intr" or "interrupts" properties are required
579  * if the driver wishes to create mappings or field interrupts on behalf
580  * of the device.
581  *
582  * The "reg" property is assumed to be a list of at least one triple
583  *
584  *	<bustype, address, size>*1
585  *
586  * The "intr" property is assumed to be a list of at least one duple
587  *
588  *	<SPARC ipl, vector#>*1
589  *
590  * The "interrupts" property is assumed to be a list of at least one
591  * n-tuples that describes the interrupt capabilities of the bus the device
592  * is connected to.  For SBus, this looks like
593  *
594  *	<SBus-level>*1
595  *
596  * (This property obsoletes the 'intr' property).
597  *
598  * The "ranges" property is optional.
599  */
600 void
make_ddi_ppd(dev_info_t * child,struct ddi_parent_private_data ** ppd)601 make_ddi_ppd(dev_info_t *child, struct ddi_parent_private_data **ppd)
602 {
603 	struct ddi_parent_private_data *pdptr;
604 	int n;
605 	int *reg_prop, *rng_prop, *intr_prop, *irupts_prop;
606 	uint_t reg_len, rng_len, intr_len, irupts_len;
607 
608 	*ppd = pdptr = kmem_zalloc(sizeof (*pdptr), KM_SLEEP);
609 
610 	/*
611 	 * Handle the 'reg' property.
612 	 */
613 	if ((get_prop_int_array(child, "reg", &reg_prop, &reg_len) ==
614 	    DDI_PROP_SUCCESS) && (reg_len != 0)) {
615 		pdptr->par_nreg = reg_len / (int)sizeof (struct regspec);
616 		pdptr->par_reg = (struct regspec *)reg_prop;
617 	}
618 
619 	/*
620 	 * See if I have a range (adding one where needed - this
621 	 * means to add one for sbus node in sun4c, when romvec > 0,
622 	 * if no range is already defined in the PROM node.
623 	 * (Currently no sun4c PROMS define range properties,
624 	 * but they should and may in the future.)  For the SBus
625 	 * node, the range is defined by the SBus reg property.
626 	 */
627 	if (get_prop_int_array(child, "ranges", &rng_prop, &rng_len)
628 	    == DDI_PROP_SUCCESS) {
629 		pdptr->par_nrng = rng_len / (int)(sizeof (struct rangespec));
630 		pdptr->par_rng = (struct rangespec *)rng_prop;
631 	}
632 
633 	/*
634 	 * Handle the 'intr' and 'interrupts' properties
635 	 */
636 
637 	/*
638 	 * For backwards compatibility
639 	 * we first look for the 'intr' property for the device.
640 	 */
641 	if (get_prop_int_array(child, "intr", &intr_prop, &intr_len)
642 	    != DDI_PROP_SUCCESS) {
643 		intr_len = 0;
644 	}
645 
646 	/*
647 	 * If we're to support bus adapters and future platforms cleanly,
648 	 * we need to support the generalized 'interrupts' property.
649 	 */
650 	if (get_prop_int_array(child, "interrupts", &irupts_prop,
651 	    &irupts_len) != DDI_PROP_SUCCESS) {
652 		irupts_len = 0;
653 	} else if (intr_len != 0) {
654 		/*
655 		 * If both 'intr' and 'interrupts' are defined,
656 		 * then 'interrupts' wins and we toss the 'intr' away.
657 		 */
658 		ddi_prop_free((void *)intr_prop);
659 		intr_len = 0;
660 	}
661 
662 	if (intr_len != 0) {
663 
664 		/*
665 		 * Translate the 'intr' property into an array
666 		 * an array of struct intrspec's.  There's not really
667 		 * very much to do here except copy what's out there.
668 		 */
669 
670 		struct intrspec *new;
671 		struct prop_ispec *l;
672 
673 		n = pdptr->par_nintr = intr_len / sizeof (struct prop_ispec);
674 		l = (struct prop_ispec *)intr_prop;
675 		pdptr->par_intr =
676 		    new = kmem_zalloc(n * sizeof (struct intrspec), KM_SLEEP);
677 		while (n--) {
678 			new->intrspec_pri = l->pri;
679 			new->intrspec_vec = l->vec;
680 			new++;
681 			l++;
682 		}
683 		ddi_prop_free((void *)intr_prop);
684 
685 	} else if ((n = irupts_len) != 0) {
686 		size_t size;
687 		int *out;
688 
689 		/*
690 		 * Translate the 'interrupts' property into an array
691 		 * of intrspecs for the rest of the DDI framework to
692 		 * toy with.  Only our ancestors really know how to
693 		 * do this, so ask 'em.  We massage the 'interrupts'
694 		 * property so that it is pre-pended by a count of
695 		 * the number of integers in the argument.
696 		 */
697 		size = sizeof (int) + n;
698 		out = kmem_alloc(size, KM_SLEEP);
699 		*out = n / sizeof (int);
700 		bcopy(irupts_prop, out + 1, (size_t)n);
701 		ddi_prop_free((void *)irupts_prop);
702 		if (impl_xlate_intrs(child, out, pdptr) != DDI_SUCCESS) {
703 			cmn_err(CE_CONT,
704 			    "Unable to translate 'interrupts' for %s%d\n",
705 			    DEVI(child)->devi_binding_name,
706 			    DEVI(child)->devi_instance);
707 		}
708 		kmem_free(out, size);
709 	}
710 }
711 
712 /*
713  * Name a child
714  */
715 static int
impl_sunbus_name_child(dev_info_t * child,char * name,int namelen)716 impl_sunbus_name_child(dev_info_t *child, char *name, int namelen)
717 {
718 	/*
719 	 * Fill in parent-private data and this function returns to us
720 	 * an indication if it used "registers" to fill in the data.
721 	 */
722 	if (ddi_get_parent_data(child) == NULL) {
723 		struct ddi_parent_private_data *pdptr;
724 		make_ddi_ppd(child, &pdptr);
725 		ddi_set_parent_data(child, pdptr);
726 	}
727 
728 	name[0] = '\0';
729 	if (sparc_pd_getnreg(child) > 0) {
730 		(void) snprintf(name, namelen, "%x,%x",
731 		    (uint_t)sparc_pd_getreg(child, 0)->regspec_bustype,
732 		    (uint_t)sparc_pd_getreg(child, 0)->regspec_addr);
733 	}
734 
735 	return (DDI_SUCCESS);
736 }
737 
738 /*
739  * Called from the bus_ctl op of sunbus (sbus, obio, etc) nexus drivers
740  * to implement the DDI_CTLOPS_INITCHILD operation.  That is, it names
741  * the children of sun busses based on the reg spec.
742  *
743  * Handles the following properties (in make_ddi_ppd):
744  *	Property		value
745  *	  Name			type
746  *	reg		register spec
747  *	intr		old-form interrupt spec
748  *	interrupts	new (bus-oriented) interrupt spec
749  *	ranges		range spec
750  */
751 int
impl_ddi_sunbus_initchild(dev_info_t * child)752 impl_ddi_sunbus_initchild(dev_info_t *child)
753 {
754 	char name[MAXNAMELEN];
755 	void impl_ddi_sunbus_removechild(dev_info_t *);
756 
757 	/*
758 	 * Name the child, also makes parent private data
759 	 */
760 	(void) impl_sunbus_name_child(child, name, MAXNAMELEN);
761 	ddi_set_name_addr(child, name);
762 
763 	/*
764 	 * Attempt to merge a .conf node; if successful, remove the
765 	 * .conf node.
766 	 */
767 	if ((ndi_dev_is_persistent_node(child) == 0) &&
768 	    (ndi_merge_node(child, impl_sunbus_name_child) == DDI_SUCCESS)) {
769 		/*
770 		 * Return failure to remove node
771 		 */
772 		impl_ddi_sunbus_removechild(child);
773 		return (DDI_FAILURE);
774 	}
775 	return (DDI_SUCCESS);
776 }
777 
778 void
impl_free_ddi_ppd(dev_info_t * dip)779 impl_free_ddi_ppd(dev_info_t *dip)
780 {
781 	struct ddi_parent_private_data *pdptr;
782 	size_t n;
783 
784 	if ((pdptr = ddi_get_parent_data(dip)) == NULL)
785 		return;
786 
787 	if ((n = (size_t)pdptr->par_nintr) != 0)
788 		/*
789 		 * Note that kmem_free is used here (instead of
790 		 * ddi_prop_free) because the contents of the
791 		 * property were placed into a separate buffer and
792 		 * mucked with a bit before being stored in par_intr.
793 		 * The actual return value from the prop lookup
794 		 * was freed with ddi_prop_free previously.
795 		 */
796 		kmem_free(pdptr->par_intr, n * sizeof (struct intrspec));
797 
798 	if ((n = (size_t)pdptr->par_nrng) != 0)
799 		ddi_prop_free((void *)pdptr->par_rng);
800 
801 	if ((n = pdptr->par_nreg) != 0)
802 		ddi_prop_free((void *)pdptr->par_reg);
803 
804 	kmem_free(pdptr, sizeof (*pdptr));
805 	ddi_set_parent_data(dip, NULL);
806 }
807 
808 void
impl_ddi_sunbus_removechild(dev_info_t * dip)809 impl_ddi_sunbus_removechild(dev_info_t *dip)
810 {
811 	impl_free_ddi_ppd(dip);
812 	ddi_set_name_addr(dip, NULL);
813 	/*
814 	 * Strip the node to properly convert it back to prototype form
815 	 */
816 	impl_rem_dev_props(dip);
817 }
818 
819 /*
820  * DDI Interrupt
821  */
822 
823 /*
824  * turn this on to force isa, eisa, and mca device to ignore the new
825  * hardware nodes in the device tree (normally turned on only for
826  * drivers that need it by setting the property "ignore-hardware-nodes"
827  * in their driver.conf file).
828  *
829  * 7/31/96 -- Turned off globally.  Leaving variable in for the moment
830  *		as safety valve.
831  */
832 int ignore_hardware_nodes = 0;
833 
834 /*
835  * New DDI interrupt framework
836  */
837 
838 /*
839  * i_ddi_intr_ops:
840  *
841  * This is the interrupt operator function wrapper for the bus function
842  * bus_intr_op.
843  */
844 int
i_ddi_intr_ops(dev_info_t * dip,dev_info_t * rdip,ddi_intr_op_t op,ddi_intr_handle_impl_t * hdlp,void * result)845 i_ddi_intr_ops(dev_info_t *dip, dev_info_t *rdip, ddi_intr_op_t op,
846     ddi_intr_handle_impl_t *hdlp, void * result)
847 {
848 	dev_info_t	*pdip = (dev_info_t *)DEVI(dip)->devi_parent;
849 	int		ret = DDI_FAILURE;
850 
851 	/* request parent to process this interrupt op */
852 	if (NEXUS_HAS_INTR_OP(pdip))
853 		ret = (*(DEVI(pdip)->devi_ops->devo_bus_ops->bus_intr_op))(
854 		    pdip, rdip, op, hdlp, result);
855 	else
856 		cmn_err(CE_WARN, "Failed to process interrupt "
857 		    "for %s%d due to down-rev nexus driver %s%d",
858 		    ddi_get_name(rdip), ddi_get_instance(rdip),
859 		    ddi_get_name(pdip), ddi_get_instance(pdip));
860 	return (ret);
861 }
862 
863 /*
864  * i_ddi_add_softint - allocate and add a soft interrupt to the system
865  */
866 int
i_ddi_add_softint(ddi_softint_hdl_impl_t * hdlp)867 i_ddi_add_softint(ddi_softint_hdl_impl_t *hdlp)
868 {
869 	int ret;
870 
871 	/* add soft interrupt handler */
872 	ret = add_avsoftintr((void *)hdlp, hdlp->ih_pri, hdlp->ih_cb_func,
873 	    DEVI(hdlp->ih_dip)->devi_name, hdlp->ih_cb_arg1, hdlp->ih_cb_arg2);
874 	return (ret ? DDI_SUCCESS : DDI_FAILURE);
875 }
876 
877 
878 void
i_ddi_remove_softint(ddi_softint_hdl_impl_t * hdlp)879 i_ddi_remove_softint(ddi_softint_hdl_impl_t *hdlp)
880 {
881 	(void) rem_avsoftintr((void *)hdlp, hdlp->ih_pri, hdlp->ih_cb_func);
882 }
883 
884 
885 extern void (*setsoftint)(int, struct av_softinfo *);
886 extern boolean_t av_check_softint_pending(struct av_softinfo *, boolean_t);
887 
888 int
i_ddi_trigger_softint(ddi_softint_hdl_impl_t * hdlp,void * arg2)889 i_ddi_trigger_softint(ddi_softint_hdl_impl_t *hdlp, void *arg2)
890 {
891 	if (av_check_softint_pending(hdlp->ih_pending, B_FALSE))
892 		return (DDI_EPENDING);
893 
894 	update_avsoftintr_args((void *)hdlp, hdlp->ih_pri, arg2);
895 
896 	(*setsoftint)(hdlp->ih_pri, hdlp->ih_pending);
897 	return (DDI_SUCCESS);
898 }
899 
900 /*
901  * i_ddi_set_softint_pri:
902  *
903  * The way this works is that it first tries to add a softint vector
904  * at the new priority in hdlp. If that succeeds; then it removes the
905  * existing softint vector at the old priority.
906  */
907 int
i_ddi_set_softint_pri(ddi_softint_hdl_impl_t * hdlp,uint_t old_pri)908 i_ddi_set_softint_pri(ddi_softint_hdl_impl_t *hdlp, uint_t old_pri)
909 {
910 	int ret;
911 
912 	/*
913 	 * If a softint is pending at the old priority then fail the request.
914 	 */
915 	if (av_check_softint_pending(hdlp->ih_pending, B_TRUE))
916 		return (DDI_FAILURE);
917 
918 	ret = av_softint_movepri((void *)hdlp, old_pri);
919 	return (ret ? DDI_SUCCESS : DDI_FAILURE);
920 }
921 
922 void
i_ddi_alloc_intr_phdl(ddi_intr_handle_impl_t * hdlp)923 i_ddi_alloc_intr_phdl(ddi_intr_handle_impl_t *hdlp)
924 {
925 	hdlp->ih_private = (void *)kmem_zalloc(sizeof (ihdl_plat_t), KM_SLEEP);
926 }
927 
928 void
i_ddi_free_intr_phdl(ddi_intr_handle_impl_t * hdlp)929 i_ddi_free_intr_phdl(ddi_intr_handle_impl_t *hdlp)
930 {
931 	kmem_free(hdlp->ih_private, sizeof (ihdl_plat_t));
932 	hdlp->ih_private = NULL;
933 }
934 
935 int
i_ddi_get_intx_nintrs(dev_info_t * dip)936 i_ddi_get_intx_nintrs(dev_info_t *dip)
937 {
938 	struct ddi_parent_private_data *pdp;
939 
940 	if ((pdp = ddi_get_parent_data(dip)) == NULL)
941 		return (0);
942 
943 	return (pdp->par_nintr);
944 }
945 
946 /*
947  * DDI Memory/DMA
948  */
949 
950 /*
951  * Support for allocating DMAable memory to implement
952  * ddi_dma_mem_alloc(9F) interface.
953  */
954 
955 #define	KA_ALIGN_SHIFT	7
956 #define	KA_ALIGN	(1 << KA_ALIGN_SHIFT)
957 #define	KA_NCACHE	(PAGESHIFT + 1 - KA_ALIGN_SHIFT)
958 
959 /*
960  * Dummy DMA attribute template for kmem_io[].kmem_io_attr.  We only
961  * care about addr_lo, addr_hi, and align.  addr_hi will be dynamically set.
962  */
963 
964 static ddi_dma_attr_t kmem_io_attr = {
965 	DMA_ATTR_V0,
966 	0x0000000000000000ULL,		/* dma_attr_addr_lo */
967 	0x0000000000000000ULL,		/* dma_attr_addr_hi */
968 	0x00ffffff,
969 	0x1000,				/* dma_attr_align */
970 	1, 1, 0xffffffffULL, 0xffffffffULL, 0x1, 1, 0
971 };
972 
973 /* kmem io memory ranges and indices */
974 enum {
975 	IO_4P, IO_64G, IO_4G, IO_2G, IO_1G, IO_512M,
976 	IO_256M, IO_128M, IO_64M, IO_32M, IO_16M, MAX_MEM_RANGES
977 };
978 
979 static struct {
980 	vmem_t		*kmem_io_arena;
981 	kmem_cache_t	*kmem_io_cache[KA_NCACHE];
982 	ddi_dma_attr_t	kmem_io_attr;
983 } kmem_io[MAX_MEM_RANGES];
984 
985 static int kmem_io_idx;		/* index of first populated kmem_io[] */
986 
987 static page_t *
page_create_io_wrapper(void * addr,size_t len,int vmflag,void * arg)988 page_create_io_wrapper(void *addr, size_t len, int vmflag, void *arg)
989 {
990 	extern page_t *page_create_io(vnode_t *, u_offset_t, uint_t,
991 	    uint_t, struct as *, caddr_t, ddi_dma_attr_t *);
992 
993 	return (page_create_io(&kvp, (u_offset_t)(uintptr_t)addr, len,
994 	    PG_EXCL | ((vmflag & VM_NOSLEEP) ? 0 : PG_WAIT), &kas, addr, arg));
995 }
996 
997 #ifdef __xpv
998 static void
segkmem_free_io(vmem_t * vmp,void * ptr,size_t size)999 segkmem_free_io(vmem_t *vmp, void *ptr, size_t size)
1000 {
1001 	extern void page_destroy_io(page_t *);
1002 	segkmem_xfree(vmp, ptr, size, &kvp, page_destroy_io);
1003 }
1004 #endif
1005 
1006 static void *
segkmem_alloc_io_4P(vmem_t * vmp,size_t size,int vmflag)1007 segkmem_alloc_io_4P(vmem_t *vmp, size_t size, int vmflag)
1008 {
1009 	return (segkmem_xalloc(vmp, NULL, size, vmflag, 0,
1010 	    page_create_io_wrapper, &kmem_io[IO_4P].kmem_io_attr));
1011 }
1012 
1013 static void *
segkmem_alloc_io_64G(vmem_t * vmp,size_t size,int vmflag)1014 segkmem_alloc_io_64G(vmem_t *vmp, size_t size, int vmflag)
1015 {
1016 	return (segkmem_xalloc(vmp, NULL, size, vmflag, 0,
1017 	    page_create_io_wrapper, &kmem_io[IO_64G].kmem_io_attr));
1018 }
1019 
1020 static void *
segkmem_alloc_io_4G(vmem_t * vmp,size_t size,int vmflag)1021 segkmem_alloc_io_4G(vmem_t *vmp, size_t size, int vmflag)
1022 {
1023 	return (segkmem_xalloc(vmp, NULL, size, vmflag, 0,
1024 	    page_create_io_wrapper, &kmem_io[IO_4G].kmem_io_attr));
1025 }
1026 
1027 static void *
segkmem_alloc_io_2G(vmem_t * vmp,size_t size,int vmflag)1028 segkmem_alloc_io_2G(vmem_t *vmp, size_t size, int vmflag)
1029 {
1030 	return (segkmem_xalloc(vmp, NULL, size, vmflag, 0,
1031 	    page_create_io_wrapper, &kmem_io[IO_2G].kmem_io_attr));
1032 }
1033 
1034 static void *
segkmem_alloc_io_1G(vmem_t * vmp,size_t size,int vmflag)1035 segkmem_alloc_io_1G(vmem_t *vmp, size_t size, int vmflag)
1036 {
1037 	return (segkmem_xalloc(vmp, NULL, size, vmflag, 0,
1038 	    page_create_io_wrapper, &kmem_io[IO_1G].kmem_io_attr));
1039 }
1040 
1041 static void *
segkmem_alloc_io_512M(vmem_t * vmp,size_t size,int vmflag)1042 segkmem_alloc_io_512M(vmem_t *vmp, size_t size, int vmflag)
1043 {
1044 	return (segkmem_xalloc(vmp, NULL, size, vmflag, 0,
1045 	    page_create_io_wrapper, &kmem_io[IO_512M].kmem_io_attr));
1046 }
1047 
1048 static void *
segkmem_alloc_io_256M(vmem_t * vmp,size_t size,int vmflag)1049 segkmem_alloc_io_256M(vmem_t *vmp, size_t size, int vmflag)
1050 {
1051 	return (segkmem_xalloc(vmp, NULL, size, vmflag, 0,
1052 	    page_create_io_wrapper, &kmem_io[IO_256M].kmem_io_attr));
1053 }
1054 
1055 static void *
segkmem_alloc_io_128M(vmem_t * vmp,size_t size,int vmflag)1056 segkmem_alloc_io_128M(vmem_t *vmp, size_t size, int vmflag)
1057 {
1058 	return (segkmem_xalloc(vmp, NULL, size, vmflag, 0,
1059 	    page_create_io_wrapper, &kmem_io[IO_128M].kmem_io_attr));
1060 }
1061 
1062 static void *
segkmem_alloc_io_64M(vmem_t * vmp,size_t size,int vmflag)1063 segkmem_alloc_io_64M(vmem_t *vmp, size_t size, int vmflag)
1064 {
1065 	return (segkmem_xalloc(vmp, NULL, size, vmflag, 0,
1066 	    page_create_io_wrapper, &kmem_io[IO_64M].kmem_io_attr));
1067 }
1068 
1069 static void *
segkmem_alloc_io_32M(vmem_t * vmp,size_t size,int vmflag)1070 segkmem_alloc_io_32M(vmem_t *vmp, size_t size, int vmflag)
1071 {
1072 	return (segkmem_xalloc(vmp, NULL, size, vmflag, 0,
1073 	    page_create_io_wrapper, &kmem_io[IO_32M].kmem_io_attr));
1074 }
1075 
1076 static void *
segkmem_alloc_io_16M(vmem_t * vmp,size_t size,int vmflag)1077 segkmem_alloc_io_16M(vmem_t *vmp, size_t size, int vmflag)
1078 {
1079 	return (segkmem_xalloc(vmp, NULL, size, vmflag, 0,
1080 	    page_create_io_wrapper, &kmem_io[IO_16M].kmem_io_attr));
1081 }
1082 
1083 struct {
1084 	uint64_t	io_limit;
1085 	char		*io_name;
1086 	void		*(*io_alloc)(vmem_t *, size_t, int);
1087 	int		io_initial;	/* kmem_io_init during startup */
1088 } io_arena_params[MAX_MEM_RANGES] = {
1089 	{0x000fffffffffffffULL,	"kmem_io_4P",	segkmem_alloc_io_4P,	1},
1090 	{0x0000000fffffffffULL,	"kmem_io_64G",	segkmem_alloc_io_64G,	0},
1091 	{0x00000000ffffffffULL,	"kmem_io_4G",	segkmem_alloc_io_4G,	1},
1092 	{0x000000007fffffffULL,	"kmem_io_2G",	segkmem_alloc_io_2G,	1},
1093 	{0x000000003fffffffULL,	"kmem_io_1G",	segkmem_alloc_io_1G,	0},
1094 	{0x000000001fffffffULL,	"kmem_io_512M",	segkmem_alloc_io_512M,	0},
1095 	{0x000000000fffffffULL,	"kmem_io_256M",	segkmem_alloc_io_256M,	0},
1096 	{0x0000000007ffffffULL,	"kmem_io_128M",	segkmem_alloc_io_128M,	0},
1097 	{0x0000000003ffffffULL,	"kmem_io_64M",	segkmem_alloc_io_64M,	0},
1098 	{0x0000000001ffffffULL,	"kmem_io_32M",	segkmem_alloc_io_32M,	0},
1099 	{0x0000000000ffffffULL,	"kmem_io_16M",	segkmem_alloc_io_16M,	1}
1100 };
1101 
1102 void
kmem_io_init(int a)1103 kmem_io_init(int a)
1104 {
1105 	int	c;
1106 	char name[40];
1107 
1108 	kmem_io[a].kmem_io_arena = vmem_create(io_arena_params[a].io_name,
1109 	    NULL, 0, PAGESIZE, io_arena_params[a].io_alloc,
1110 #ifdef __xpv
1111 	    segkmem_free_io,
1112 #else
1113 	    segkmem_free,
1114 #endif
1115 	    heap_arena, 0, VM_SLEEP);
1116 
1117 	for (c = 0; c < KA_NCACHE; c++) {
1118 		size_t size = KA_ALIGN << c;
1119 		(void) sprintf(name, "%s_%lu",
1120 		    io_arena_params[a].io_name, size);
1121 		kmem_io[a].kmem_io_cache[c] = kmem_cache_create(name,
1122 		    size, size, NULL, NULL, NULL, NULL,
1123 		    kmem_io[a].kmem_io_arena, 0);
1124 	}
1125 }
1126 
1127 /*
1128  * Return the index of the highest memory range for addr.
1129  */
1130 static int
kmem_io_index(uint64_t addr)1131 kmem_io_index(uint64_t addr)
1132 {
1133 	int n;
1134 
1135 	for (n = kmem_io_idx; n < MAX_MEM_RANGES; n++) {
1136 		if (kmem_io[n].kmem_io_attr.dma_attr_addr_hi <= addr) {
1137 			if (kmem_io[n].kmem_io_arena == NULL)
1138 				kmem_io_init(n);
1139 			return (n);
1140 		}
1141 	}
1142 	panic("kmem_io_index: invalid addr - must be at least 16m");
1143 
1144 	/*NOTREACHED*/
1145 }
1146 
1147 /*
1148  * Return the index of the next kmem_io populated memory range
1149  * after curindex.
1150  */
1151 static int
kmem_io_index_next(int curindex)1152 kmem_io_index_next(int curindex)
1153 {
1154 	int n;
1155 
1156 	for (n = curindex + 1; n < MAX_MEM_RANGES; n++) {
1157 		if (kmem_io[n].kmem_io_arena)
1158 			return (n);
1159 	}
1160 	return (-1);
1161 }
1162 
1163 /*
1164  * allow kmem to be mapped in with different PTE cache attribute settings.
1165  * Used by i_ddi_mem_alloc()
1166  */
1167 int
kmem_override_cache_attrs(caddr_t kva,size_t size,uint_t order)1168 kmem_override_cache_attrs(caddr_t kva, size_t size, uint_t order)
1169 {
1170 	uint_t hat_flags;
1171 	caddr_t kva_end;
1172 	uint_t hat_attr;
1173 	pfn_t pfn;
1174 
1175 	if (hat_getattr(kas.a_hat, kva, &hat_attr) == -1) {
1176 		return (-1);
1177 	}
1178 
1179 	hat_attr &= ~HAT_ORDER_MASK;
1180 	hat_attr |= order | HAT_NOSYNC;
1181 	hat_flags = HAT_LOAD_LOCK;
1182 
1183 	kva_end = (caddr_t)(((uintptr_t)kva + size + PAGEOFFSET) &
1184 	    (uintptr_t)PAGEMASK);
1185 	kva = (caddr_t)((uintptr_t)kva & (uintptr_t)PAGEMASK);
1186 
1187 	while (kva < kva_end) {
1188 		pfn = hat_getpfnum(kas.a_hat, kva);
1189 		hat_unload(kas.a_hat, kva, PAGESIZE, HAT_UNLOAD_UNLOCK);
1190 		hat_devload(kas.a_hat, kva, PAGESIZE, pfn, hat_attr, hat_flags);
1191 		kva += MMU_PAGESIZE;
1192 	}
1193 
1194 	return (0);
1195 }
1196 
1197 static int
ctgcompare(const void * a1,const void * a2)1198 ctgcompare(const void *a1, const void *a2)
1199 {
1200 	/* we just want to compare virtual addresses */
1201 	a1 = ((struct ctgas *)a1)->ctg_addr;
1202 	a2 = ((struct ctgas *)a2)->ctg_addr;
1203 	return (a1 == a2 ? 0 : (a1 < a2 ? -1 : 1));
1204 }
1205 
1206 void
ka_init(void)1207 ka_init(void)
1208 {
1209 	int a;
1210 	paddr_t maxphysaddr;
1211 #if !defined(__xpv)
1212 	extern pfn_t physmax;
1213 
1214 	maxphysaddr = mmu_ptob((paddr_t)physmax) + MMU_PAGEOFFSET;
1215 #else
1216 	maxphysaddr = mmu_ptob((paddr_t)HYPERVISOR_memory_op(
1217 	    XENMEM_maximum_ram_page, NULL)) + MMU_PAGEOFFSET;
1218 #endif
1219 
1220 	ASSERT(maxphysaddr <= io_arena_params[0].io_limit);
1221 
1222 	for (a = 0; a < MAX_MEM_RANGES; a++) {
1223 		if (maxphysaddr >= io_arena_params[a + 1].io_limit) {
1224 			if (maxphysaddr > io_arena_params[a + 1].io_limit)
1225 				io_arena_params[a].io_limit = maxphysaddr;
1226 			else
1227 				a++;
1228 			break;
1229 		}
1230 	}
1231 	kmem_io_idx = a;
1232 
1233 	for (; a < MAX_MEM_RANGES; a++) {
1234 		kmem_io[a].kmem_io_attr = kmem_io_attr;
1235 		kmem_io[a].kmem_io_attr.dma_attr_addr_hi =
1236 		    io_arena_params[a].io_limit;
1237 		/*
1238 		 * initialize kmem_io[] arena/cache corresponding to
1239 		 * maxphysaddr and to the "common" io memory ranges that
1240 		 * have io_initial set to a non-zero value.
1241 		 */
1242 		if (io_arena_params[a].io_initial || a == kmem_io_idx)
1243 			kmem_io_init(a);
1244 	}
1245 
1246 	/* initialize ctgtree */
1247 	avl_create(&ctgtree, ctgcompare, sizeof (struct ctgas),
1248 	    offsetof(struct ctgas, ctg_link));
1249 }
1250 
1251 /*
1252  * put contig address/size
1253  */
1254 static void *
putctgas(void * addr,size_t size)1255 putctgas(void *addr, size_t size)
1256 {
1257 	struct ctgas    *ctgp;
1258 	if ((ctgp = kmem_zalloc(sizeof (*ctgp), KM_NOSLEEP)) != NULL) {
1259 		ctgp->ctg_addr = addr;
1260 		ctgp->ctg_size = size;
1261 		CTGLOCK();
1262 		avl_add(&ctgtree, ctgp);
1263 		CTGUNLOCK();
1264 	}
1265 	return (ctgp);
1266 }
1267 
1268 /*
1269  * get contig size by addr
1270  */
1271 static size_t
getctgsz(void * addr)1272 getctgsz(void *addr)
1273 {
1274 	struct ctgas    *ctgp;
1275 	struct ctgas    find;
1276 	size_t		sz = 0;
1277 
1278 	find.ctg_addr = addr;
1279 	CTGLOCK();
1280 	if ((ctgp = avl_find(&ctgtree, &find, NULL)) != NULL) {
1281 		avl_remove(&ctgtree, ctgp);
1282 	}
1283 	CTGUNLOCK();
1284 
1285 	if (ctgp != NULL) {
1286 		sz = ctgp->ctg_size;
1287 		kmem_free(ctgp, sizeof (*ctgp));
1288 	}
1289 
1290 	return (sz);
1291 }
1292 
1293 /*
1294  * contig_alloc:
1295  *
1296  *	allocates contiguous memory to satisfy the 'size' and dma attributes
1297  *	specified in 'attr'.
1298  *
1299  *	Not all of memory need to be physically contiguous if the
1300  *	scatter-gather list length is greater than 1.
1301  */
1302 
1303 /*ARGSUSED*/
1304 void *
contig_alloc(size_t size,ddi_dma_attr_t * attr,uintptr_t align,int cansleep)1305 contig_alloc(size_t size, ddi_dma_attr_t *attr, uintptr_t align, int cansleep)
1306 {
1307 	pgcnt_t		pgcnt = btopr(size);
1308 	size_t		asize = pgcnt * PAGESIZE;
1309 	page_t		*ppl;
1310 	int		pflag;
1311 	void		*addr;
1312 
1313 	extern page_t *page_create_io(vnode_t *, u_offset_t, uint_t,
1314 	    uint_t, struct as *, caddr_t, ddi_dma_attr_t *);
1315 
1316 	/* segkmem_xalloc */
1317 
1318 	if (align <= PAGESIZE)
1319 		addr = vmem_alloc(heap_arena, asize,
1320 		    (cansleep) ? VM_SLEEP : VM_NOSLEEP);
1321 	else
1322 		addr = vmem_xalloc(heap_arena, asize, align, 0, 0, NULL, NULL,
1323 		    (cansleep) ? VM_SLEEP : VM_NOSLEEP);
1324 	if (addr) {
1325 		ASSERT(!((uintptr_t)addr & (align - 1)));
1326 
1327 		if (page_resv(pgcnt, (cansleep) ? KM_SLEEP : KM_NOSLEEP) == 0) {
1328 			vmem_free(heap_arena, addr, asize);
1329 			return (NULL);
1330 		}
1331 		pflag = PG_EXCL;
1332 
1333 		if (cansleep)
1334 			pflag |= PG_WAIT;
1335 
1336 		/* 4k req gets from freelists rather than pfn search */
1337 		if (pgcnt > 1 || align > PAGESIZE)
1338 			pflag |= PG_PHYSCONTIG;
1339 
1340 		ppl = page_create_io(&kvp, (u_offset_t)(uintptr_t)addr,
1341 		    asize, pflag, &kas, (caddr_t)addr, attr);
1342 
1343 		if (!ppl) {
1344 			vmem_free(heap_arena, addr, asize);
1345 			page_unresv(pgcnt);
1346 			return (NULL);
1347 		}
1348 
1349 		while (ppl != NULL) {
1350 			page_t	*pp = ppl;
1351 			page_sub(&ppl, pp);
1352 			ASSERT(page_iolock_assert(pp));
1353 			page_io_unlock(pp);
1354 			page_downgrade(pp);
1355 			hat_memload(kas.a_hat, (caddr_t)(uintptr_t)pp->p_offset,
1356 			    pp, (PROT_ALL & ~PROT_USER) |
1357 			    HAT_NOSYNC, HAT_LOAD_LOCK);
1358 		}
1359 	}
1360 	return (addr);
1361 }
1362 
1363 void
contig_free(void * addr,size_t size)1364 contig_free(void *addr, size_t size)
1365 {
1366 	pgcnt_t	pgcnt = btopr(size);
1367 	size_t	asize = pgcnt * PAGESIZE;
1368 	caddr_t	a, ea;
1369 	page_t	*pp;
1370 
1371 	hat_unload(kas.a_hat, addr, asize, HAT_UNLOAD_UNLOCK);
1372 
1373 	for (a = addr, ea = a + asize; a < ea; a += PAGESIZE) {
1374 		pp = page_find(&kvp, (u_offset_t)(uintptr_t)a);
1375 		if (!pp)
1376 			panic("contig_free: contig pp not found");
1377 
1378 		if (!page_tryupgrade(pp)) {
1379 			page_unlock(pp);
1380 			pp = page_lookup(&kvp,
1381 			    (u_offset_t)(uintptr_t)a, SE_EXCL);
1382 			if (pp == NULL)
1383 				panic("contig_free: page freed");
1384 		}
1385 		page_destroy(pp, 0);
1386 	}
1387 
1388 	page_unresv(pgcnt);
1389 	vmem_free(heap_arena, addr, asize);
1390 }
1391 
1392 /*
1393  * Allocate from the system, aligned on a specific boundary.
1394  * The alignment, if non-zero, must be a power of 2.
1395  */
1396 static void *
kalloca(size_t size,size_t align,int cansleep,int physcontig,ddi_dma_attr_t * attr)1397 kalloca(size_t size, size_t align, int cansleep, int physcontig,
1398     ddi_dma_attr_t *attr)
1399 {
1400 	size_t *addr, *raddr, rsize;
1401 	size_t hdrsize = 4 * sizeof (size_t);	/* must be power of 2 */
1402 	int a, i, c;
1403 	vmem_t *vmp = NULL;
1404 	kmem_cache_t *cp = NULL;
1405 
1406 	if (attr->dma_attr_addr_lo > mmu_ptob((uint64_t)ddiphysmin))
1407 		return (NULL);
1408 
1409 	align = MAX(align, hdrsize);
1410 	ASSERT((align & (align - 1)) == 0);
1411 
1412 	/*
1413 	 * All of our allocators guarantee 16-byte alignment, so we don't
1414 	 * need to reserve additional space for the header.
1415 	 * To simplify picking the correct kmem_io_cache, we round up to
1416 	 * a multiple of KA_ALIGN.
1417 	 */
1418 	rsize = P2ROUNDUP_TYPED(size + align, KA_ALIGN, size_t);
1419 
1420 	if (physcontig && rsize > PAGESIZE) {
1421 		if ((addr = contig_alloc(size, attr, align, cansleep)) !=
1422 		    NULL) {
1423 			if (!putctgas(addr, size))
1424 				contig_free(addr, size);
1425 			else
1426 				return (addr);
1427 		}
1428 		return (NULL);
1429 	}
1430 
1431 	a = kmem_io_index(attr->dma_attr_addr_hi);
1432 
1433 	if (rsize > PAGESIZE) {
1434 		vmp = kmem_io[a].kmem_io_arena;
1435 		raddr = vmem_alloc(vmp, rsize,
1436 		    (cansleep) ? VM_SLEEP : VM_NOSLEEP);
1437 	} else {
1438 		c = highbit((rsize >> KA_ALIGN_SHIFT) - 1);
1439 		cp = kmem_io[a].kmem_io_cache[c];
1440 		raddr = kmem_cache_alloc(cp, (cansleep) ? KM_SLEEP :
1441 		    KM_NOSLEEP);
1442 	}
1443 
1444 	if (raddr == NULL) {
1445 		int	na;
1446 
1447 		ASSERT(cansleep == 0);
1448 		if (rsize > PAGESIZE)
1449 			return (NULL);
1450 		/*
1451 		 * System does not have memory in the requested range.
1452 		 * Try smaller kmem io ranges and larger cache sizes
1453 		 * to see if there might be memory available in
1454 		 * these other caches.
1455 		 */
1456 
1457 		for (na = kmem_io_index_next(a); na >= 0;
1458 		    na = kmem_io_index_next(na)) {
1459 			ASSERT(kmem_io[na].kmem_io_arena);
1460 			cp = kmem_io[na].kmem_io_cache[c];
1461 			raddr = kmem_cache_alloc(cp, KM_NOSLEEP);
1462 			if (raddr)
1463 				goto kallocdone;
1464 		}
1465 		/* now try the larger kmem io cache sizes */
1466 		for (na = a; na >= 0; na = kmem_io_index_next(na)) {
1467 			for (i = c + 1; i < KA_NCACHE; i++) {
1468 				cp = kmem_io[na].kmem_io_cache[i];
1469 				raddr = kmem_cache_alloc(cp, KM_NOSLEEP);
1470 				if (raddr)
1471 					goto kallocdone;
1472 			}
1473 		}
1474 		return (NULL);
1475 	}
1476 
1477 kallocdone:
1478 	ASSERT(!P2BOUNDARY((uintptr_t)raddr, rsize, PAGESIZE) ||
1479 	    rsize > PAGESIZE);
1480 
1481 	addr = (size_t *)P2ROUNDUP((uintptr_t)raddr + hdrsize, align);
1482 	ASSERT((uintptr_t)addr + size - (uintptr_t)raddr <= rsize);
1483 
1484 	addr[-4] = (size_t)cp;
1485 	addr[-3] = (size_t)vmp;
1486 	addr[-2] = (size_t)raddr;
1487 	addr[-1] = rsize;
1488 
1489 	return (addr);
1490 }
1491 
1492 static void
kfreea(void * addr)1493 kfreea(void *addr)
1494 {
1495 	size_t		size;
1496 
1497 	if (!((uintptr_t)addr & PAGEOFFSET) && (size = getctgsz(addr))) {
1498 		contig_free(addr, size);
1499 	} else {
1500 		size_t	*saddr = addr;
1501 		if (saddr[-4] == 0)
1502 			vmem_free((vmem_t *)saddr[-3], (void *)saddr[-2],
1503 			    saddr[-1]);
1504 		else
1505 			kmem_cache_free((kmem_cache_t *)saddr[-4],
1506 			    (void *)saddr[-2]);
1507 	}
1508 }
1509 
1510 /*ARGSUSED*/
1511 void
i_ddi_devacc_to_hatacc(const ddi_device_acc_attr_t * devaccp,uint_t * hataccp)1512 i_ddi_devacc_to_hatacc(const ddi_device_acc_attr_t *devaccp, uint_t *hataccp)
1513 {
1514 }
1515 
1516 /*
1517  * Check if the specified cache attribute is supported on the platform.
1518  * This function must be called before i_ddi_cacheattr_to_hatacc().
1519  */
1520 boolean_t
i_ddi_check_cache_attr(uint_t flags)1521 i_ddi_check_cache_attr(uint_t flags)
1522 {
1523 	/*
1524 	 * The cache attributes are mutually exclusive. Any combination of
1525 	 * the attributes leads to a failure.
1526 	 */
1527 	uint_t cache_attr = IOMEM_CACHE_ATTR(flags);
1528 	if ((cache_attr != 0) && !ISP2(cache_attr))
1529 		return (B_FALSE);
1530 
1531 	/* All cache attributes are supported on X86/X64 */
1532 	if (cache_attr & (IOMEM_DATA_UNCACHED | IOMEM_DATA_CACHED |
1533 	    IOMEM_DATA_UC_WR_COMBINE))
1534 		return (B_TRUE);
1535 
1536 	/* undefined attributes */
1537 	return (B_FALSE);
1538 }
1539 
1540 /* set HAT cache attributes from the cache attributes */
1541 void
i_ddi_cacheattr_to_hatacc(uint_t flags,uint_t * hataccp)1542 i_ddi_cacheattr_to_hatacc(uint_t flags, uint_t *hataccp)
1543 {
1544 	uint_t cache_attr = IOMEM_CACHE_ATTR(flags);
1545 	static char *fname = "i_ddi_cacheattr_to_hatacc";
1546 
1547 	/*
1548 	 * If write-combining is not supported, then it falls back
1549 	 * to uncacheable.
1550 	 */
1551 	if (cache_attr == IOMEM_DATA_UC_WR_COMBINE &&
1552 	    !is_x86_feature(x86_featureset, X86FSET_PAT))
1553 		cache_attr = IOMEM_DATA_UNCACHED;
1554 
1555 	/*
1556 	 * set HAT attrs according to the cache attrs.
1557 	 */
1558 	switch (cache_attr) {
1559 	case IOMEM_DATA_UNCACHED:
1560 		*hataccp &= ~HAT_ORDER_MASK;
1561 		*hataccp |= (HAT_STRICTORDER | HAT_PLAT_NOCACHE);
1562 		break;
1563 	case IOMEM_DATA_UC_WR_COMBINE:
1564 		*hataccp &= ~HAT_ORDER_MASK;
1565 		*hataccp |= (HAT_MERGING_OK | HAT_PLAT_NOCACHE);
1566 		break;
1567 	case IOMEM_DATA_CACHED:
1568 		*hataccp &= ~HAT_ORDER_MASK;
1569 		*hataccp |= HAT_UNORDERED_OK;
1570 		break;
1571 	/*
1572 	 * This case must not occur because the cache attribute is scrutinized
1573 	 * before this function is called.
1574 	 */
1575 	default:
1576 		/*
1577 		 * set cacheable to hat attrs.
1578 		 */
1579 		*hataccp &= ~HAT_ORDER_MASK;
1580 		*hataccp |= HAT_UNORDERED_OK;
1581 		cmn_err(CE_WARN, "%s: cache_attr=0x%x is ignored.",
1582 		    fname, cache_attr);
1583 	}
1584 }
1585 
1586 /*
1587  * This should actually be called i_ddi_dma_mem_alloc. There should
1588  * also be an i_ddi_pio_mem_alloc. i_ddi_dma_mem_alloc should call
1589  * through the device tree with the DDI_CTLOPS_DMA_ALIGN ctl ops to
1590  * get alignment requirements for DMA memory. i_ddi_pio_mem_alloc
1591  * should use DDI_CTLOPS_PIO_ALIGN. Since we only have i_ddi_mem_alloc
1592  * so far which is used for both, DMA and PIO, we have to use the DMA
1593  * ctl ops to make everybody happy.
1594  */
1595 /*ARGSUSED*/
1596 int
i_ddi_mem_alloc(dev_info_t * dip,ddi_dma_attr_t * attr,size_t length,int cansleep,int flags,const ddi_device_acc_attr_t * accattrp,caddr_t * kaddrp,size_t * real_length,ddi_acc_hdl_t * ap)1597 i_ddi_mem_alloc(dev_info_t *dip, ddi_dma_attr_t *attr,
1598     size_t length, int cansleep, int flags,
1599     const ddi_device_acc_attr_t *accattrp, caddr_t *kaddrp,
1600     size_t *real_length, ddi_acc_hdl_t *ap)
1601 {
1602 	caddr_t a;
1603 	int iomin;
1604 	ddi_acc_impl_t *iap;
1605 	int physcontig = 0;
1606 	pgcnt_t npages;
1607 	pgcnt_t minctg;
1608 	uint_t order;
1609 	int e;
1610 
1611 	/*
1612 	 * Check legality of arguments
1613 	 */
1614 	if (length == 0 || kaddrp == NULL || attr == NULL) {
1615 		return (DDI_FAILURE);
1616 	}
1617 
1618 	if (attr->dma_attr_minxfer == 0 || attr->dma_attr_align == 0 ||
1619 	    !ISP2(attr->dma_attr_align) || !ISP2(attr->dma_attr_minxfer)) {
1620 		return (DDI_FAILURE);
1621 	}
1622 
1623 	/*
1624 	 * figure out most restrictive alignment requirement
1625 	 */
1626 	iomin = attr->dma_attr_minxfer;
1627 	iomin = maxbit(iomin, attr->dma_attr_align);
1628 	if (iomin == 0)
1629 		return (DDI_FAILURE);
1630 
1631 	ASSERT((iomin & (iomin - 1)) == 0);
1632 
1633 	/*
1634 	 * if we allocate memory with IOMEM_DATA_UNCACHED or
1635 	 * IOMEM_DATA_UC_WR_COMBINE, make sure we allocate a page aligned
1636 	 * memory that ends on a page boundry.
1637 	 * Don't want to have to different cache mappings to the same
1638 	 * physical page.
1639 	 */
1640 	if (OVERRIDE_CACHE_ATTR(flags)) {
1641 		iomin = (iomin + MMU_PAGEOFFSET) & MMU_PAGEMASK;
1642 		length = (length + MMU_PAGEOFFSET) & (size_t)MMU_PAGEMASK;
1643 	}
1644 
1645 	/*
1646 	 * Determine if we need to satisfy the request for physically
1647 	 * contiguous memory or alignments larger than pagesize.
1648 	 */
1649 	npages = btopr(length + attr->dma_attr_align);
1650 	minctg = howmany(npages, attr->dma_attr_sgllen);
1651 
1652 	if (minctg > 1) {
1653 		uint64_t pfnseg = attr->dma_attr_seg >> PAGESHIFT;
1654 		/*
1655 		 * verify that the minimum contig requirement for the
1656 		 * actual length does not cross segment boundary.
1657 		 */
1658 		length = P2ROUNDUP_TYPED(length, attr->dma_attr_minxfer,
1659 		    size_t);
1660 		npages = btopr(length);
1661 		minctg = howmany(npages, attr->dma_attr_sgllen);
1662 		if (minctg > pfnseg + 1)
1663 			return (DDI_FAILURE);
1664 		physcontig = 1;
1665 	} else {
1666 		length = P2ROUNDUP_TYPED(length, iomin, size_t);
1667 	}
1668 
1669 	/*
1670 	 * Allocate the requested amount from the system.
1671 	 */
1672 	a = kalloca(length, iomin, cansleep, physcontig, attr);
1673 
1674 	if ((*kaddrp = a) == NULL)
1675 		return (DDI_FAILURE);
1676 
1677 	/*
1678 	 * if we to modify the cache attributes, go back and muck with the
1679 	 * mappings.
1680 	 */
1681 	if (OVERRIDE_CACHE_ATTR(flags)) {
1682 		order = 0;
1683 		i_ddi_cacheattr_to_hatacc(flags, &order);
1684 		e = kmem_override_cache_attrs(a, length, order);
1685 		if (e != 0) {
1686 			kfreea(a);
1687 			return (DDI_FAILURE);
1688 		}
1689 	}
1690 
1691 	if (real_length) {
1692 		*real_length = length;
1693 	}
1694 	if (ap) {
1695 		/*
1696 		 * initialize access handle
1697 		 */
1698 		iap = (ddi_acc_impl_t *)ap->ah_platform_private;
1699 		iap->ahi_acc_attr |= DDI_ACCATTR_CPU_VADDR;
1700 		impl_acc_hdl_init(ap);
1701 	}
1702 
1703 	return (DDI_SUCCESS);
1704 }
1705 
1706 /* ARGSUSED */
1707 void
i_ddi_mem_free(caddr_t kaddr,ddi_acc_hdl_t * ap)1708 i_ddi_mem_free(caddr_t kaddr, ddi_acc_hdl_t *ap)
1709 {
1710 	if (ap != NULL) {
1711 		/*
1712 		 * if we modified the cache attributes on alloc, go back and
1713 		 * fix them since this memory could be returned to the
1714 		 * general pool.
1715 		 */
1716 		if (OVERRIDE_CACHE_ATTR(ap->ah_xfermodes)) {
1717 			uint_t order = 0;
1718 			int e;
1719 			i_ddi_cacheattr_to_hatacc(IOMEM_DATA_CACHED, &order);
1720 			e = kmem_override_cache_attrs(kaddr, ap->ah_len, order);
1721 			if (e != 0) {
1722 				cmn_err(CE_WARN, "i_ddi_mem_free() failed to "
1723 				    "override cache attrs, memory leaked\n");
1724 				return;
1725 			}
1726 		}
1727 	}
1728 	kfreea(kaddr);
1729 }
1730 
1731 /*
1732  * Access Barriers
1733  *
1734  */
1735 /*ARGSUSED*/
1736 int
i_ddi_ontrap(ddi_acc_handle_t hp)1737 i_ddi_ontrap(ddi_acc_handle_t hp)
1738 {
1739 	return (DDI_FAILURE);
1740 }
1741 
1742 /*ARGSUSED*/
1743 void
i_ddi_notrap(ddi_acc_handle_t hp)1744 i_ddi_notrap(ddi_acc_handle_t hp)
1745 {
1746 }
1747 
1748 
1749 /*
1750  * Misc Functions
1751  */
1752 
1753 /*
1754  * Implementation instance override functions
1755  *
1756  * No override on i86pc
1757  */
1758 /*ARGSUSED*/
1759 uint_t
impl_assign_instance(dev_info_t * dip)1760 impl_assign_instance(dev_info_t *dip)
1761 {
1762 	return ((uint_t)-1);
1763 }
1764 
1765 /*ARGSUSED*/
1766 int
impl_keep_instance(dev_info_t * dip)1767 impl_keep_instance(dev_info_t *dip)
1768 {
1769 
1770 #if defined(__xpv)
1771 	/*
1772 	 * Do not persist instance numbers assigned to devices in dom0
1773 	 */
1774 	dev_info_t *pdip;
1775 	if (DOMAIN_IS_INITDOMAIN(xen_info)) {
1776 		if (((pdip = ddi_get_parent(dip)) != NULL) &&
1777 		    (strcmp(ddi_get_name(pdip), "xpvd") == 0))
1778 			return (DDI_SUCCESS);
1779 	}
1780 #endif
1781 	return (DDI_FAILURE);
1782 }
1783 
1784 /*ARGSUSED*/
1785 int
impl_free_instance(dev_info_t * dip)1786 impl_free_instance(dev_info_t *dip)
1787 {
1788 	return (DDI_FAILURE);
1789 }
1790 
1791 /*ARGSUSED*/
1792 int
impl_check_cpu(dev_info_t * devi)1793 impl_check_cpu(dev_info_t *devi)
1794 {
1795 	return (DDI_SUCCESS);
1796 }
1797 
1798 /*
1799  * Referenced in common/cpr_driver.c: Power off machine.
1800  * Don't know how to power off i86pc.
1801  */
1802 void
arch_power_down()1803 arch_power_down()
1804 {}
1805 
1806 /*
1807  * Copy name to property_name, since name
1808  * is in the low address range below kernelbase.
1809  */
1810 static void
copy_boot_str(const char * boot_str,char * kern_str,int len)1811 copy_boot_str(const char *boot_str, char *kern_str, int len)
1812 {
1813 	int i = 0;
1814 
1815 	while (i < len - 1 && boot_str[i] != '\0') {
1816 		kern_str[i] = boot_str[i];
1817 		i++;
1818 	}
1819 
1820 	kern_str[i] = 0;	/* null terminate */
1821 	if (boot_str[i] != '\0')
1822 		cmn_err(CE_WARN,
1823 		    "boot property string is truncated to %s", kern_str);
1824 }
1825 
1826 static void
get_boot_properties(void)1827 get_boot_properties(void)
1828 {
1829 	extern char hw_provider[];
1830 	dev_info_t *devi;
1831 	char *name;
1832 	int length, flags;
1833 	char property_name[50], property_val[50];
1834 	void *bop_staging_area;
1835 
1836 	bop_staging_area = kmem_zalloc(MMU_PAGESIZE, KM_NOSLEEP);
1837 
1838 	/*
1839 	 * Import "root" properties from the boot.
1840 	 *
1841 	 * We do this by invoking BOP_NEXTPROP until the list
1842 	 * is completely copied in.
1843 	 */
1844 
1845 	devi = ddi_root_node();
1846 	for (name = BOP_NEXTPROP(bootops, "");		/* get first */
1847 	    name;					/* NULL => DONE */
1848 	    name = BOP_NEXTPROP(bootops, name)) {	/* get next */
1849 
1850 		/* copy string to memory above kernelbase */
1851 		copy_boot_str(name, property_name, 50);
1852 
1853 		/*
1854 		 * Skip vga properties. They will be picked up later
1855 		 * by get_vga_properties.
1856 		 */
1857 		if (strcmp(property_name, "display-edif-block") == 0 ||
1858 		    strcmp(property_name, "display-edif-id") == 0) {
1859 			continue;
1860 		}
1861 
1862 		length = BOP_GETPROPLEN(bootops, property_name);
1863 		if (length < 0)
1864 			continue;
1865 		if (length > MMU_PAGESIZE) {
1866 			cmn_err(CE_NOTE,
1867 			    "boot property %s longer than 0x%x, ignored\n",
1868 			    property_name, MMU_PAGESIZE);
1869 			continue;
1870 		}
1871 		BOP_GETPROP(bootops, property_name, bop_staging_area);
1872 		flags = do_bsys_getproptype(bootops, property_name);
1873 
1874 		/*
1875 		 * special properties:
1876 		 * si-machine, si-hw-provider
1877 		 *	goes to kernel data structures.
1878 		 * bios-boot-device and stdout
1879 		 *	goes to hardware property list so it may show up
1880 		 *	in the prtconf -vp output. This is needed by
1881 		 *	Install/Upgrade. Once we fix install upgrade,
1882 		 *	this can be taken out.
1883 		 */
1884 		if (strcmp(name, "si-machine") == 0) {
1885 			(void) strncpy(utsname.machine, bop_staging_area,
1886 			    SYS_NMLN);
1887 			utsname.machine[SYS_NMLN - 1] = '\0';
1888 			continue;
1889 		}
1890 		if (strcmp(name, "si-hw-provider") == 0) {
1891 			(void) strncpy(hw_provider, bop_staging_area, SYS_NMLN);
1892 			hw_provider[SYS_NMLN - 1] = '\0';
1893 			continue;
1894 		}
1895 		if (strcmp(name, "bios-boot-device") == 0) {
1896 			copy_boot_str(bop_staging_area, property_val, 50);
1897 			(void) ndi_prop_update_string(DDI_DEV_T_NONE, devi,
1898 			    property_name, property_val);
1899 			continue;
1900 		}
1901 		if (strcmp(name, "stdout") == 0) {
1902 			(void) ndi_prop_update_int(DDI_DEV_T_NONE, devi,
1903 			    property_name, *((int *)bop_staging_area));
1904 			continue;
1905 		}
1906 
1907 		/* Boolean property */
1908 		if (length == 0) {
1909 			(void) e_ddi_prop_create(DDI_DEV_T_NONE, devi,
1910 			    DDI_PROP_CANSLEEP, property_name, NULL, 0);
1911 			continue;
1912 		}
1913 
1914 		/* Now anything else based on type. */
1915 		switch (flags) {
1916 		case DDI_PROP_TYPE_INT:
1917 			if (length == sizeof (int)) {
1918 				(void) e_ddi_prop_update_int(DDI_DEV_T_NONE,
1919 				    devi, property_name,
1920 				    *((int *)bop_staging_area));
1921 			} else {
1922 				(void) e_ddi_prop_update_int_array(
1923 				    DDI_DEV_T_NONE, devi, property_name,
1924 				    bop_staging_area, length / sizeof (int));
1925 			}
1926 			break;
1927 		case DDI_PROP_TYPE_STRING:
1928 			(void) e_ddi_prop_update_string(DDI_DEV_T_NONE, devi,
1929 			    property_name, bop_staging_area);
1930 			break;
1931 		case DDI_PROP_TYPE_BYTE:
1932 			(void) e_ddi_prop_update_byte_array(DDI_DEV_T_NONE,
1933 			    devi, property_name, bop_staging_area, length);
1934 			break;
1935 		case DDI_PROP_TYPE_INT64:
1936 			if (length == sizeof (int64_t)) {
1937 				(void) e_ddi_prop_update_int64(DDI_DEV_T_NONE,
1938 				    devi, property_name,
1939 				    *((int64_t *)bop_staging_area));
1940 			} else {
1941 				(void) e_ddi_prop_update_int64_array(
1942 				    DDI_DEV_T_NONE, devi, property_name,
1943 				    bop_staging_area,
1944 				    length / sizeof (int64_t));
1945 			}
1946 			break;
1947 		default:
1948 			/* Property type unknown, use old prop interface */
1949 			(void) e_ddi_prop_create(DDI_DEV_T_NONE, devi,
1950 			    DDI_PROP_CANSLEEP, property_name, bop_staging_area,
1951 			    length);
1952 		}
1953 	}
1954 
1955 	kmem_free(bop_staging_area, MMU_PAGESIZE);
1956 }
1957 
1958 static void
get_vga_properties(void)1959 get_vga_properties(void)
1960 {
1961 	dev_info_t *devi;
1962 	major_t major;
1963 	char *name;
1964 	int length;
1965 	char property_val[50];
1966 	void *bop_staging_area;
1967 
1968 	/*
1969 	 * XXXX Hack Allert!
1970 	 * There really needs to be a better way for identifying various
1971 	 * console framebuffers and their related issues.  Till then,
1972 	 * check for this one as a replacement to vgatext.
1973 	 */
1974 	major = ddi_name_to_major("ragexl");
1975 	if (major == (major_t)-1) {
1976 		major = ddi_name_to_major("vgatext");
1977 		if (major == (major_t)-1)
1978 			return;
1979 	}
1980 	devi = devnamesp[major].dn_head;
1981 	if (devi == NULL)
1982 		return;
1983 
1984 	bop_staging_area = kmem_zalloc(MMU_PAGESIZE, KM_SLEEP);
1985 
1986 	/*
1987 	 * Import "vga" properties from the boot.
1988 	 */
1989 	name = "display-edif-block";
1990 	length = BOP_GETPROPLEN(bootops, name);
1991 	if (length > 0 && length < MMU_PAGESIZE) {
1992 		BOP_GETPROP(bootops, name, bop_staging_area);
1993 		(void) ndi_prop_update_byte_array(DDI_DEV_T_NONE,
1994 		    devi, name, bop_staging_area, length);
1995 	}
1996 
1997 	/*
1998 	 * kdmconfig is also looking for display-type and
1999 	 * video-adapter-type. We default to color and svga.
2000 	 *
2001 	 * Could it be "monochrome", "vga"?
2002 	 * Nah, you've got to come to the 21st century...
2003 	 * And you can set monitor type manually in kdmconfig
2004 	 * if you are really an old junky.
2005 	 */
2006 	(void) ndi_prop_update_string(DDI_DEV_T_NONE,
2007 	    devi, "display-type", "color");
2008 	(void) ndi_prop_update_string(DDI_DEV_T_NONE,
2009 	    devi, "video-adapter-type", "svga");
2010 
2011 	name = "display-edif-id";
2012 	length = BOP_GETPROPLEN(bootops, name);
2013 	if (length > 0 && length < MMU_PAGESIZE) {
2014 		BOP_GETPROP(bootops, name, bop_staging_area);
2015 		copy_boot_str(bop_staging_area, property_val, length);
2016 		(void) ndi_prop_update_string(DDI_DEV_T_NONE,
2017 		    devi, name, property_val);
2018 	}
2019 
2020 	kmem_free(bop_staging_area, MMU_PAGESIZE);
2021 }
2022 
2023 /*
2024  * Copy console font to kernel memory. The temporary font setup
2025  * to use font module was done in early console setup, using low
2026  * memory and data from font module. Now we need to allocate
2027  * kernel memory and copy data over, so the low memory can be freed.
2028  * We can have at most one entry in font list from early boot.
2029  */
2030 static void
get_console_font(void)2031 get_console_font(void)
2032 {
2033 	struct fontlist *fp, *fl;
2034 	bitmap_data_t *bd;
2035 	struct font *fd, *tmp;
2036 	int i;
2037 
2038 	if (STAILQ_EMPTY(&fonts))
2039 		return;
2040 
2041 	fl = STAILQ_FIRST(&fonts);
2042 	STAILQ_REMOVE_HEAD(&fonts, font_next);
2043 	fp = kmem_zalloc(sizeof (*fp), KM_SLEEP);
2044 	bd = kmem_zalloc(sizeof (*bd), KM_SLEEP);
2045 	fd = kmem_zalloc(sizeof (*fd), KM_SLEEP);
2046 
2047 	fp->font_name = NULL;
2048 	fp->font_flags = FONT_BOOT;
2049 	fp->font_data = bd;
2050 
2051 	bd->width = fl->font_data->width;
2052 	bd->height = fl->font_data->height;
2053 	bd->uncompressed_size = fl->font_data->uncompressed_size;
2054 	bd->font = fd;
2055 
2056 	tmp = fl->font_data->font;
2057 	fd->vf_width = tmp->vf_width;
2058 	fd->vf_height = tmp->vf_height;
2059 	for (i = 0; i < VFNT_MAPS; i++) {
2060 		if (tmp->vf_map_count[i] == 0)
2061 			continue;
2062 		fd->vf_map_count[i] = tmp->vf_map_count[i];
2063 		fd->vf_map[i] = kmem_alloc(fd->vf_map_count[i] *
2064 		    sizeof (*fd->vf_map[i]), KM_SLEEP);
2065 		bcopy(tmp->vf_map[i], fd->vf_map[i], fd->vf_map_count[i] *
2066 		    sizeof (*fd->vf_map[i]));
2067 	}
2068 	fd->vf_bytes = kmem_alloc(bd->uncompressed_size, KM_SLEEP);
2069 	bcopy(tmp->vf_bytes, fd->vf_bytes, bd->uncompressed_size);
2070 	STAILQ_INSERT_HEAD(&fonts, fp, font_next);
2071 }
2072 
2073 /*
2074  * This is temporary, but absolutely necessary.  If we are being
2075  * booted with a device tree created by the DevConf project's bootconf
2076  * program, then we have device information nodes that reflect
2077  * reality.  At this point in time in the Solaris release schedule, the
2078  * kernel drivers aren't prepared for reality.  They still depend on their
2079  * own ad-hoc interpretations of the properties created when their .conf
2080  * files were interpreted. These drivers use an "ignore-hardware-nodes"
2081  * property to prevent them from using the nodes passed up from the bootconf
2082  * device tree.
2083  *
2084  * Trying to assemble root file system drivers as we are booting from
2085  * devconf will fail if the kernel driver is basing its name_addr's on the
2086  * psuedo-node device info while the bootpath passed up from bootconf is using
2087  * reality-based name_addrs.  We help the boot along in this case by
2088  * looking at the pre-bootconf bootpath and determining if we would have
2089  * successfully matched if that had been the bootpath we had chosen.
2090  *
2091  * Note that we only even perform this extra check if we've booted
2092  * using bootconf's 1275 compliant bootpath, this is the boot device, and
2093  * we're trying to match the name_addr specified in the 1275 bootpath.
2094  */
2095 
2096 #define	MAXCOMPONENTLEN	32
2097 
2098 int
x86_old_bootpath_name_addr_match(dev_info_t * cdip,char * caddr,char * naddr)2099 x86_old_bootpath_name_addr_match(dev_info_t *cdip, char *caddr, char *naddr)
2100 {
2101 	/*
2102 	 *  There are multiple criteria to be met before we can even
2103 	 *  consider allowing a name_addr match here.
2104 	 *
2105 	 *  1) We must have been booted such that the bootconf program
2106 	 *	created device tree nodes and properties.  This can be
2107 	 *	determined by examining the 'bootpath' property.  This
2108 	 *	property will be a non-null string iff bootconf was
2109 	 *	involved in the boot.
2110 	 *
2111 	 *  2) The module that we want to match must be the boot device.
2112 	 *
2113 	 *  3) The instance of the module we are thinking of letting be
2114 	 *	our match must be ignoring hardware nodes.
2115 	 *
2116 	 *  4) The name_addr we want to match must be the name_addr
2117 	 *	specified in the 1275 bootpath.
2118 	 */
2119 	static char bootdev_module[MAXCOMPONENTLEN];
2120 	static char bootdev_oldmod[MAXCOMPONENTLEN];
2121 	static char bootdev_newaddr[MAXCOMPONENTLEN];
2122 	static char bootdev_oldaddr[MAXCOMPONENTLEN];
2123 	static int  quickexit;
2124 
2125 	char *daddr;
2126 	int dlen;
2127 
2128 	char	*lkupname;
2129 	int	rv = DDI_FAILURE;
2130 
2131 	if ((ddi_getlongprop(DDI_DEV_T_ANY, cdip, DDI_PROP_DONTPASS,
2132 	    "devconf-addr", (caddr_t)&daddr, &dlen) == DDI_PROP_SUCCESS) &&
2133 	    (ddi_getprop(DDI_DEV_T_ANY, cdip, DDI_PROP_DONTPASS,
2134 	    "ignore-hardware-nodes", -1) != -1)) {
2135 		if (strcmp(daddr, caddr) == 0) {
2136 			return (DDI_SUCCESS);
2137 		}
2138 	}
2139 
2140 	if (quickexit)
2141 		return (rv);
2142 
2143 	if (bootdev_module[0] == '\0') {
2144 		char *addrp, *eoaddrp;
2145 		char *busp, *modp, *atp;
2146 		char *bp1275, *bp;
2147 		int  bp1275len, bplen;
2148 
2149 		bp1275 = bp = addrp = eoaddrp = busp = modp = atp = NULL;
2150 
2151 		if (ddi_getlongprop(DDI_DEV_T_ANY,
2152 		    ddi_root_node(), 0, "bootpath",
2153 		    (caddr_t)&bp1275, &bp1275len) != DDI_PROP_SUCCESS ||
2154 		    bp1275len <= 1) {
2155 			/*
2156 			 * We didn't boot from bootconf so we never need to
2157 			 * do any special matches.
2158 			 */
2159 			quickexit = 1;
2160 			if (bp1275)
2161 				kmem_free(bp1275, bp1275len);
2162 			return (rv);
2163 		}
2164 
2165 		if (ddi_getlongprop(DDI_DEV_T_ANY,
2166 		    ddi_root_node(), 0, "boot-path",
2167 		    (caddr_t)&bp, &bplen) != DDI_PROP_SUCCESS || bplen <= 1) {
2168 			/*
2169 			 * No fallback position for matching. This is
2170 			 * certainly unexpected, but we'll handle it
2171 			 * just in case.
2172 			 */
2173 			quickexit = 1;
2174 			kmem_free(bp1275, bp1275len);
2175 			if (bp)
2176 				kmem_free(bp, bplen);
2177 			return (rv);
2178 		}
2179 
2180 		/*
2181 		 *  Determine boot device module and 1275 name_addr
2182 		 *
2183 		 *  bootpath assumed to be of the form /bus/module@name_addr
2184 		 */
2185 		if ((busp = strchr(bp1275, '/')) != NULL) {
2186 			if ((modp = strchr(busp + 1, '/')) != NULL) {
2187 				if ((atp = strchr(modp + 1, '@')) != NULL) {
2188 					*atp = '\0';
2189 					addrp = atp + 1;
2190 					if ((eoaddrp = strchr(addrp, '/')) !=
2191 					    NULL)
2192 						*eoaddrp = '\0';
2193 				}
2194 			}
2195 		}
2196 
2197 		if (modp && addrp) {
2198 			(void) strncpy(bootdev_module, modp + 1,
2199 			    MAXCOMPONENTLEN);
2200 			bootdev_module[MAXCOMPONENTLEN - 1] = '\0';
2201 
2202 			(void) strncpy(bootdev_newaddr, addrp, MAXCOMPONENTLEN);
2203 			bootdev_newaddr[MAXCOMPONENTLEN - 1] = '\0';
2204 		} else {
2205 			quickexit = 1;
2206 			kmem_free(bp1275, bp1275len);
2207 			kmem_free(bp, bplen);
2208 			return (rv);
2209 		}
2210 
2211 		/*
2212 		 *  Determine fallback name_addr
2213 		 *
2214 		 *  10/3/96 - Also save fallback module name because it
2215 		 *  might actually be different than the current module
2216 		 *  name.  E.G., ISA pnp drivers have new names.
2217 		 *
2218 		 *  bootpath assumed to be of the form /bus/module@name_addr
2219 		 */
2220 		addrp = NULL;
2221 		if ((busp = strchr(bp, '/')) != NULL) {
2222 			if ((modp = strchr(busp + 1, '/')) != NULL) {
2223 				if ((atp = strchr(modp + 1, '@')) != NULL) {
2224 					*atp = '\0';
2225 					addrp = atp + 1;
2226 					if ((eoaddrp = strchr(addrp, '/')) !=
2227 					    NULL)
2228 						*eoaddrp = '\0';
2229 				}
2230 			}
2231 		}
2232 
2233 		if (modp && addrp) {
2234 			(void) strncpy(bootdev_oldmod, modp + 1,
2235 			    MAXCOMPONENTLEN);
2236 			bootdev_module[MAXCOMPONENTLEN - 1] = '\0';
2237 
2238 			(void) strncpy(bootdev_oldaddr, addrp, MAXCOMPONENTLEN);
2239 			bootdev_oldaddr[MAXCOMPONENTLEN - 1] = '\0';
2240 		}
2241 
2242 		/* Free up the bootpath storage now that we're done with it. */
2243 		kmem_free(bp1275, bp1275len);
2244 		kmem_free(bp, bplen);
2245 
2246 		if (bootdev_oldaddr[0] == '\0') {
2247 			quickexit = 1;
2248 			return (rv);
2249 		}
2250 	}
2251 
2252 	if (((lkupname = ddi_get_name(cdip)) != NULL) &&
2253 	    (strcmp(bootdev_module, lkupname) == 0 ||
2254 	    strcmp(bootdev_oldmod, lkupname) == 0) &&
2255 	    ((ddi_getprop(DDI_DEV_T_ANY, cdip, DDI_PROP_DONTPASS,
2256 	    "ignore-hardware-nodes", -1) != -1) ||
2257 	    ignore_hardware_nodes) &&
2258 	    strcmp(bootdev_newaddr, caddr) == 0 &&
2259 	    strcmp(bootdev_oldaddr, naddr) == 0) {
2260 		rv = DDI_SUCCESS;
2261 	}
2262 
2263 	return (rv);
2264 }
2265 
2266 /*
2267  * Perform a copy from a memory mapped device (whose devinfo pointer is devi)
2268  * separately mapped at devaddr in the kernel to a kernel buffer at kaddr.
2269  */
2270 /*ARGSUSED*/
2271 int
e_ddi_copyfromdev(dev_info_t * devi,off_t off,const void * devaddr,void * kaddr,size_t len)2272 e_ddi_copyfromdev(dev_info_t *devi,
2273     off_t off, const void *devaddr, void *kaddr, size_t len)
2274 {
2275 	bcopy(devaddr, kaddr, len);
2276 	return (0);
2277 }
2278 
2279 /*
2280  * Perform a copy to a memory mapped device (whose devinfo pointer is devi)
2281  * separately mapped at devaddr in the kernel from a kernel buffer at kaddr.
2282  */
2283 /*ARGSUSED*/
2284 int
e_ddi_copytodev(dev_info_t * devi,off_t off,const void * kaddr,void * devaddr,size_t len)2285 e_ddi_copytodev(dev_info_t *devi,
2286     off_t off, const void *kaddr, void *devaddr, size_t len)
2287 {
2288 	bcopy(kaddr, devaddr, len);
2289 	return (0);
2290 }
2291 
2292 
2293 static int
poke_mem(peekpoke_ctlops_t * in_args)2294 poke_mem(peekpoke_ctlops_t *in_args)
2295 {
2296 	int err;
2297 	on_trap_data_t otd;
2298 
2299 	/* Set up protected environment. */
2300 	if (!on_trap(&otd, OT_DATA_ACCESS)) {
2301 		err = DDI_SUCCESS;
2302 		switch (in_args->size) {
2303 		case sizeof (uint8_t):
2304 			*(uint8_t *)(in_args->dev_addr) =
2305 			    *(uint8_t *)in_args->host_addr;
2306 			break;
2307 
2308 		case sizeof (uint16_t):
2309 			*(uint16_t *)(in_args->dev_addr) =
2310 			    *(uint16_t *)in_args->host_addr;
2311 			break;
2312 
2313 		case sizeof (uint32_t):
2314 			*(uint32_t *)(in_args->dev_addr) =
2315 			    *(uint32_t *)in_args->host_addr;
2316 			break;
2317 
2318 		case sizeof (uint64_t):
2319 			*(uint64_t *)(in_args->dev_addr) =
2320 			    *(uint64_t *)in_args->host_addr;
2321 			break;
2322 
2323 		default:
2324 			err = DDI_FAILURE;
2325 			break;
2326 		}
2327 	} else {
2328 		err = DDI_FAILURE;
2329 	}
2330 
2331 	/* Take down protected environment. */
2332 	no_trap();
2333 
2334 	return (err);
2335 }
2336 
2337 
2338 static int
peek_mem(peekpoke_ctlops_t * in_args)2339 peek_mem(peekpoke_ctlops_t *in_args)
2340 {
2341 	int err;
2342 	on_trap_data_t otd;
2343 
2344 	if (!on_trap(&otd, OT_DATA_ACCESS)) {
2345 		err = DDI_SUCCESS;
2346 		switch (in_args->size) {
2347 		case sizeof (uint8_t):
2348 			*(uint8_t *)in_args->host_addr =
2349 			    *(uint8_t *)in_args->dev_addr;
2350 			break;
2351 
2352 		case sizeof (uint16_t):
2353 			*(uint16_t *)in_args->host_addr =
2354 			    *(uint16_t *)in_args->dev_addr;
2355 			break;
2356 
2357 		case sizeof (uint32_t):
2358 			*(uint32_t *)in_args->host_addr =
2359 			    *(uint32_t *)in_args->dev_addr;
2360 			break;
2361 
2362 		case sizeof (uint64_t):
2363 			*(uint64_t *)in_args->host_addr =
2364 			    *(uint64_t *)in_args->dev_addr;
2365 			break;
2366 
2367 		default:
2368 			err = DDI_FAILURE;
2369 			break;
2370 		}
2371 	} else {
2372 		err = DDI_FAILURE;
2373 	}
2374 
2375 	no_trap();
2376 	return (err);
2377 }
2378 
2379 
2380 /*
2381  * This is called only to process peek/poke when the DIP is NULL.
2382  * Assume that this is for memory, as nexi take care of device safe accesses.
2383  */
2384 int
peekpoke_mem(ddi_ctl_enum_t cmd,peekpoke_ctlops_t * in_args)2385 peekpoke_mem(ddi_ctl_enum_t cmd, peekpoke_ctlops_t *in_args)
2386 {
2387 	return (cmd == DDI_CTLOPS_PEEK ? peek_mem(in_args) : poke_mem(in_args));
2388 }
2389 
2390 /*
2391  * we've just done a cautious put/get. Check if it was successful by
2392  * calling pci_ereport_post() on all puts and for any gets that return -1
2393  */
2394 static int
pci_peekpoke_check_fma(dev_info_t * dip,void * arg,ddi_ctl_enum_t ctlop,void (* scan)(dev_info_t *,ddi_fm_error_t *))2395 pci_peekpoke_check_fma(dev_info_t *dip, void *arg, ddi_ctl_enum_t ctlop,
2396     void (*scan)(dev_info_t *, ddi_fm_error_t *))
2397 {
2398 	int	rval = DDI_SUCCESS;
2399 	peekpoke_ctlops_t *in_args = (peekpoke_ctlops_t *)arg;
2400 	ddi_fm_error_t de;
2401 	ddi_acc_impl_t *hp = (ddi_acc_impl_t *)in_args->handle;
2402 	ddi_acc_hdl_t *hdlp = (ddi_acc_hdl_t *)in_args->handle;
2403 	int check_err = 0;
2404 	int repcount = in_args->repcount;
2405 
2406 	if (ctlop == DDI_CTLOPS_POKE &&
2407 	    hdlp->ah_acc.devacc_attr_access != DDI_CAUTIOUS_ACC)
2408 		return (DDI_SUCCESS);
2409 
2410 	if (ctlop == DDI_CTLOPS_PEEK &&
2411 	    hdlp->ah_acc.devacc_attr_access != DDI_CAUTIOUS_ACC) {
2412 		for (; repcount; repcount--) {
2413 			switch (in_args->size) {
2414 			case sizeof (uint8_t):
2415 				if (*(uint8_t *)in_args->host_addr == 0xff)
2416 					check_err = 1;
2417 				break;
2418 			case sizeof (uint16_t):
2419 				if (*(uint16_t *)in_args->host_addr == 0xffff)
2420 					check_err = 1;
2421 				break;
2422 			case sizeof (uint32_t):
2423 				if (*(uint32_t *)in_args->host_addr ==
2424 				    0xffffffff)
2425 					check_err = 1;
2426 				break;
2427 			case sizeof (uint64_t):
2428 				if (*(uint64_t *)in_args->host_addr ==
2429 				    0xffffffffffffffff)
2430 					check_err = 1;
2431 				break;
2432 			}
2433 		}
2434 		if (check_err == 0)
2435 			return (DDI_SUCCESS);
2436 	}
2437 	/*
2438 	 * for a cautious put or get or a non-cautious get that returned -1 call
2439 	 * io framework to see if there really was an error
2440 	 */
2441 	bzero(&de, sizeof (ddi_fm_error_t));
2442 	de.fme_version = DDI_FME_VERSION;
2443 	de.fme_ena = fm_ena_generate(0, FM_ENA_FMT1);
2444 	if (hdlp->ah_acc.devacc_attr_access == DDI_CAUTIOUS_ACC) {
2445 		de.fme_flag = DDI_FM_ERR_EXPECTED;
2446 		de.fme_acc_handle = in_args->handle;
2447 	} else if (hdlp->ah_acc.devacc_attr_access == DDI_DEFAULT_ACC) {
2448 		/*
2449 		 * We only get here with DDI_DEFAULT_ACC for config space gets.
2450 		 * Non-hardened drivers may be probing the hardware and
2451 		 * expecting -1 returned. So need to treat errors on
2452 		 * DDI_DEFAULT_ACC as DDI_FM_ERR_EXPECTED.
2453 		 */
2454 		de.fme_flag = DDI_FM_ERR_EXPECTED;
2455 		de.fme_acc_handle = in_args->handle;
2456 	} else {
2457 		/*
2458 		 * Hardened driver doing protected accesses shouldn't
2459 		 * get errors unless there's a hardware problem. Treat
2460 		 * as nonfatal if there's an error, but set UNEXPECTED
2461 		 * so we raise ereports on any errors and potentially
2462 		 * fault the device
2463 		 */
2464 		de.fme_flag = DDI_FM_ERR_UNEXPECTED;
2465 	}
2466 	(void) scan(dip, &de);
2467 	if (hdlp->ah_acc.devacc_attr_access != DDI_DEFAULT_ACC &&
2468 	    de.fme_status != DDI_FM_OK) {
2469 		ndi_err_t *errp = (ndi_err_t *)hp->ahi_err;
2470 		rval = DDI_FAILURE;
2471 		errp->err_ena = de.fme_ena;
2472 		errp->err_expected = de.fme_flag;
2473 		errp->err_status = DDI_FM_NONFATAL;
2474 	}
2475 	return (rval);
2476 }
2477 
2478 /*
2479  * pci_peekpoke_check_nofma() is for when an error occurs on a register access
2480  * during pci_ereport_post(). We can't call pci_ereport_post() again or we'd
2481  * recurse, so assume all puts are OK and gets have failed if they return -1
2482  */
2483 static int
pci_peekpoke_check_nofma(void * arg,ddi_ctl_enum_t ctlop)2484 pci_peekpoke_check_nofma(void *arg, ddi_ctl_enum_t ctlop)
2485 {
2486 	int rval = DDI_SUCCESS;
2487 	peekpoke_ctlops_t *in_args = (peekpoke_ctlops_t *)arg;
2488 	ddi_acc_impl_t *hp = (ddi_acc_impl_t *)in_args->handle;
2489 	ddi_acc_hdl_t *hdlp = (ddi_acc_hdl_t *)in_args->handle;
2490 	int repcount = in_args->repcount;
2491 
2492 	if (ctlop == DDI_CTLOPS_POKE)
2493 		return (rval);
2494 
2495 	for (; repcount; repcount--) {
2496 		switch (in_args->size) {
2497 		case sizeof (uint8_t):
2498 			if (*(uint8_t *)in_args->host_addr == 0xff)
2499 				rval = DDI_FAILURE;
2500 			break;
2501 		case sizeof (uint16_t):
2502 			if (*(uint16_t *)in_args->host_addr == 0xffff)
2503 				rval = DDI_FAILURE;
2504 			break;
2505 		case sizeof (uint32_t):
2506 			if (*(uint32_t *)in_args->host_addr == 0xffffffff)
2507 				rval = DDI_FAILURE;
2508 			break;
2509 		case sizeof (uint64_t):
2510 			if (*(uint64_t *)in_args->host_addr ==
2511 			    0xffffffffffffffff)
2512 				rval = DDI_FAILURE;
2513 			break;
2514 		}
2515 	}
2516 	if (hdlp->ah_acc.devacc_attr_access != DDI_DEFAULT_ACC &&
2517 	    rval == DDI_FAILURE) {
2518 		ndi_err_t *errp = (ndi_err_t *)hp->ahi_err;
2519 		errp->err_ena = fm_ena_generate(0, FM_ENA_FMT1);
2520 		errp->err_expected = DDI_FM_ERR_UNEXPECTED;
2521 		errp->err_status = DDI_FM_NONFATAL;
2522 	}
2523 	return (rval);
2524 }
2525 
2526 int
pci_peekpoke_check(dev_info_t * dip,dev_info_t * rdip,ddi_ctl_enum_t ctlop,void * arg,void * result,int (* handler)(dev_info_t *,dev_info_t *,ddi_ctl_enum_t,void *,void *),kmutex_t * err_mutexp,kmutex_t * peek_poke_mutexp,void (* scan)(dev_info_t *,ddi_fm_error_t *))2527 pci_peekpoke_check(dev_info_t *dip, dev_info_t *rdip,
2528     ddi_ctl_enum_t ctlop, void *arg, void *result,
2529     int (*handler)(dev_info_t *, dev_info_t *, ddi_ctl_enum_t, void *,
2530     void *), kmutex_t *err_mutexp, kmutex_t *peek_poke_mutexp,
2531     void (*scan)(dev_info_t *, ddi_fm_error_t *))
2532 {
2533 	int rval;
2534 	peekpoke_ctlops_t *in_args = (peekpoke_ctlops_t *)arg;
2535 	ddi_acc_impl_t *hp = (ddi_acc_impl_t *)in_args->handle;
2536 
2537 	/*
2538 	 * this function only supports cautious accesses, not peeks/pokes
2539 	 * which don't have a handle
2540 	 */
2541 	if (hp == NULL)
2542 		return (DDI_FAILURE);
2543 
2544 	if (hp->ahi_acc_attr & DDI_ACCATTR_CONFIG_SPACE) {
2545 		if (!mutex_tryenter(err_mutexp)) {
2546 			/*
2547 			 * As this may be a recursive call from within
2548 			 * pci_ereport_post() we can't wait for the mutexes.
2549 			 * Fortunately we know someone is already calling
2550 			 * pci_ereport_post() which will handle the error bits
2551 			 * for us, and as this is a config space access we can
2552 			 * just do the access and check return value for -1
2553 			 * using pci_peekpoke_check_nofma().
2554 			 */
2555 			rval = handler(dip, rdip, ctlop, arg, result);
2556 			if (rval == DDI_SUCCESS)
2557 				rval = pci_peekpoke_check_nofma(arg, ctlop);
2558 			return (rval);
2559 		}
2560 		/*
2561 		 * This can't be a recursive call. Drop the err_mutex and get
2562 		 * both mutexes in the right order. If an error hasn't already
2563 		 * been detected by the ontrap code, use pci_peekpoke_check_fma
2564 		 * which will call pci_ereport_post() to check error status.
2565 		 */
2566 		mutex_exit(err_mutexp);
2567 	}
2568 	mutex_enter(peek_poke_mutexp);
2569 	rval = handler(dip, rdip, ctlop, arg, result);
2570 	if (rval == DDI_SUCCESS) {
2571 		mutex_enter(err_mutexp);
2572 		rval = pci_peekpoke_check_fma(dip, arg, ctlop, scan);
2573 		mutex_exit(err_mutexp);
2574 	}
2575 	mutex_exit(peek_poke_mutexp);
2576 	return (rval);
2577 }
2578 
2579 void
impl_setup_ddi(void)2580 impl_setup_ddi(void)
2581 {
2582 #if !defined(__xpv)
2583 	extern void startup_bios_disk(void);
2584 	extern int post_fastreboot;
2585 #endif
2586 	dev_info_t *xdip, *isa_dip;
2587 	rd_existing_t rd_mem_prop;
2588 	int err;
2589 
2590 	ndi_devi_alloc_sleep(ddi_root_node(), "ramdisk",
2591 	    (pnode_t)DEVI_SID_NODEID, &xdip);
2592 
2593 	(void) BOP_GETPROP(bootops,
2594 	    "ramdisk_start", (void *)&ramdisk_start);
2595 	(void) BOP_GETPROP(bootops,
2596 	    "ramdisk_end", (void *)&ramdisk_end);
2597 
2598 #ifdef __xpv
2599 	ramdisk_start -= ONE_GIG;
2600 	ramdisk_end -= ONE_GIG;
2601 #endif
2602 	rd_mem_prop.phys = ramdisk_start;
2603 	rd_mem_prop.size = ramdisk_end - ramdisk_start + 1;
2604 
2605 	(void) ndi_prop_update_byte_array(DDI_DEV_T_NONE, xdip,
2606 	    RD_EXISTING_PROP_NAME, (uchar_t *)&rd_mem_prop,
2607 	    sizeof (rd_mem_prop));
2608 	err = ndi_devi_bind_driver(xdip, 0);
2609 	ASSERT(err == 0);
2610 
2611 	/* isa node */
2612 	if (pseudo_isa) {
2613 		ndi_devi_alloc_sleep(ddi_root_node(), "isa",
2614 		    (pnode_t)DEVI_SID_NODEID, &isa_dip);
2615 		(void) ndi_prop_update_string(DDI_DEV_T_NONE, isa_dip,
2616 		    "device_type", "isa");
2617 		(void) ndi_prop_update_string(DDI_DEV_T_NONE, isa_dip,
2618 		    "bus-type", "isa");
2619 		(void) ndi_devi_bind_driver(isa_dip, 0);
2620 	}
2621 
2622 	/*
2623 	 * Read in the properties from the boot.
2624 	 */
2625 	get_boot_properties();
2626 
2627 	/* not framebuffer should be enumerated, if present */
2628 	get_vga_properties();
2629 
2630 	/* Copy console font if provided by boot. */
2631 	get_console_font();
2632 
2633 	/*
2634 	 * Check for administratively disabled drivers.
2635 	 */
2636 	check_driver_disable();
2637 
2638 #if !defined(__xpv)
2639 	if (!post_fastreboot && BOP_GETPROPLEN(bootops, "efi-systab") < 0)
2640 		startup_bios_disk();
2641 #endif
2642 	/* do bus dependent probes. */
2643 	impl_bus_initialprobe();
2644 }
2645 
2646 dev_t
getrootdev(void)2647 getrootdev(void)
2648 {
2649 	/*
2650 	 * Usually rootfs.bo_name is initialized by the
2651 	 * the bootpath property from bootenv.rc, but
2652 	 * defaults to "/ramdisk:a" otherwise.
2653 	 */
2654 	return (ddi_pathname_to_dev_t(rootfs.bo_name));
2655 }
2656 
2657 static struct bus_probe {
2658 	struct bus_probe *next;
2659 	void (*probe)(int);
2660 } *bus_probes;
2661 
2662 void
impl_bus_add_probe(void (* func)(int))2663 impl_bus_add_probe(void (*func)(int))
2664 {
2665 	struct bus_probe *probe;
2666 	struct bus_probe *lastprobe = NULL;
2667 
2668 	probe = kmem_alloc(sizeof (*probe), KM_SLEEP);
2669 	probe->probe = func;
2670 	probe->next = NULL;
2671 
2672 	if (!bus_probes) {
2673 		bus_probes = probe;
2674 		return;
2675 	}
2676 
2677 	lastprobe = bus_probes;
2678 	while (lastprobe->next)
2679 		lastprobe = lastprobe->next;
2680 	lastprobe->next = probe;
2681 }
2682 
2683 /*ARGSUSED*/
2684 void
impl_bus_delete_probe(void (* func)(int))2685 impl_bus_delete_probe(void (*func)(int))
2686 {
2687 	struct bus_probe *prev = NULL;
2688 	struct bus_probe *probe = bus_probes;
2689 
2690 	while (probe) {
2691 		if (probe->probe == func)
2692 			break;
2693 		prev = probe;
2694 		probe = probe->next;
2695 	}
2696 
2697 	if (probe == NULL)
2698 		return;
2699 
2700 	if (prev)
2701 		prev->next = probe->next;
2702 	else
2703 		bus_probes = probe->next;
2704 
2705 	kmem_free(probe, sizeof (struct bus_probe));
2706 }
2707 
2708 /*
2709  * impl_bus_initialprobe
2710  *	Modload the prom simulator, then let it probe to verify existence
2711  *	and type of PCI support.
2712  */
2713 static void
impl_bus_initialprobe(void)2714 impl_bus_initialprobe(void)
2715 {
2716 	struct bus_probe *probe;
2717 
2718 	/* load modules to install bus probes */
2719 #if defined(__xpv)
2720 	if (DOMAIN_IS_INITDOMAIN(xen_info)) {
2721 		if (modload("misc", "pci_autoconfig") < 0) {
2722 			panic("failed to load misc/pci_autoconfig");
2723 		}
2724 
2725 		if (modload("drv", "isa") < 0)
2726 			panic("failed to load drv/isa");
2727 	}
2728 
2729 	(void) modload("misc", "xpv_autoconfig");
2730 #else
2731 	if (modload("misc", "pci_autoconfig") < 0) {
2732 		panic("failed to load misc/pci_autoconfig");
2733 	}
2734 
2735 	(void) modload("misc", "acpidev");
2736 
2737 	if (modload("drv", "isa") < 0)
2738 		panic("failed to load drv/isa");
2739 #endif
2740 
2741 	probe = bus_probes;
2742 	while (probe) {
2743 		/* run the probe functions */
2744 		(*probe->probe)(0);
2745 		probe = probe->next;
2746 	}
2747 }
2748 
2749 /*
2750  * impl_bus_reprobe
2751  *	Reprogram devices not set up by firmware.
2752  */
2753 static void
impl_bus_reprobe(void)2754 impl_bus_reprobe(void)
2755 {
2756 	struct bus_probe *probe;
2757 
2758 	probe = bus_probes;
2759 	while (probe) {
2760 		/* run the probe function */
2761 		(*probe->probe)(1);
2762 		probe = probe->next;
2763 	}
2764 }
2765 
2766 
2767 /*
2768  * The following functions ready a cautious request to go up to the nexus
2769  * driver.  It is up to the nexus driver to decide how to process the request.
2770  * It may choose to call i_ddi_do_caut_get/put in this file, or do it
2771  * differently.
2772  */
2773 
2774 static void
i_ddi_caut_getput_ctlops(ddi_acc_impl_t * hp,uint64_t host_addr,uint64_t dev_addr,size_t size,size_t repcount,uint_t flags,ddi_ctl_enum_t cmd)2775 i_ddi_caut_getput_ctlops(ddi_acc_impl_t *hp, uint64_t host_addr,
2776     uint64_t dev_addr, size_t size, size_t repcount, uint_t flags,
2777     ddi_ctl_enum_t cmd)
2778 {
2779 	peekpoke_ctlops_t	cautacc_ctlops_arg;
2780 
2781 	cautacc_ctlops_arg.size = size;
2782 	cautacc_ctlops_arg.dev_addr = dev_addr;
2783 	cautacc_ctlops_arg.host_addr = host_addr;
2784 	cautacc_ctlops_arg.handle = (ddi_acc_handle_t)hp;
2785 	cautacc_ctlops_arg.repcount = repcount;
2786 	cautacc_ctlops_arg.flags = flags;
2787 
2788 	(void) ddi_ctlops(hp->ahi_common.ah_dip, hp->ahi_common.ah_dip, cmd,
2789 	    &cautacc_ctlops_arg, NULL);
2790 }
2791 
2792 uint8_t
i_ddi_caut_get8(ddi_acc_impl_t * hp,uint8_t * addr)2793 i_ddi_caut_get8(ddi_acc_impl_t *hp, uint8_t *addr)
2794 {
2795 	uint8_t value;
2796 	i_ddi_caut_getput_ctlops(hp, (uintptr_t)&value, (uintptr_t)addr,
2797 	    sizeof (uint8_t), 1, 0, DDI_CTLOPS_PEEK);
2798 
2799 	return (value);
2800 }
2801 
2802 uint16_t
i_ddi_caut_get16(ddi_acc_impl_t * hp,uint16_t * addr)2803 i_ddi_caut_get16(ddi_acc_impl_t *hp, uint16_t *addr)
2804 {
2805 	uint16_t value;
2806 	i_ddi_caut_getput_ctlops(hp, (uintptr_t)&value, (uintptr_t)addr,
2807 	    sizeof (uint16_t), 1, 0, DDI_CTLOPS_PEEK);
2808 
2809 	return (value);
2810 }
2811 
2812 uint32_t
i_ddi_caut_get32(ddi_acc_impl_t * hp,uint32_t * addr)2813 i_ddi_caut_get32(ddi_acc_impl_t *hp, uint32_t *addr)
2814 {
2815 	uint32_t value;
2816 	i_ddi_caut_getput_ctlops(hp, (uintptr_t)&value, (uintptr_t)addr,
2817 	    sizeof (uint32_t), 1, 0, DDI_CTLOPS_PEEK);
2818 
2819 	return (value);
2820 }
2821 
2822 uint64_t
i_ddi_caut_get64(ddi_acc_impl_t * hp,uint64_t * addr)2823 i_ddi_caut_get64(ddi_acc_impl_t *hp, uint64_t *addr)
2824 {
2825 	uint64_t value;
2826 	i_ddi_caut_getput_ctlops(hp, (uintptr_t)&value, (uintptr_t)addr,
2827 	    sizeof (uint64_t), 1, 0, DDI_CTLOPS_PEEK);
2828 
2829 	return (value);
2830 }
2831 
2832 void
i_ddi_caut_put8(ddi_acc_impl_t * hp,uint8_t * addr,uint8_t value)2833 i_ddi_caut_put8(ddi_acc_impl_t *hp, uint8_t *addr, uint8_t value)
2834 {
2835 	i_ddi_caut_getput_ctlops(hp, (uintptr_t)&value, (uintptr_t)addr,
2836 	    sizeof (uint8_t), 1, 0, DDI_CTLOPS_POKE);
2837 }
2838 
2839 void
i_ddi_caut_put16(ddi_acc_impl_t * hp,uint16_t * addr,uint16_t value)2840 i_ddi_caut_put16(ddi_acc_impl_t *hp, uint16_t *addr, uint16_t value)
2841 {
2842 	i_ddi_caut_getput_ctlops(hp, (uintptr_t)&value, (uintptr_t)addr,
2843 	    sizeof (uint16_t), 1, 0, DDI_CTLOPS_POKE);
2844 }
2845 
2846 void
i_ddi_caut_put32(ddi_acc_impl_t * hp,uint32_t * addr,uint32_t value)2847 i_ddi_caut_put32(ddi_acc_impl_t *hp, uint32_t *addr, uint32_t value)
2848 {
2849 	i_ddi_caut_getput_ctlops(hp, (uintptr_t)&value, (uintptr_t)addr,
2850 	    sizeof (uint32_t), 1, 0, DDI_CTLOPS_POKE);
2851 }
2852 
2853 void
i_ddi_caut_put64(ddi_acc_impl_t * hp,uint64_t * addr,uint64_t value)2854 i_ddi_caut_put64(ddi_acc_impl_t *hp, uint64_t *addr, uint64_t value)
2855 {
2856 	i_ddi_caut_getput_ctlops(hp, (uintptr_t)&value, (uintptr_t)addr,
2857 	    sizeof (uint64_t), 1, 0, DDI_CTLOPS_POKE);
2858 }
2859 
2860 void
i_ddi_caut_rep_get8(ddi_acc_impl_t * hp,uint8_t * host_addr,uint8_t * dev_addr,size_t repcount,uint_t flags)2861 i_ddi_caut_rep_get8(ddi_acc_impl_t *hp, uint8_t *host_addr, uint8_t *dev_addr,
2862     size_t repcount, uint_t flags)
2863 {
2864 	i_ddi_caut_getput_ctlops(hp, (uintptr_t)host_addr, (uintptr_t)dev_addr,
2865 	    sizeof (uint8_t), repcount, flags, DDI_CTLOPS_PEEK);
2866 }
2867 
2868 void
i_ddi_caut_rep_get16(ddi_acc_impl_t * hp,uint16_t * host_addr,uint16_t * dev_addr,size_t repcount,uint_t flags)2869 i_ddi_caut_rep_get16(ddi_acc_impl_t *hp, uint16_t *host_addr,
2870     uint16_t *dev_addr, size_t repcount, uint_t flags)
2871 {
2872 	i_ddi_caut_getput_ctlops(hp, (uintptr_t)host_addr, (uintptr_t)dev_addr,
2873 	    sizeof (uint16_t), repcount, flags, DDI_CTLOPS_PEEK);
2874 }
2875 
2876 void
i_ddi_caut_rep_get32(ddi_acc_impl_t * hp,uint32_t * host_addr,uint32_t * dev_addr,size_t repcount,uint_t flags)2877 i_ddi_caut_rep_get32(ddi_acc_impl_t *hp, uint32_t *host_addr,
2878     uint32_t *dev_addr, size_t repcount, uint_t flags)
2879 {
2880 	i_ddi_caut_getput_ctlops(hp, (uintptr_t)host_addr, (uintptr_t)dev_addr,
2881 	    sizeof (uint32_t), repcount, flags, DDI_CTLOPS_PEEK);
2882 }
2883 
2884 void
i_ddi_caut_rep_get64(ddi_acc_impl_t * hp,uint64_t * host_addr,uint64_t * dev_addr,size_t repcount,uint_t flags)2885 i_ddi_caut_rep_get64(ddi_acc_impl_t *hp, uint64_t *host_addr,
2886     uint64_t *dev_addr, size_t repcount, uint_t flags)
2887 {
2888 	i_ddi_caut_getput_ctlops(hp, (uintptr_t)host_addr, (uintptr_t)dev_addr,
2889 	    sizeof (uint64_t), repcount, flags, DDI_CTLOPS_PEEK);
2890 }
2891 
2892 void
i_ddi_caut_rep_put8(ddi_acc_impl_t * hp,uint8_t * host_addr,uint8_t * dev_addr,size_t repcount,uint_t flags)2893 i_ddi_caut_rep_put8(ddi_acc_impl_t *hp, uint8_t *host_addr, uint8_t *dev_addr,
2894     size_t repcount, uint_t flags)
2895 {
2896 	i_ddi_caut_getput_ctlops(hp, (uintptr_t)host_addr, (uintptr_t)dev_addr,
2897 	    sizeof (uint8_t), repcount, flags, DDI_CTLOPS_POKE);
2898 }
2899 
2900 void
i_ddi_caut_rep_put16(ddi_acc_impl_t * hp,uint16_t * host_addr,uint16_t * dev_addr,size_t repcount,uint_t flags)2901 i_ddi_caut_rep_put16(ddi_acc_impl_t *hp, uint16_t *host_addr,
2902     uint16_t *dev_addr, size_t repcount, uint_t flags)
2903 {
2904 	i_ddi_caut_getput_ctlops(hp, (uintptr_t)host_addr, (uintptr_t)dev_addr,
2905 	    sizeof (uint16_t), repcount, flags, DDI_CTLOPS_POKE);
2906 }
2907 
2908 void
i_ddi_caut_rep_put32(ddi_acc_impl_t * hp,uint32_t * host_addr,uint32_t * dev_addr,size_t repcount,uint_t flags)2909 i_ddi_caut_rep_put32(ddi_acc_impl_t *hp, uint32_t *host_addr,
2910     uint32_t *dev_addr, size_t repcount, uint_t flags)
2911 {
2912 	i_ddi_caut_getput_ctlops(hp, (uintptr_t)host_addr, (uintptr_t)dev_addr,
2913 	    sizeof (uint32_t), repcount, flags, DDI_CTLOPS_POKE);
2914 }
2915 
2916 void
i_ddi_caut_rep_put64(ddi_acc_impl_t * hp,uint64_t * host_addr,uint64_t * dev_addr,size_t repcount,uint_t flags)2917 i_ddi_caut_rep_put64(ddi_acc_impl_t *hp, uint64_t *host_addr,
2918     uint64_t *dev_addr, size_t repcount, uint_t flags)
2919 {
2920 	i_ddi_caut_getput_ctlops(hp, (uintptr_t)host_addr, (uintptr_t)dev_addr,
2921 	    sizeof (uint64_t), repcount, flags, DDI_CTLOPS_POKE);
2922 }
2923 
2924 boolean_t
i_ddi_copybuf_required(ddi_dma_attr_t * attrp)2925 i_ddi_copybuf_required(ddi_dma_attr_t *attrp)
2926 {
2927 	uint64_t hi_pa;
2928 
2929 	hi_pa = ((uint64_t)physmax + 1ull) << PAGESHIFT;
2930 	if (attrp->dma_attr_addr_hi < hi_pa) {
2931 		return (B_TRUE);
2932 	}
2933 
2934 	return (B_FALSE);
2935 }
2936 
2937 size_t
i_ddi_copybuf_size()2938 i_ddi_copybuf_size()
2939 {
2940 	return (dma_max_copybuf_size);
2941 }
2942 
2943 /*
2944  * i_ddi_dma_max()
2945  *    returns the maximum DMA size which can be performed in a single DMA
2946  *    window taking into account the devices DMA contraints (attrp), the
2947  *    maximum copy buffer size (if applicable), and the worse case buffer
2948  *    fragmentation.
2949  */
2950 /*ARGSUSED*/
2951 uint32_t
i_ddi_dma_max(dev_info_t * dip,ddi_dma_attr_t * attrp)2952 i_ddi_dma_max(dev_info_t *dip, ddi_dma_attr_t *attrp)
2953 {
2954 	uint64_t maxxfer;
2955 
2956 
2957 	/*
2958 	 * take the min of maxxfer and the the worse case fragementation
2959 	 * (e.g. every cookie <= 1 page)
2960 	 */
2961 	maxxfer = MIN(attrp->dma_attr_maxxfer,
2962 	    ((uint64_t)(attrp->dma_attr_sgllen - 1) << PAGESHIFT));
2963 
2964 	/*
2965 	 * If the DMA engine can't reach all off memory, we also need to take
2966 	 * the max size of the copybuf into consideration.
2967 	 */
2968 	if (i_ddi_copybuf_required(attrp)) {
2969 		maxxfer = MIN(i_ddi_copybuf_size(), maxxfer);
2970 	}
2971 
2972 	/*
2973 	 * we only return a 32-bit value. Make sure it's not -1. Round to a
2974 	 * page so it won't be mistaken for an error value during debug.
2975 	 */
2976 	if (maxxfer >= 0xFFFFFFFF) {
2977 		maxxfer = 0xFFFFF000;
2978 	}
2979 
2980 	/*
2981 	 * make sure the value we return is a whole multiple of the
2982 	 * granlarity.
2983 	 */
2984 	if (attrp->dma_attr_granular > 1) {
2985 		maxxfer = maxxfer - (maxxfer % attrp->dma_attr_granular);
2986 	}
2987 
2988 	return ((uint32_t)maxxfer);
2989 }
2990 
2991 /*ARGSUSED*/
2992 void
translate_devid(dev_info_t * dip)2993 translate_devid(dev_info_t *dip)
2994 {
2995 }
2996 
2997 pfn_t
i_ddi_paddr_to_pfn(paddr_t paddr)2998 i_ddi_paddr_to_pfn(paddr_t paddr)
2999 {
3000 	pfn_t pfn;
3001 
3002 #ifdef __xpv
3003 	if (DOMAIN_IS_INITDOMAIN(xen_info)) {
3004 		pfn = xen_assign_pfn(mmu_btop(paddr));
3005 	} else {
3006 		pfn = mmu_btop(paddr);
3007 	}
3008 #else
3009 	pfn = mmu_btop(paddr);
3010 #endif
3011 
3012 	return (pfn);
3013 }
3014