xref: /titanic_44/usr/src/uts/sun4u/sunfire/io/ac.c (revision a60349c89adffc0902b2353230891d8e7f2b24d9)
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 2009 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  * Copyright (c) 2011 Bayard G. Bell. All rights reserved.
26  */
27 
28 
29 #include <sys/types.h>
30 #include <sys/conf.h>
31 #include <sys/ddi.h>
32 #include <sys/sunddi.h>
33 #include <sys/ddi_impldefs.h>
34 #include <sys/obpdefs.h>
35 #include <sys/cmn_err.h>
36 #include <sys/errno.h>
37 #include <sys/kmem.h>
38 #include <sys/debug.h>
39 #include <sys/sysmacros.h>
40 #include <sys/machsystm.h>
41 #include <vm/hat_sfmmu.h>
42 #include <sys/autoconf.h>
43 #include <sys/open.h>
44 #include <sys/stat.h>
45 #include <sys/modctl.h>
46 #include <sys/fhc.h>
47 #include <sys/ac.h>
48 #include <sys/cpu_module.h>
49 #include <sys/x_call.h>
50 #include <sys/fpu/fpusystm.h>
51 #include <sys/lgrp.h>
52 
53 /* Useful debugging Stuff */
54 #include <sys/nexusdebug.h>
55 
56 /*
57  * Function prototypes
58  */
59 
60 static int ac_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg,
61 		void **result);
62 static int ac_attach(dev_info_t *, ddi_attach_cmd_t);
63 static int ac_detach(dev_info_t *, ddi_detach_cmd_t);
64 static int ac_open(dev_t *, int, int, cred_t *);
65 static int ac_close(dev_t, int, int, cred_t *);
66 static int ac_ioctl(dev_t, int, intptr_t, int, cred_t *, int *);
67 
68 static void ac_add_kstats(struct ac_soft_state *);
69 static void ac_del_kstats(struct ac_soft_state *);
70 static int ac_misc_kstat_update(kstat_t *, int);
71 static void ac_add_picN_kstats(dev_info_t *dip);
72 static int ac_counters_kstat_update(kstat_t *, int);
73 static void ac_get_memory_status(struct ac_soft_state *, enum ac_bank_id);
74 static void ac_eval_memory_status(struct ac_soft_state *, enum ac_bank_id);
75 static void ac_ecache_flush(uint64_t, uint64_t);
76 static int ac_pkt_init(ac_cfga_pkt_t *pkt, intptr_t arg, int flag);
77 static int ac_pkt_fini(ac_cfga_pkt_t *pkt, intptr_t arg, int flag);
78 static int ac_reset_timeout(int rw);
79 static void ac_timeout(void *);
80 static int ac_enter_transition(void);
81 static void ac_exit_transition(void);
82 
83 
84 int ac_add_memory(ac_cfga_pkt_t *);
85 int ac_del_memory(ac_cfga_pkt_t *);
86 int ac_mem_stat(ac_cfga_pkt_t *, int);
87 int ac_mem_test_start(ac_cfga_pkt_t *, int);
88 int ac_mem_test_stop(ac_cfga_pkt_t *, int);
89 int ac_mem_test_read(ac_cfga_pkt_t *, int);
90 int ac_mem_test_write(ac_cfga_pkt_t *, int);
91 void ac_mem_test_stop_on_close(uint_t, uint_t);
92 /*
93  * ac audit message events
94  */
95 typedef enum {
96 	AC_AUDIT_OSTATE_CONFIGURE,
97 	AC_AUDIT_OSTATE_UNCONFIGURE,
98 	AC_AUDIT_OSTATE_SUCCEEDED,
99 	AC_AUDIT_OSTATE_CONFIGURE_FAILED,
100 	AC_AUDIT_OSTATE_UNCONFIGURE_FAILED
101 } ac_audit_evt_t;
102 static void ac_policy_audit_messages(ac_audit_evt_t event, ac_cfga_pkt_t *pkt);
103 static char *ac_ostate_typestr(sysc_cfga_ostate_t ostate, ac_audit_evt_t event);
104 
105 /* The memory ioctl interface version of this driver. */
106 static ac_mem_version_t ac_mem_version = AC_MEM_ADMIN_VERSION;
107 
108 static int ac_mem_exercise(ac_cfga_pkt_t *, int);
109 
110 /*
111  * Configuration data structures
112  */
113 static struct cb_ops ac_cb_ops = {
114 	ac_open,			/* open */
115 	ac_close,			/* close */
116 	nulldev,			/* strategy */
117 	nulldev,			/* print */
118 	nodev,				/* dump */
119 	nulldev,			/* read */
120 	nulldev,			/* write */
121 	ac_ioctl,			/* ioctl */
122 	nodev,				/* devmap */
123 	nodev,				/* mmap */
124 	nodev,				/* segmap */
125 	nochpoll,			/* poll */
126 	ddi_prop_op,			/* cb_prop_op */
127 	0,				/* streamtab */
128 	D_MP | D_NEW | D_HOTPLUG,	/* Driver compatibility flag */
129 	CB_REV,				/* rev */
130 	nodev,				/* cb_aread */
131 	nodev				/* cb_awrite */
132 };
133 
134 static struct dev_ops ac_ops = {
135 	DEVO_REV,			/* devo_rev, */
136 	0,				/* refcnt */
137 	ac_info,			/* getinfo */
138 	nulldev,			/* identify */
139 	nulldev,			/* probe */
140 	ac_attach,			/* attach */
141 	ac_detach,			/* detach */
142 	nulldev,			/* reset */
143 	&ac_cb_ops,			/* cb_ops */
144 	(struct bus_ops *)0,		/* bus_ops */
145 	nulldev,			/* power */
146 	ddi_quiesce_not_needed,			/* quiesce */
147 };
148 
149 /*
150  * Driver globals
151  */
152 void *acp;				/* ac soft state hook */
153 static kstat_t	*ac_picN_ksp[AC_NUM_PICS];	/* performance picN kstats */
154 static int	ac_attachcnt = 0;	/* number of instances attached */
155 static kmutex_t ac_attachcnt_mutex;	/* ac_attachcnt lock - attach/detach */
156 static kmutex_t ac_hot_plug_mode_mutex;
157 static timeout_id_t	ac_hot_plug_timeout;
158 static int		ac_hot_plug_timeout_interval = 10;
159 
160 #define	AC_GETSOFTC(I) \
161 	((struct ac_soft_state *)ddi_get_soft_state(acp, (I)))
162 
163 extern struct mod_ops mod_driverops;
164 
165 static struct modldrv modldrv = {
166 	&mod_driverops,		/* Type of module.  This one is a driver */
167 	"AC Leaf",		/* name of module */
168 	&ac_ops,		/* driver ops */
169 };
170 
171 static struct modlinkage modlinkage = {
172 	MODREV_1,
173 	(void *)&modldrv,
174 	NULL
175 };
176 
177 /*
178  * These are the module initialization routines.
179  */
180 
181 int
182 _init(void)
183 {
184 	int error;
185 
186 	if ((error = ddi_soft_state_init(&acp, sizeof (struct ac_soft_state),
187 	    1)) != 0)
188 		return (error);
189 
190 	if ((error = mod_install(&modlinkage)) != 0) {
191 		ddi_soft_state_fini(&acp);
192 		return (error);
193 	}
194 	/* Initialize global mutex */
195 	mutex_init(&ac_attachcnt_mutex, NULL, MUTEX_DRIVER, NULL);
196 	mutex_init(&ac_hot_plug_mode_mutex, NULL, MUTEX_DRIVER, NULL);
197 	return (0);
198 }
199 
200 int
201 _fini(void)
202 {
203 	int error;
204 
205 	if ((error = mod_remove(&modlinkage)) == 0) {
206 		ddi_soft_state_fini(&acp);
207 		mutex_destroy(&ac_attachcnt_mutex);
208 		mutex_destroy(&ac_hot_plug_mode_mutex);
209 	}
210 	return (error);
211 }
212 
213 int
214 _info(struct modinfo *modinfop)
215 {
216 	return (mod_info(&modlinkage, modinfop));
217 }
218 
219 /* ARGSUSED */
220 static int
221 ac_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result)
222 {
223 	dev_t	dev;
224 	int	instance;
225 
226 	if (infocmd == DDI_INFO_DEVT2INSTANCE) {
227 		dev = (dev_t)arg;
228 		instance = AC_GETINSTANCE(getminor(dev));
229 		*result = (void *)(uintptr_t)instance;
230 		return (DDI_SUCCESS);
231 	}
232 	return (DDI_FAILURE);
233 }
234 
235 static int
236 ac_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
237 {
238 	int instance;
239 	struct ac_soft_state *softsp;
240 	struct bd_list *list = NULL;
241 
242 	switch (cmd) {
243 	case DDI_ATTACH:
244 		break;
245 
246 	case DDI_RESUME:
247 		return (DDI_SUCCESS);
248 
249 	default:
250 		return (DDI_FAILURE);
251 	}
252 
253 	instance = ddi_get_instance(devi);
254 
255 	if (ddi_soft_state_zalloc(acp, instance) != DDI_SUCCESS) {
256 		cmn_err(CE_WARN, "ddi_soft_state_zalloc failed for ac%d",
257 		    instance);
258 		return (DDI_FAILURE);
259 	}
260 
261 	softsp = ddi_get_soft_state(acp, instance);
262 
263 	/* Set the dip in the soft state */
264 	softsp->dip = devi;
265 
266 	/* Get the board number from this nodes parent */
267 	softsp->pdip = ddi_get_parent(softsp->dip);
268 	if ((softsp->board = (int)ddi_getprop(DDI_DEV_T_ANY, softsp->pdip,
269 	    DDI_PROP_DONTPASS, OBP_BOARDNUM, -1)) == -1) {
270 		cmn_err(CE_WARN, "ac%d: unable to retrieve %s property",
271 		    instance, OBP_BOARDNUM);
272 		goto bad;
273 	}
274 
275 	DPRINTF(AC_ATTACH_DEBUG, ("ac%d: devi= 0x%p\n,"
276 	    " softsp=0x%p\n", instance, (void *)devi, (void *)softsp));
277 
278 	/* map in the registers for this device. */
279 	if (ddi_map_regs(softsp->dip, 0, (caddr_t *)&softsp->ac_base, 0, 0)) {
280 		cmn_err(CE_WARN, "ac%d: unable to map registers", instance);
281 		goto bad;
282 	}
283 
284 	/* Setup the pointers to the hardware registers */
285 	softsp->ac_id = (uint32_t *)softsp->ac_base;
286 	softsp->ac_memctl = (uint64_t *)((char *)softsp->ac_base +
287 	    AC_OFF_MEMCTL);
288 	softsp->ac_memdecode0 = (uint64_t *)((char *)softsp->ac_base +
289 	    AC_OFF_MEMDEC0);
290 	softsp->ac_memdecode1 = (uint64_t *)((char *)softsp->ac_base +
291 	    AC_OFF_MEMDEC1);
292 	softsp->ac_counter = (uint64_t *)((char *)softsp->ac_base +
293 	    AC_OFF_CNTR);
294 	softsp->ac_mccr = (uint32_t *)((char *)softsp->ac_base +
295 	    AC_OFF_MCCR);
296 
297 	/* nothing to suspend/resume here */
298 	(void) ddi_prop_update_string(DDI_DEV_T_NONE, devi,
299 	    "pm-hardware-state", "no-suspend-resume");
300 
301 	/* setup the the AC counter registers to allow for hotplug. */
302 	list = fhc_bdlist_lock(softsp->board);
303 
304 	if (list == NULL) {
305 		cmn_err(CE_PANIC, "ac%d: Board %d not found in database",
306 		    instance, softsp->board);
307 	}
308 
309 	/* set the AC rev into the bd list structure */
310 	list->sc.ac_compid = *softsp->ac_id;
311 
312 	list->ac_softsp = softsp;
313 
314 	if (list->sc.type == CPU_BOARD || list->sc.type == MEM_BOARD) {
315 		/* Create the minor nodes */
316 		if (ddi_create_minor_node(devi, NAME_BANK0, S_IFCHR,
317 		    (AC_PUTINSTANCE(instance) | 0),
318 		    DDI_NT_ATTACHMENT_POINT, 0) == DDI_FAILURE) {
319 			cmn_err(CE_WARN, "ac%d: \"%s\" "
320 			    "ddi_create_minor_node failed", instance,
321 			    NAME_BANK0);
322 		}
323 		if (ddi_create_minor_node(devi, NAME_BANK1, S_IFCHR,
324 		    (AC_PUTINSTANCE(instance) | 1),
325 		    DDI_NT_ATTACHMENT_POINT, 0) == DDI_FAILURE) {
326 			cmn_err(CE_WARN, "ac%d: \"%s\" "
327 			    "ddi_create_minor_node failed", instance,
328 			    NAME_BANK0);
329 		}
330 
331 		/* purge previous fhc pa database entries */
332 		fhc_del_memloc(softsp->board);
333 
334 		/* Inherit Memory Bank Status */
335 		ac_get_memory_status(softsp, Bank0);
336 		ac_get_memory_status(softsp, Bank1);
337 		/* Final Memory Bank Status evaluation and messaging */
338 		ac_eval_memory_status(softsp, Bank0);
339 		ac_eval_memory_status(softsp, Bank1);
340 	}
341 
342 	fhc_bdlist_unlock();
343 
344 	/* create the kstats for this device. */
345 	ac_add_kstats(softsp);
346 
347 	ddi_report_dev(devi);
348 
349 	return (DDI_SUCCESS);
350 
351 bad:
352 	ddi_soft_state_free(acp, instance);
353 	return (DDI_FAILURE);
354 }
355 
356 /* ARGSUSED */
357 static int
358 ac_detach(dev_info_t *devi, ddi_detach_cmd_t cmd)
359 {
360 	int instance;
361 	struct ac_soft_state *softsp;
362 	struct bd_list *list;
363 
364 	/* get the instance of this devi */
365 	instance = ddi_get_instance(devi);
366 
367 	/* get the soft state pointer for this device node */
368 	softsp = ddi_get_soft_state(acp, instance);
369 
370 	switch (cmd) {
371 	case DDI_SUSPEND:
372 		return (DDI_SUCCESS);
373 
374 	case DDI_DETACH:
375 		list = fhc_bdlist_lock(softsp->board);
376 
377 		if (fhc_bd_detachable(softsp->board))
378 			break;
379 		else
380 			fhc_bdlist_unlock();
381 		/* FALLTHROUGH */
382 
383 	default:
384 		return (DDI_FAILURE);
385 	}
386 
387 	ASSERT(list->ac_softsp == softsp);
388 
389 	if (list->sc.type == CPU_BOARD || list->sc.type == MEM_BOARD) {
390 		int cpui;
391 
392 		/*
393 		 * Test to see if memory is in use on a CPU/MEM board.
394 		 * In the case of a DR operation this condition
395 		 * will have been assured when the board was unconfigured.
396 		 */
397 		if (softsp->bank[Bank0].busy != 0 ||
398 		    softsp->bank[Bank0].ostate == SYSC_CFGA_OSTATE_CONFIGURED ||
399 		    softsp->bank[Bank1].busy != 0 ||
400 		    softsp->bank[Bank1].ostate == SYSC_CFGA_OSTATE_CONFIGURED) {
401 			fhc_bdlist_unlock();
402 			return (DDI_FAILURE);
403 		}
404 		/*
405 		 * CPU busy test is done by the DR sequencer before
406 		 * device detach called.
407 		 */
408 
409 		/*
410 		 * Flush all E-caches to remove references to this
411 		 * board's memory.
412 		 *
413 		 * Do this one CPU at a time to avoid stalls and timeouts
414 		 * due to all CPUs flushing concurrently.
415 		 * xc_one returns silently for non-existant CPUs.
416 		 */
417 		for (cpui = 0; cpui < NCPU; cpui++)
418 			xc_one(cpui, ac_ecache_flush, 0, 0);
419 	}
420 
421 	list->ac_softsp = NULL;
422 
423 	/* delete the kstat for this driver. */
424 	ac_del_kstats(softsp);
425 
426 	/* unmap the registers */
427 	ddi_unmap_regs(softsp->dip, 0, (caddr_t *)&softsp->ac_base, 0, 0);
428 
429 	fhc_bdlist_unlock();
430 
431 	/* Remove the minor nodes. */
432 	ddi_remove_minor_node(devi, NULL);
433 
434 	/* free the soft state structure */
435 	ddi_soft_state_free(acp, instance);
436 	ddi_prop_remove_all(devi);
437 
438 	return (DDI_SUCCESS);
439 }
440 
441 /* ARGSUSED */
442 static int
443 ac_open(dev_t *devp, int flag, int otyp, cred_t *credp)
444 {
445 	int instance;
446 	dev_t dev;
447 	struct ac_soft_state *softsp;
448 	struct bd_list *board;
449 	int vis;
450 
451 	dev = *devp;
452 	instance = AC_GETINSTANCE(getminor(dev));
453 	softsp = AC_GETSOFTC(instance);
454 
455 	/* Is the instance attached? */
456 	if (softsp == NULL) {
457 #ifdef DEBUG
458 		cmn_err(CE_WARN, "ac%d device not attached", instance);
459 #endif /* DEBUG */
460 		return (ENXIO);
461 	}
462 
463 	/*
464 	 * If the board is not configured, hide the memory APs
465 	 */
466 	board = fhc_bdlist_lock(softsp->board);
467 	vis = (board != NULL) && MEM_BOARD_VISIBLE(board);
468 	fhc_bdlist_unlock();
469 
470 	if (!vis)
471 		return (ENXIO);
472 
473 	/* verify that otyp is appropriate */
474 	if (otyp != OTYP_CHR) {
475 		return (EINVAL);
476 	}
477 
478 	return (DDI_SUCCESS);
479 }
480 
481 /* ARGSUSED */
482 static int
483 ac_close(dev_t devt, int flag, int otyp, cred_t *credp)
484 {
485 	struct ac_soft_state *softsp;
486 	int instance;
487 
488 	instance = AC_GETINSTANCE(getminor(devt));
489 	softsp = AC_GETSOFTC(instance);
490 	ASSERT(softsp != NULL);
491 	ac_mem_test_stop_on_close(softsp->board, AC_GETBANK(getminor(devt)));
492 	return (DDI_SUCCESS);
493 }
494 
495 static int
496 ac_pkt_init(ac_cfga_pkt_t *pkt, intptr_t arg, int flag)
497 {
498 #ifdef _MULTI_DATAMODEL
499 	if (ddi_model_convert_from(flag & FMODELS) == DDI_MODEL_ILP32) {
500 		ac_cfga_cmd32_t ac_cmd32;
501 
502 		if (ddi_copyin((void *)arg, &ac_cmd32,
503 		    sizeof (ac_cfga_cmd32_t), flag) != 0) {
504 			return (EFAULT);
505 		}
506 		pkt->cmd_cfga.force = ac_cmd32.force;
507 		pkt->cmd_cfga.test = ac_cmd32.test;
508 		pkt->cmd_cfga.arg = ac_cmd32.arg;
509 		pkt->cmd_cfga.errtype = ac_cmd32.errtype;
510 		pkt->cmd_cfga.outputstr =
511 		    (char *)(uintptr_t)ac_cmd32.outputstr;
512 		pkt->cmd_cfga.private =
513 		    (void *)(uintptr_t)ac_cmd32.private;
514 	} else
515 #endif /* _MULTI_DATAMODEL */
516 	if (ddi_copyin((void *)arg, &(pkt->cmd_cfga),
517 	    sizeof (ac_cfga_cmd_t), flag) != 0) {
518 		return (EFAULT);
519 	}
520 	pkt->errbuf = kmem_zalloc(SYSC_OUTPUT_LEN, KM_SLEEP);
521 	return (0);
522 }
523 
524 static int
525 ac_pkt_fini(ac_cfga_pkt_t *pkt, intptr_t arg, int flag)
526 {
527 	int ret = TRUE;
528 
529 #ifdef _MULTI_DATAMODEL
530 	if (ddi_model_convert_from(flag & FMODELS) == DDI_MODEL_ILP32) {
531 
532 		if (ddi_copyout(&(pkt->cmd_cfga.errtype),
533 		    (void *)&(((ac_cfga_cmd32_t *)arg)->errtype),
534 		    sizeof (ac_err_t), flag) != 0) {
535 			ret = FALSE;
536 		}
537 	} else
538 #endif
539 	if (ddi_copyout(&(pkt->cmd_cfga.errtype),
540 	    (void *)&(((ac_cfga_cmd_t *)arg)->errtype),
541 	    sizeof (ac_err_t), flag) != 0) {
542 		ret = FALSE;
543 	}
544 
545 	if ((ret != FALSE) && ((pkt->cmd_cfga.outputstr != NULL) &&
546 	    (ddi_copyout(pkt->errbuf, pkt->cmd_cfga.outputstr,
547 	    SYSC_OUTPUT_LEN, flag) != 0))) {
548 			ret = FALSE;
549 	}
550 
551 	kmem_free(pkt->errbuf, SYSC_OUTPUT_LEN);
552 	return (ret);
553 }
554 
555 /* ARGSUSED */
556 static int
557 ac_ioctl(
558 	dev_t devt,
559 	int cmd,
560 	intptr_t arg,
561 	int flag,
562 	cred_t *cred_p,
563 	int *rval_p)
564 {
565 	struct ac_soft_state *softsp;
566 	ac_cfga_pkt_t cfga_pkt, *pkt;
567 	int instance;
568 	int retval;
569 
570 	instance = AC_GETINSTANCE(getminor(devt));
571 	softsp = AC_GETSOFTC(instance);
572 	if (softsp == NULL) {
573 #ifdef DEBUG
574 		cmn_err(CE_NOTE, "ac%d device not attached", instance);
575 #endif /* DEBUG */
576 		return (ENXIO);
577 	}
578 
579 	/*
580 	 * Dispose of the easy ones first.
581 	 */
582 	switch (cmd) {
583 	case AC_MEM_ADMIN_VER:
584 		/*
585 		 * Specify the revision of this ioctl interface driver.
586 		 */
587 		if (ddi_copyout(&ac_mem_version, (void *)arg,
588 		    sizeof (ac_mem_version_t), flag) != 0)
589 			return (EFAULT);
590 		return (DDI_SUCCESS);
591 
592 	case AC_MEM_CONFIGURE:
593 	case AC_MEM_UNCONFIGURE:
594 	case AC_MEM_STAT:
595 	case AC_MEM_TEST_START:
596 	case AC_MEM_TEST_STOP:
597 	case AC_MEM_TEST_READ:
598 	case AC_MEM_TEST_WRITE:
599 	case AC_MEM_EXERCISE:
600 		break;
601 
602 	default:
603 		return (ENOTTY);
604 	}
605 	if (cmd != AC_MEM_STAT && !fpu_exists) {
606 		return (ENOTSUP);
607 	}
608 
609 	pkt = &cfga_pkt;
610 	if ((retval = ac_pkt_init(pkt, arg, flag)) != 0)
611 		return (retval);
612 	pkt->softsp = softsp;
613 	pkt->bank = AC_GETBANK(getminor(devt));
614 
615 	switch (cmd) {
616 	case AC_MEM_CONFIGURE:
617 		if ((flag & FWRITE) == 0) {
618 			retval = EBADF;
619 			break;
620 		}
621 
622 		if (pkt->cmd_cfga.private != NULL) {
623 			retval = EINVAL;
624 			break;
625 		}
626 		ac_policy_audit_messages(AC_AUDIT_OSTATE_CONFIGURE, pkt);
627 		retval = ac_add_memory(pkt);
628 		if (!retval)
629 			ac_policy_audit_messages(
630 			    AC_AUDIT_OSTATE_SUCCEEDED, pkt);
631 		else
632 			ac_policy_audit_messages(
633 			    AC_AUDIT_OSTATE_CONFIGURE_FAILED, pkt);
634 		break;
635 
636 	case AC_MEM_UNCONFIGURE:
637 		if ((flag & FWRITE) == 0) {
638 			retval = EBADF;
639 			break;
640 		}
641 
642 		if (pkt->cmd_cfga.private != NULL) {
643 			retval = EINVAL;
644 			break;
645 		}
646 		ac_policy_audit_messages(AC_AUDIT_OSTATE_UNCONFIGURE, pkt);
647 		retval = ac_del_memory(pkt);
648 		if (!retval) {
649 			ac_policy_audit_messages(
650 			    AC_AUDIT_OSTATE_SUCCEEDED, pkt);
651 		} else
652 			ac_policy_audit_messages(
653 			    AC_AUDIT_OSTATE_UNCONFIGURE_FAILED, pkt);
654 		break;
655 
656 	case AC_MEM_STAT:
657 		/*
658 		 * Query usage of a bank of memory.
659 		 */
660 		retval = ac_mem_stat(pkt, flag);
661 		break;
662 
663 	case AC_MEM_TEST_START:
664 		if ((flag & FWRITE) == 0) {
665 			retval = EBADF;
666 			break;
667 		}
668 
669 		retval = ac_mem_test_start(pkt, flag);
670 		break;
671 
672 	case AC_MEM_TEST_STOP:
673 		if ((flag & FWRITE) == 0) {
674 			retval = EBADF;
675 			break;
676 		}
677 
678 		retval =  ac_mem_test_stop(pkt, flag);
679 		break;
680 
681 	case AC_MEM_TEST_READ:
682 		/*
683 		 * read a 'page' (or less) of memory safely.
684 		 */
685 		if ((flag & FWRITE) == 0) {
686 			retval = EBADF;
687 			break;
688 		}
689 
690 		retval = ac_mem_test_read(pkt, flag);
691 		break;
692 
693 	case AC_MEM_TEST_WRITE:
694 		/*
695 		 * write a 'page' (or less) of memory safely.
696 		 */
697 		if ((flag & FWRITE) == 0) {
698 			retval = EBADF;
699 			break;
700 		}
701 
702 		retval = ac_mem_test_write(pkt, flag);
703 		break;
704 
705 	case AC_MEM_EXERCISE:
706 		retval = ac_mem_exercise(pkt, flag);
707 		break;
708 
709 	default:
710 		ASSERT(0);
711 		retval = ENOTTY;
712 		break;
713 	}
714 
715 	if (ac_pkt_fini(pkt, arg, flag) != TRUE)
716 		retval = EFAULT;
717 
718 	return (retval);
719 }
720 
721 static void
722 ac_add_kstats(struct ac_soft_state *softsp)
723 {
724 	struct kstat *ac_ksp, *ac_counters_ksp;
725 	struct ac_kstat *ac_named_ksp;
726 	struct kstat_named *ac_counters_named_data;
727 
728 	/*
729 	 * create the unix-misc kstat for address controller
730 	 * using the board number as the instance.
731 	 */
732 	if ((ac_ksp = kstat_create("unix", softsp->board,
733 	    AC_KSTAT_NAME, "misc", KSTAT_TYPE_NAMED,
734 	    sizeof (struct ac_kstat) / sizeof (kstat_named_t),
735 	    KSTAT_FLAG_PERSISTENT)) == NULL) {
736 		cmn_err(CE_WARN, "ac%d: kstat_create failed",
737 		    ddi_get_instance(softsp->dip));
738 		return;
739 	}
740 
741 	ac_named_ksp = (struct ac_kstat *)(ac_ksp->ks_data);
742 
743 	/* initialize the named kstats */
744 	kstat_named_init(&ac_named_ksp->ac_memctl,
745 	    MEMCTL_KSTAT_NAMED,
746 	    KSTAT_DATA_UINT64);
747 
748 	kstat_named_init(&ac_named_ksp->ac_memdecode0,
749 	    MEMDECODE0_KSTAT_NAMED,
750 	    KSTAT_DATA_UINT64);
751 
752 	kstat_named_init(&ac_named_ksp->ac_memdecode1,
753 	    MEMDECODE1_KSTAT_NAMED,
754 	    KSTAT_DATA_UINT64);
755 
756 	kstat_named_init(&ac_named_ksp->ac_mccr,
757 	    MCCR_KSTAT_NAMED,
758 	    KSTAT_DATA_UINT32);
759 
760 	kstat_named_init(&ac_named_ksp->ac_counter,
761 	    CNTR_KSTAT_NAMED,
762 	    KSTAT_DATA_UINT64);
763 
764 	kstat_named_init(&ac_named_ksp->ac_bank0_status,
765 	    BANK_0_KSTAT_NAMED,
766 	    KSTAT_DATA_CHAR);
767 
768 	kstat_named_init(&ac_named_ksp->ac_bank1_status,
769 	    BANK_1_KSTAT_NAMED,
770 	    KSTAT_DATA_CHAR);
771 
772 	ac_ksp->ks_update = ac_misc_kstat_update;
773 	ac_ksp->ks_private = (void *)softsp;
774 	softsp->ac_ksp = ac_ksp;
775 	kstat_install(ac_ksp);
776 
777 	/*
778 	 * Create the picN kstats if we are the first instance
779 	 * to attach. We use ac_attachcnt as a count of how
780 	 * many instances have attached. This is protected by
781 	 * a mutex.
782 	 */
783 	mutex_enter(&ac_attachcnt_mutex);
784 	if (ac_attachcnt == 0)
785 		ac_add_picN_kstats(softsp->dip);
786 
787 	ac_attachcnt ++;
788 	mutex_exit(&ac_attachcnt_mutex);
789 
790 	/*
791 	 * Create the "counter" kstat for each AC instance.
792 	 * This provides access to the %pcr and %pic
793 	 * registers for that instance.
794 	 *
795 	 * The size of this kstat is AC_NUM_PICS + 1 for %pcr
796 	 */
797 	if ((ac_counters_ksp = kstat_create("ac",
798 	    ddi_get_instance(softsp->dip), "counters",
799 	    "bus", KSTAT_TYPE_NAMED, AC_NUM_PICS + 1,
800 	    KSTAT_FLAG_WRITABLE)) == NULL) {
801 
802 		cmn_err(CE_WARN, "ac%d counters: kstat_create failed",
803 		    ddi_get_instance(softsp->dip));
804 		return;
805 	}
806 	ac_counters_named_data =
807 	    (struct kstat_named *)(ac_counters_ksp->ks_data);
808 
809 	/* initialize the named kstats */
810 	kstat_named_init(&ac_counters_named_data[0],
811 	    "pcr", KSTAT_DATA_UINT64);
812 
813 	kstat_named_init(&ac_counters_named_data[1],
814 	    "pic0", KSTAT_DATA_UINT64);
815 
816 	kstat_named_init(&ac_counters_named_data[2],
817 	    "pic1", KSTAT_DATA_UINT64);
818 
819 	ac_counters_ksp->ks_update = ac_counters_kstat_update;
820 	ac_counters_ksp->ks_private = (void *)softsp;
821 	kstat_install(ac_counters_ksp);
822 
823 	/* update the sofstate */
824 	softsp->ac_counters_ksp = ac_counters_ksp;
825 }
826 
827 /*
828  * called from ac_add_kstats() to create a kstat for each %pic
829  * that the AC supports. These (read-only) kstats export the
830  * event names and %pcr masks that each %pic supports.
831  *
832  * if we fail to create any of these kstats we must remove any
833  * that we have already created and return;
834  *
835  * NOTE: because all AC's use the same events we only need to
836  *       create the picN kstats once. All instances can use
837  *       the same picN kstats.
838  *
839  *       The flexibility exists to allow each device specify it's
840  *       own events by creating picN kstats with the instance number
841  *       set to ddi_get_instance(softsp->dip).
842  *
843  *       When searching for a picN kstat for a device you should
844  *       first search for a picN kstat using the instance number
845  *       of the device you are interested in. If that fails you
846  *       should use the first picN kstat found for that device.
847  */
848 static void
849 ac_add_picN_kstats(dev_info_t *dip)
850 {
851 	typedef struct ac_event_mask {
852 		char *event_name;
853 		uint64_t pcr_mask;
854 	} ac_event_mask_t;
855 
856 	/*
857 	 * AC Performance Events.
858 	 *
859 	 * We declare an array of event-names and event-masks.
860 	 */
861 	ac_event_mask_t ac_events_arr[] = {
862 		{"mem_bank0_rds", 0x1}, {"mem_bank0_wrs", 0x2},
863 		{"mem_bank0_stall", 0x3}, {"mem_bank1_rds", 0x4},
864 		{"mem_bank1_wrs", 0x5}, {"mem_bank1_stall", 0x6},
865 		{"clock_cycles", 0x7}, {"addr_pkts", 0x8},
866 		{"data_pkts", 0x9}, {"flow_ctl_cyc", 0xa},
867 		{"fast_arb_pkts", 0xb}, {"bus_cont_cyc", 0xc},
868 		{"data_bus_can", 0xd}, {"ac_addr_pkts", 0xe},
869 		{"ac_data_pkts", 0xf}, {"rts_pkts", 0x10},
870 		{"rtsa_pkts", 0x11}, {"rto_pkts", 0x12},
871 		{"rs_pkts", 0x13}, {"wb_pkts", 0x14},
872 		{"ws_pkts", 0x15}, {"rio_pkts", 0x16},
873 		{"rbio_pkts", 0x17}, {"wio_pkts", 0x18},
874 		{"wbio_pkts", 0x19}, {"upa_a_rds_m", 0x1a},
875 		{"upa_a_rdo_v", 0x1b}, {"upa_b_rds_m", 0x1c},
876 		{"upa_b_rdo_v", 0x1d}, {"upa_a_preqs_fr", 0x20},
877 		{"upa_a_sreqs_to", 0x21}, {"upa_a_preqs_to", 0x22},
878 		{"upa_a_rds_fr", 0x23}, {"upa_a_rdsa_fr", 0x24},
879 		{"upa_a_rdo_fr", 0x25}, {"upa_a_rdd_fr", 0x26},
880 		{"upa_a_rio_rbio", 0x27}, {"upa_a_wio_wbio", 0x28},
881 		{"upa_a_cpb_to", 0x29}, {"upa_a_inv_to", 0x2a},
882 		{"upa_a_hits_buff", 0x2b}, {"upa_a_wb", 0x2c},
883 		{"upa_a_wi", 0x2d}, {"upa_b_preqs_fr", 0x30},
884 		{"upa_b_sreqs_to", 0x31}, {"upa_b_preqs_to", 0x32},
885 		{"upa_b_rds_fr", 0x33}, {"upa_b_rdsa_fr", 0x34},
886 		{"upa_b_rdo_fr", 0x35}, {"upa_b_rdd_fr", 0x36},
887 		{"upa_b_rio_rbio", 0x37}, {"upa_b_wio_wbio", 0x38},
888 		{"upa_b_cpb_to", 0x39}, {"upa_b_inv_to", 0x3a},
889 		{"upa_b_hits_buff", 0x3b}, {"upa_b_wb", 0x3c},
890 		{"upa_b_wi", 0x3d}
891 	};
892 
893 #define	AC_NUM_EVENTS sizeof (ac_events_arr) / sizeof (ac_events_arr[0])
894 
895 	/*
896 	 * array of clear masks for each pic.
897 	 * These masks are used to clear the %pcr bits for
898 	 * each pic.
899 	 */
900 	ac_event_mask_t ac_clear_pic[AC_NUM_PICS] = {
901 		/* pic0 */
902 		{"clear_pic", (uint64_t)~(0x3f)},
903 		/* pic1 */
904 		{"clear_pic", (uint64_t)~(0x3f << 8)}
905 	};
906 
907 	struct kstat_named *ac_pic_named_data;
908 	int  		event, pic;
909 	char 		pic_name[30];
910 	int		instance = ddi_get_instance(dip);
911 	int		pic_shift = 0;
912 
913 	for (pic = 0; pic < AC_NUM_PICS; pic++) {
914 		/*
915 		 * create the picN kstat. The size of this kstat is
916 		 * AC_NUM_EVENTS + 1 for the clear_event_mask
917 		 */
918 		(void) sprintf(pic_name, "pic%d", pic);	/* pic0, pic1 ... */
919 		if ((ac_picN_ksp[pic] = kstat_create("ac",
920 		    instance, pic_name, "bus", KSTAT_TYPE_NAMED,
921 		    AC_NUM_EVENTS + 1, NULL)) == NULL) {
922 
923 				cmn_err(CE_WARN, "ac %s: kstat_create failed",
924 				    pic_name);
925 
926 				/* remove pic0 kstat if pic1 create fails */
927 				if (pic == 1) {
928 					kstat_delete(ac_picN_ksp[0]);
929 					ac_picN_ksp[0] = NULL;
930 				}
931 				return;
932 		}
933 		ac_pic_named_data =
934 		    (struct kstat_named *)(ac_picN_ksp[pic]->ks_data);
935 
936 		/*
937 		 * when we are storing pcr_masks we need to shift bits
938 		 * left by 8 for pic1 events.
939 		 */
940 		if (pic == 1)
941 			pic_shift = 8;
942 
943 		/*
944 		 * for each picN event we need to write a kstat record
945 		 * (name = EVENT, value.ui64 = PCR_MASK)
946 		 */
947 		for (event = 0; event < AC_NUM_EVENTS; event ++) {
948 
949 			/* pcr_mask */
950 			ac_pic_named_data[event].value.ui64 =
951 			    ac_events_arr[event].pcr_mask << pic_shift;
952 
953 			/* event-name */
954 			kstat_named_init(&ac_pic_named_data[event],
955 			    ac_events_arr[event].event_name,
956 			    KSTAT_DATA_UINT64);
957 		}
958 
959 		/*
960 		 * we add the clear_pic event and mask as the last
961 		 * record in the kstat
962 		 */
963 		/* pcr mask */
964 		ac_pic_named_data[AC_NUM_EVENTS].value.ui64 =
965 		    ac_clear_pic[pic].pcr_mask;
966 
967 		/* event-name */
968 		kstat_named_init(&ac_pic_named_data[AC_NUM_EVENTS],
969 		    ac_clear_pic[pic].event_name,
970 		    KSTAT_DATA_UINT64);
971 
972 		kstat_install(ac_picN_ksp[pic]);
973 	}
974 }
975 
976 
977 static void
978 ac_del_kstats(struct ac_soft_state *softsp)
979 {
980 	struct kstat *ac_ksp;
981 	int pic;
982 
983 	/* remove "misc" kstat */
984 	ac_ksp = softsp->ac_ksp;
985 	softsp->ac_ksp = NULL;
986 	if (ac_ksp != NULL) {
987 		ASSERT(ac_ksp->ks_private == (void *)softsp);
988 		kstat_delete(ac_ksp);
989 	}
990 
991 	/* remove "bus" kstat */
992 	ac_ksp = softsp->ac_counters_ksp;
993 	softsp->ac_counters_ksp = NULL;
994 	if (ac_ksp != NULL) {
995 		ASSERT(ac_ksp->ks_private == (void *)softsp);
996 		kstat_delete(ac_ksp);
997 	}
998 
999 	/*
1000 	 * if we are the last instance to detach we need to
1001 	 * remove the picN kstats. We use ac_attachcnt as a
1002 	 * count of how many instances are still attached. This
1003 	 * is protected by a mutex.
1004 	 */
1005 	mutex_enter(&ac_attachcnt_mutex);
1006 	ac_attachcnt --;
1007 	if (ac_attachcnt == 0) {
1008 		for (pic = 0; pic < AC_NUM_PICS; pic++) {
1009 			if (ac_picN_ksp[pic] != (kstat_t *)NULL) {
1010 				kstat_delete(ac_picN_ksp[pic]);
1011 				ac_picN_ksp[pic] = NULL;
1012 			}
1013 		}
1014 	}
1015 	mutex_exit(&ac_attachcnt_mutex);
1016 }
1017 
1018 static enum ac_bank_status
1019 ac_kstat_stat(sysc_cfga_rstate_t rst, sysc_cfga_ostate_t ost)
1020 {
1021 	switch (rst) {
1022 	case SYSC_CFGA_RSTATE_EMPTY:
1023 		return (StNoMem);
1024 	case SYSC_CFGA_RSTATE_DISCONNECTED:
1025 		return (StBad);
1026 	case SYSC_CFGA_RSTATE_CONNECTED:
1027 		switch (ost) {
1028 		case SYSC_CFGA_OSTATE_UNCONFIGURED:
1029 			return (StSpare);
1030 		case SYSC_CFGA_OSTATE_CONFIGURED:
1031 			return (StActive);
1032 		default:
1033 			return (StUnknown);
1034 		}
1035 	default:
1036 		return (StUnknown);
1037 	}
1038 }
1039 
1040 static enum ac_bank_condition
1041 ac_kstat_cond(sysc_cfga_cond_t cond)
1042 {
1043 	switch (cond) {
1044 	case SYSC_CFGA_COND_UNKNOWN:
1045 		return (ConUnknown);
1046 	case SYSC_CFGA_COND_OK:
1047 		return (ConOK);
1048 	case SYSC_CFGA_COND_FAILING:
1049 		return (ConFailing);
1050 	case SYSC_CFGA_COND_FAILED:
1051 		return (ConFailed);
1052 	case SYSC_CFGA_COND_UNUSABLE:
1053 		return (ConBad);
1054 	default:
1055 		return (ConUnknown);
1056 	}
1057 }
1058 
1059 static int
1060 ac_misc_kstat_update(kstat_t *ksp, int rw)
1061 {
1062 	struct ac_kstat *acksp;
1063 	struct ac_soft_state *softsp;
1064 
1065 	acksp = (struct ac_kstat *)ksp->ks_data;
1066 	softsp = (struct ac_soft_state *)ksp->ks_private;
1067 	/* Need the NULL check in case kstat is about to be deleted. */
1068 	ASSERT(softsp->ac_ksp == NULL || ksp == softsp->ac_ksp);
1069 
1070 	/* this is a read-only kstat. Bail out on a write */
1071 	if (rw == KSTAT_WRITE) {
1072 		return (EACCES);
1073 	} else {
1074 		/*
1075 		 * copy the current state of the hardware into the
1076 		 * kstat structure.
1077 		 */
1078 		acksp->ac_memctl.value.ui64 = *softsp->ac_memctl;
1079 		acksp->ac_memdecode0.value.ui64 = *softsp->ac_memdecode0;
1080 		acksp->ac_memdecode1.value.ui64 = *softsp->ac_memdecode1;
1081 		acksp->ac_mccr.value.ui32 = *softsp->ac_mccr;
1082 		acksp->ac_counter.value.ui64 = *softsp->ac_counter;
1083 		acksp->ac_bank0_status.value.c[0] =
1084 		    ac_kstat_stat(softsp->bank[0].rstate,
1085 		    softsp->bank[0].ostate);
1086 		acksp->ac_bank0_status.value.c[1] =
1087 		    ac_kstat_cond(softsp->bank[0].condition);
1088 		acksp->ac_bank1_status.value.c[0] =
1089 		    ac_kstat_stat(softsp->bank[1].rstate,
1090 		    softsp->bank[1].ostate);
1091 		acksp->ac_bank1_status.value.c[1] =
1092 		    ac_kstat_cond(softsp->bank[1].condition);
1093 	}
1094 	return (0);
1095 }
1096 
1097 static int
1098 ac_counters_kstat_update(kstat_t *ksp, int rw)
1099 {
1100 	struct kstat_named *ac_counters_data;
1101 	struct ac_soft_state *softsp;
1102 	uint64_t pic_register;
1103 
1104 	ac_counters_data = (struct kstat_named *)ksp->ks_data;
1105 	softsp = (struct ac_soft_state *)ksp->ks_private;
1106 
1107 	/*
1108 	 * We need to start/restart the ac_timeout that will
1109 	 * return the AC counters to hot-plug mode after the
1110 	 * ac_hot_plug_timeout_interval has expired. We tell
1111 	 * ac_reset_timeout() whether this is a kstat_read or a
1112 	 * kstat_write call. If this fails we reject the kstat
1113 	 * operation.
1114 	 */
1115 	if (ac_reset_timeout(rw) != 0)
1116 		return (-1);
1117 
1118 
1119 	if (rw == KSTAT_WRITE) {
1120 		/*
1121 		 * Write the %pcr value to the softsp->ac_mccr.
1122 		 * This interface does not support writing to the
1123 		 * %pic.
1124 		 */
1125 		*softsp->ac_mccr =
1126 		    (uint32_t)ac_counters_data[0].value.ui64;
1127 	} else {
1128 		/*
1129 		 * Read %pcr and %pic register values and write them
1130 		 * into counters kstat.
1131 		 */
1132 
1133 		/* pcr */
1134 		ac_counters_data[0].value.ui64 = *softsp->ac_mccr;
1135 
1136 		pic_register = *softsp->ac_counter;
1137 		/*
1138 		 * ac pic register:
1139 		 *  (63:32) = pic1
1140 		 *  (31:00) = pic0
1141 		 */
1142 
1143 		/* pic0 */
1144 		ac_counters_data[1].value.ui64 =
1145 		    AC_COUNTER_TO_PIC0(pic_register);
1146 		/* pic1 */
1147 		ac_counters_data[2].value.ui64 =
1148 		    AC_COUNTER_TO_PIC1(pic_register);
1149 	}
1150 	return (0);
1151 }
1152 
1153 /*
1154  * Decode the memory state given to us and plug it into the soft state
1155  */
1156 static void
1157 ac_get_memory_status(struct ac_soft_state *softsp, enum ac_bank_id id)
1158 {
1159 	char	*property = (id == Bank0) ? AC_BANK0_STATUS : AC_BANK1_STATUS;
1160 	char	*propval;
1161 	int	proplen;
1162 	uint64_t memdec = (id == Bank0) ?
1163 	    *(softsp->ac_memdecode0) : *(softsp->ac_memdecode1);
1164 	uint_t		grp_size;
1165 
1166 	softsp->bank[id].busy = 0;
1167 	softsp->bank[id].status_change = ddi_get_time();
1168 
1169 	if (GRP_SIZE_IS_SET(memdec)) {
1170 		grp_size = GRP_SPANMB(memdec);
1171 
1172 		/* determine the memory bank size (in MB) */
1173 		softsp->bank[id].real_size = softsp->bank[id].use_size =
1174 		    (id == Bank0) ? (grp_size / INTLV0(*softsp->ac_memctl)) :
1175 		    (grp_size / INTLV1(*softsp->ac_memctl));
1176 	} else {
1177 		softsp->bank[id].real_size = softsp->bank[id].use_size = 0;
1178 	}
1179 
1180 	/*
1181 	 * decode the memory bank property.  set condition based
1182 	 * on the values.
1183 	 */
1184 	if (ddi_prop_op(DDI_DEV_T_ANY, softsp->dip, PROP_LEN_AND_VAL_ALLOC,
1185 	    DDI_PROP_DONTPASS, property, (caddr_t)&propval, &proplen) ==
1186 	    DDI_PROP_SUCCESS) {
1187 		if (strcmp(propval, AC_BANK_NOMEM) == 0) {
1188 			softsp->bank[id].rstate = SYSC_CFGA_RSTATE_EMPTY;
1189 			softsp->bank[id].ostate = SYSC_CFGA_OSTATE_UNCONFIGURED;
1190 			softsp->bank[id].condition = SYSC_CFGA_COND_UNKNOWN;
1191 		} else if (strcmp(propval, AC_BANK_OK) == 0) {
1192 			softsp->bank[id].rstate = SYSC_CFGA_RSTATE_CONNECTED;
1193 			softsp->bank[id].ostate = SYSC_CFGA_OSTATE_CONFIGURED;
1194 			softsp->bank[id].condition = SYSC_CFGA_COND_OK;
1195 		} else if (strcmp(propval, AC_BANK_SPARE) == 0) {
1196 			softsp->bank[id].rstate = SYSC_CFGA_RSTATE_CONNECTED;
1197 			softsp->bank[id].ostate = SYSC_CFGA_OSTATE_UNCONFIGURED;
1198 			softsp->bank[id].condition = SYSC_CFGA_COND_UNKNOWN;
1199 		} else if (strcmp(propval, AC_BANK_FAILED) == 0) {
1200 			softsp->bank[id].rstate = SYSC_CFGA_RSTATE_DISCONNECTED;
1201 			softsp->bank[id].ostate = SYSC_CFGA_OSTATE_UNCONFIGURED;
1202 			softsp->bank[id].condition = SYSC_CFGA_COND_UNUSABLE;
1203 		} else {
1204 			cmn_err(CE_WARN, "ac%d: board %d, bank %d: "
1205 			    "unknown %smemory state [%s]",
1206 			    ddi_get_instance(softsp->dip), softsp->board, id,
1207 			    (memdec & AC_MEM_VALID) ? "connected " : "",
1208 			    propval);
1209 			if (memdec & AC_MEM_VALID) {
1210 				softsp->bank[id].rstate =
1211 				    SYSC_CFGA_RSTATE_CONNECTED;
1212 				softsp->bank[id].ostate =
1213 				    SYSC_CFGA_OSTATE_CONFIGURED;
1214 				softsp->bank[id].condition =
1215 				    SYSC_CFGA_COND_OK;
1216 			} else {
1217 				softsp->bank[id].rstate =
1218 				    SYSC_CFGA_RSTATE_DISCONNECTED;
1219 				softsp->bank[id].ostate =
1220 				    SYSC_CFGA_OSTATE_UNCONFIGURED;
1221 				softsp->bank[id].condition =
1222 				    SYSC_CFGA_COND_UNUSABLE;
1223 			}
1224 		}
1225 
1226 		kmem_free(propval, proplen);
1227 	} else {
1228 		/* we don't have the property, deduce the state of memory */
1229 		if (memdec & AC_MEM_VALID) {
1230 			softsp->bank[id].rstate = SYSC_CFGA_RSTATE_CONNECTED;
1231 			softsp->bank[id].ostate = SYSC_CFGA_OSTATE_CONFIGURED;
1232 			softsp->bank[id].condition = SYSC_CFGA_COND_OK;
1233 		} else {
1234 			/* could be an i/o board... */
1235 			softsp->bank[id].rstate = SYSC_CFGA_RSTATE_EMPTY;
1236 			softsp->bank[id].ostate = SYSC_CFGA_OSTATE_UNCONFIGURED;
1237 			softsp->bank[id].condition = SYSC_CFGA_COND_UNKNOWN;
1238 		}
1239 	}
1240 
1241 	/* we assume that all other bank statuses are NOT valid */
1242 	if (softsp->bank[id].rstate == SYSC_CFGA_RSTATE_CONNECTED) {
1243 		if ((memdec & AC_MEM_VALID) != 0) {
1244 			uint64_t	base_pa;
1245 
1246 			ASSERT((*softsp->ac_memctl & AC_CSR_REFEN) != 0);
1247 			/* register existence in the memloc database */
1248 			base_pa = GRP_REALBASE(memdec);
1249 			fhc_add_memloc(softsp->board, base_pa, grp_size);
1250 		}
1251 	}
1252 }
1253 
1254 static void
1255 ac_eval_memory_status(struct ac_soft_state *softsp, enum ac_bank_id id)
1256 {
1257 	uint64_t memdec = (id == Bank0) ?
1258 	    *(softsp->ac_memdecode0) : *(softsp->ac_memdecode1);
1259 	uint64_t	base_pa;
1260 
1261 	/*
1262 	 * Downgrade the status of any bank that did not get
1263 	 * programmed.
1264 	 */
1265 	if (softsp->bank[id].rstate == SYSC_CFGA_RSTATE_CONNECTED &&
1266 	    softsp->bank[id].ostate == SYSC_CFGA_OSTATE_UNCONFIGURED &&
1267 	    (memdec & AC_MEM_VALID) == 0) {
1268 		cmn_err(CE_WARN, "ac%d: board %d, bank %d: "
1269 		    "spare memory bank not valid - it was ",
1270 		    ddi_get_instance(softsp->dip), softsp->board, id);
1271 		cmn_err(CE_WARN, "misconfigured by the system "
1272 		    "firmware.  Disabling...");
1273 		softsp->bank[id].rstate = SYSC_CFGA_RSTATE_DISCONNECTED;
1274 		softsp->bank[id].ostate = SYSC_CFGA_OSTATE_UNCONFIGURED;
1275 		softsp->bank[id].condition = SYSC_CFGA_COND_UNUSABLE;
1276 	}
1277 	/*
1278 	 * Log a message about good banks.
1279 	 */
1280 	if (softsp->bank[id].rstate == SYSC_CFGA_RSTATE_CONNECTED) {
1281 		ASSERT((memdec & AC_MEM_VALID) != 0);
1282 		base_pa = GRP_REALBASE(memdec);
1283 
1284 		cmn_err(CE_CONT, "?ac%d board %d bank %d: "
1285 		    "base 0x%" PRIx64 " size %dmb rstate %d "
1286 		    "ostate %d condition %d\n",
1287 		    ddi_get_instance(softsp->dip),
1288 		    softsp->board, id, base_pa, softsp->bank[id].real_size,
1289 		    softsp->bank[id].rstate, softsp->bank[id].ostate,
1290 		    softsp->bank[id].condition);
1291 	}
1292 }
1293 
1294 /*ARGSUSED*/
1295 static void
1296 ac_ecache_flush(uint64_t a, uint64_t b)
1297 {
1298 	cpu_flush_ecache();
1299 }
1300 
1301 static char *
1302 ac_ostate_typestr(sysc_cfga_ostate_t ostate, ac_audit_evt_t event)
1303 {
1304 	char *type_str;
1305 
1306 	switch (ostate) {
1307 	case SYSC_CFGA_OSTATE_UNCONFIGURED:
1308 		switch (event) {
1309 		case AC_AUDIT_OSTATE_UNCONFIGURE:
1310 			type_str = "unconfiguring";
1311 			break;
1312 		case AC_AUDIT_OSTATE_SUCCEEDED:
1313 		case AC_AUDIT_OSTATE_UNCONFIGURE_FAILED:
1314 			type_str = "unconfigured";
1315 			break;
1316 		default:
1317 			type_str = "unconfigure?";
1318 			break;
1319 		}
1320 		break;
1321 	case SYSC_CFGA_OSTATE_CONFIGURED:
1322 		switch (event) {
1323 		case AC_AUDIT_OSTATE_CONFIGURE:
1324 			type_str = "configuring";
1325 			break;
1326 		case AC_AUDIT_OSTATE_SUCCEEDED:
1327 		case AC_AUDIT_OSTATE_CONFIGURE_FAILED:
1328 			type_str = "configured";
1329 			break;
1330 		default:
1331 			type_str = "configure?";
1332 			break;
1333 		}
1334 		break;
1335 
1336 	default:
1337 		type_str = "undefined occupant state";
1338 		break;
1339 	}
1340 	return (type_str);
1341 }
1342 
1343 static void
1344 ac_policy_audit_messages(ac_audit_evt_t event, ac_cfga_pkt_t *pkt)
1345 {
1346 	struct ac_soft_state *softsp = pkt->softsp;
1347 
1348 	switch (event) {
1349 		case AC_AUDIT_OSTATE_CONFIGURE:
1350 			cmn_err(CE_NOTE,
1351 			    "%s memory bank %d in slot %d",
1352 			    ac_ostate_typestr(SYSC_CFGA_OSTATE_CONFIGURED,
1353 			    event), pkt->bank,
1354 			    softsp->board);
1355 			break;
1356 		case AC_AUDIT_OSTATE_UNCONFIGURE:
1357 			cmn_err(CE_NOTE,
1358 			    "%s memory bank %d in slot %d",
1359 			    ac_ostate_typestr(
1360 			    SYSC_CFGA_OSTATE_UNCONFIGURED,
1361 			    event), pkt->bank,
1362 			    softsp->board);
1363 			break;
1364 		case AC_AUDIT_OSTATE_SUCCEEDED:
1365 			cmn_err(CE_NOTE,
1366 			    "memory bank %d in slot %d is %s",
1367 			    pkt->bank, softsp->board,
1368 			    ac_ostate_typestr(
1369 			    softsp->bank[pkt->bank].ostate,
1370 			    event));
1371 			break;
1372 		case AC_AUDIT_OSTATE_CONFIGURE_FAILED:
1373 			cmn_err(CE_NOTE,
1374 			"memory bank %d in slot %d not %s",
1375 			    pkt->bank,
1376 			    softsp->board,
1377 			    ac_ostate_typestr(
1378 			    SYSC_CFGA_OSTATE_CONFIGURED,
1379 			    event));
1380 			break;
1381 		case AC_AUDIT_OSTATE_UNCONFIGURE_FAILED:
1382 			cmn_err(CE_NOTE,
1383 			    "memory bank %d in slot %d not %s",
1384 			    pkt->bank,
1385 			    softsp->board,
1386 			    ac_ostate_typestr(
1387 			    SYSC_CFGA_OSTATE_UNCONFIGURED,
1388 			    event));
1389 			break;
1390 		default:
1391 			cmn_err(CE_NOTE,
1392 			    "unknown audit of memory bank %d in slot %d",
1393 			    pkt->bank, softsp->board);
1394 			break;
1395 	}
1396 }
1397 
1398 #include <vm/page.h>
1399 #include <vm/hat.h>
1400 
1401 static int
1402 ac_mem_exercise(ac_cfga_pkt_t *pkt, int flag)
1403 {
1404 	struct ac_mem_info *mem_info;
1405 	pfn_t base;
1406 	pgcnt_t npgs;
1407 
1408 	mem_info = &pkt->softsp->bank[pkt->bank];
1409 	if (mem_info->rstate == SYSC_CFGA_RSTATE_CONNECTED) {
1410 		uint64_t base_pa, bank_size;
1411 		uint64_t decode;
1412 
1413 		decode = (pkt->bank == Bank0) ?
1414 		    *pkt->softsp->ac_memdecode0 : *pkt->softsp->ac_memdecode1;
1415 		base_pa = GRP_REALBASE(decode);
1416 		bank_size = GRP_UK2SPAN(decode);
1417 
1418 		base = base_pa >> PAGESHIFT;
1419 		npgs = bank_size >> PAGESHIFT;
1420 	} else {
1421 		base = 0;
1422 		npgs = 0;
1423 	}
1424 	switch (pkt->cmd_cfga.arg) {
1425 	case AC_MEMX_RELOCATE_ALL: {
1426 		pfn_t pfn, pglim;
1427 		struct ac_memx_relocate_stats rstat;
1428 
1429 		if (npgs == 0 ||
1430 		    mem_info->ostate != SYSC_CFGA_OSTATE_CONFIGURED) {
1431 			return (EINVAL);
1432 		}
1433 		if (mem_info->busy != FALSE) {
1434 			return (EBUSY);
1435 		}
1436 		bzero(&rstat, sizeof (rstat));
1437 		rstat.base = (uint_t)base;
1438 		rstat.npgs = (uint_t)npgs;
1439 		pglim = base + npgs;
1440 		for (pfn = base; pfn < pglim; pfn++) {
1441 			page_t *pp, *pp_repl;
1442 
1443 		retry:
1444 			pp = page_numtopp_nolock(pfn);
1445 			if (pp != NULL) {
1446 				if (!page_trylock(pp, SE_EXCL)) {
1447 					pp = NULL;
1448 					rstat.nolock++;
1449 				}
1450 				if (pp != NULL && page_pptonum(pp) != pfn) {
1451 					page_unlock(pp);
1452 					goto retry;
1453 				}
1454 			} else {
1455 				rstat.nopaget++;
1456 			}
1457 			if (pp != NULL && PP_ISFREE(pp)) {
1458 				page_unlock(pp);
1459 				rstat.isfree++;
1460 				pp = NULL;
1461 			}
1462 			if (pp != NULL) {
1463 				spgcnt_t npgs;
1464 				int result;
1465 
1466 				pp_repl = NULL;
1467 				result = page_relocate(&pp, &pp_repl, 1, 1,
1468 				    &npgs, NULL);
1469 				if (result == 0) {
1470 					while (npgs-- > 0) {
1471 						page_t *tpp;
1472 
1473 						ASSERT(pp_repl != NULL);
1474 						tpp = pp_repl;
1475 						page_sub(&pp_repl, tpp);
1476 						page_unlock(tpp);
1477 					}
1478 
1479 					rstat.reloc++;
1480 				} else {
1481 					page_unlock(pp);
1482 					rstat.noreloc++;
1483 				}
1484 			}
1485 		}
1486 		if (pkt->cmd_cfga.private != NULL && ddi_copyout(&rstat,
1487 		    pkt->cmd_cfga.private, sizeof (rstat), flag) != 0)
1488 			return (EFAULT);
1489 		return (DDI_SUCCESS);
1490 	}
1491 
1492 	default:
1493 		return (EINVAL);
1494 	}
1495 }
1496 
1497 static int
1498 ac_reset_timeout(int rw)
1499 {
1500 	mutex_enter(&ac_hot_plug_mode_mutex);
1501 
1502 	if ((ac_hot_plug_timeout == (timeout_id_t)NULL) &&
1503 	    (rw == KSTAT_READ)) {
1504 		/*
1505 		 * We are in hot-plug mode. A kstat_read is not
1506 		 * going to affect this. return 0 to allow the
1507 		 * kstat_read to continue.
1508 		 */
1509 		mutex_exit(&ac_hot_plug_mode_mutex);
1510 		return (0);
1511 
1512 	} else if ((ac_hot_plug_timeout == (timeout_id_t)NULL) &&
1513 	    (rw == KSTAT_WRITE)) {
1514 		/*
1515 		 * There are no pending timeouts and we have received a
1516 		 * kstat_write request so we must be transitioning
1517 		 * from "hot-plug" mode to non "hot-plug" mode.
1518 		 * Try to lock all boards before allowing the kstat_write.
1519 		 */
1520 		if (ac_enter_transition() == TRUE)
1521 			fhc_bdlist_unlock();
1522 		else {
1523 			/* cannot lock boards so fail */
1524 			mutex_exit(&ac_hot_plug_mode_mutex);
1525 			return (-1);
1526 		}
1527 
1528 		/*
1529 		 * We need to display a Warning about hot-plugging any
1530 		 * boards. This message is only needed when we are
1531 		 * transitioning out of "hot-plug" mode.
1532 		 */
1533 		cmn_err(CE_WARN, "This machine is being taken out of "
1534 		    "hot-plug mode.");
1535 		cmn_err(CE_CONT, "Do not attempt to hot-plug boards "
1536 		    "or power supplies in this system until further notice.");
1537 
1538 	} else if (ac_hot_plug_timeout != (timeout_id_t)NULL) {
1539 		/*
1540 		 * There is a pending timeout so we must already be
1541 		 * in non "hot-plug" mode. It doesn't matter if the
1542 		 * kstat request is a read or a write.
1543 		 *
1544 		 * We need to cancel the existing timeout.
1545 		 */
1546 		(void) untimeout(ac_hot_plug_timeout);
1547 		ac_hot_plug_timeout = NULL;
1548 	}
1549 
1550 	/*
1551 	 * create a new timeout.
1552 	 */
1553 	ac_hot_plug_timeout = timeout(ac_timeout, NULL,
1554 	    drv_usectohz(ac_hot_plug_timeout_interval * 1000000));
1555 
1556 	mutex_exit(&ac_hot_plug_mode_mutex);
1557 	return (0);
1558 }
1559 
1560 static void
1561 ac_timeout(void *arg)
1562 {
1563 	struct ac_soft_state *softsp;
1564 	fhc_bd_t	*board;
1565 
1566 #ifdef lint
1567 	arg = arg;
1568 #endif /* lint */
1569 
1570 	ac_hot_plug_timeout = (timeout_id_t)NULL;
1571 
1572 	(void) fhc_bdlist_lock(-1);
1573 
1574 	/*
1575 	 * Foreach ac in the board list we need to
1576 	 * re-program the pcr into "hot-plug" mode.
1577 	 * We also program the pic register with the
1578 	 * bus pause timing
1579 	 */
1580 	board = fhc_bd_first();
1581 	while (board != NULL) {
1582 		softsp = board->ac_softsp;
1583 		if (softsp == NULL) {
1584 			/*
1585 			 * This board must not have an AC.
1586 			 * Skip it and move on.
1587 			 */
1588 			board = fhc_bd_next(board);
1589 			continue;
1590 		}
1591 		/* program the pcr into hot-plug mode */
1592 		*softsp->ac_mccr = AC_CLEAR_PCR(*softsp->ac_mccr);
1593 		*softsp->ac_mccr = AC_SET_HOT_PLUG(*softsp->ac_mccr);
1594 
1595 		/* program the pic with the bus pause time value */
1596 		*softsp->ac_counter = AC_SET_PIC_BUS_PAUSE(softsp->board);
1597 
1598 		/* get the next board */
1599 		board = fhc_bd_next(board);
1600 	}
1601 
1602 	ac_exit_transition();
1603 
1604 	fhc_bdlist_unlock();
1605 
1606 	/*
1607 	 * It is now safe to start hot-plugging again. We need
1608 	 * to display a message.
1609 	 */
1610 	cmn_err(CE_NOTE, "This machine is now in hot-plug mode.");
1611 	cmn_err(CE_CONT, "Board and power supply hot-plug operations "
1612 	    "can be resumed.");
1613 }
1614 
1615 /*
1616  * This function will acquire the lock and set the in_transition
1617  * bit for all the slots.  If the slots are being used,
1618  * we return FALSE; else set in_transition and return TRUE.
1619  */
1620 static int
1621 ac_enter_transition(void)
1622 {
1623 	fhc_bd_t	*list;
1624 	sysc_cfga_stat_t *sysc_stat_lk;
1625 
1626 	/* mutex lock the structure */
1627 	(void) fhc_bdlist_lock(-1);
1628 
1629 	list = fhc_bd_clock();
1630 
1631 	/* change the in_transition bit */
1632 	sysc_stat_lk = &list->sc;
1633 	if (sysc_stat_lk->in_transition == TRUE) {
1634 		fhc_bdlist_unlock();
1635 		return (FALSE);
1636 	} else {
1637 		sysc_stat_lk->in_transition = TRUE;
1638 		return (TRUE);
1639 	}
1640 }
1641 
1642 /*
1643  * clear the in_transition bit for all the slots.
1644  */
1645 static void
1646 ac_exit_transition(void)
1647 {
1648 	fhc_bd_t	*list;
1649 	sysc_cfga_stat_t *sysc_stat_lk;
1650 
1651 	ASSERT(fhc_bdlist_locked());
1652 
1653 	list = fhc_bd_clock();
1654 
1655 	sysc_stat_lk = &list->sc;
1656 	ASSERT(sysc_stat_lk->in_transition == TRUE);
1657 	sysc_stat_lk->in_transition = FALSE;
1658 }
1659