xref: /illumos-gate/usr/src/uts/sun4u/io/pci/simba.c (revision 7c478bd95313f5f23a4c958a745db2134aa03244)
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, Version 1.0 only
6  * (the "License").  You may not use this file except in compliance
7  * with the License.
8  *
9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10  * or http://www.opensolaris.org/os/licensing.
11  * See the License for the specific language governing permissions
12  * and limitations under the License.
13  *
14  * When distributing Covered Code, include this CDDL HEADER in each
15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16  * If applicable, add the following below this CDDL HEADER, with the
17  * fields enclosed by brackets "[]" replaced with your own identifying
18  * information: Portions Copyright [yyyy] [name of copyright owner]
19  *
20  * CDDL HEADER END
21  */
22 /*
23  * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 
27 #pragma ident	"%Z%%M%	%I%	%E% SMI"
28 
29 /*
30  *	PCI to PCI bus bridge nexus driver
31  */
32 
33 #include <sys/conf.h>
34 #include <sys/kmem.h>
35 #include <sys/debug.h>
36 #include <sys/modctl.h>
37 #include <sys/autoconf.h>
38 #include <sys/ddi_impldefs.h>
39 #include <sys/ddi_subrdefs.h>
40 #include <sys/ddifm.h>
41 #include <sys/fm/util.h>
42 #include <sys/fm/protocol.h>
43 #include <sys/fm/io/pci.h>
44 #include <sys/pci.h>
45 #include <sys/pci/pci_nexus.h>
46 #include <sys/pci/pci_regs.h>
47 #include <sys/pci/pci_simba.h>
48 #include <sys/ddi.h>
49 #include <sys/sunddi.h>
50 #include <sys/sunndi.h>
51 #include <sys/promif.h>		/* prom_printf */
52 #include <sys/open.h>
53 #include <sys/stat.h>
54 #include <sys/file.h>
55 
56 #if defined(DEBUG) && !defined(lint)
57 static uint_t simba_debug_flags = 0;
58 #define	D_IDENTIFY	0x00000001
59 #define	D_ATTACH	0x00000002
60 #define	D_DETACH	0x00000004
61 #define	D_MAP		0x00000008
62 #define	D_CTLOPS	0x00000010
63 #define	D_G_ISPEC	0x00000020
64 #define	D_A_ISPEC	0x00000040
65 #define	D_INIT_CLD	0x00400000
66 #define	D_FAULT		0x00000080
67 
68 #define	DEBUG0(f, s) if ((f)& simba_debug_flags) \
69 	prom_printf("simba: " s "\n")
70 
71 #define	DEBUG1(f, s, a) if ((f)& simba_debug_flags) \
72 	prom_printf("simba: " s "\n", a)
73 
74 #define	DEBUG2(f, s, a, b) if ((f)& simba_debug_flags) \
75 	prom_printf("simba: " s "\n", a, b)
76 
77 #define	DEBUG3(f, s, a, b, c) if ((f)& simba_debug_flags) \
78 	prom_printf("simba: " s "\n", a, b, c)
79 
80 #define	DEBUG4(f, s, a, b, c, d) if ((f)& simba_debug_flags) \
81 	prom_printf("simba: " s "\n", a, b, c, d)
82 
83 #define	DEBUG5(f, s, a, b, c, d, e) if ((f)& simba_debug_flags) \
84 	prom_printf("simba: " s "\n", a, b, c, d, e)
85 
86 #define	DEBUG6(f, s, a, b, c, d, e, ff) if ((f)& simba_debug_flags) \
87 	prom_printf("simba: " s "\n", a, b, c, d, e, ff)
88 
89 #else
90 
91 #define	DEBUG0(f, s)
92 #define	DEBUG1(f, s, a)
93 #define	DEBUG2(f, s, a, b)
94 #define	DEBUG3(f, s, a, b, c)
95 #define	DEBUG4(f, s, a, b, c, d)
96 #define	DEBUG5(f, s, a, b, c, d, e)
97 #define	DEBUG6(f, s, a, b, c, d, e, ff)
98 
99 #endif
100 
101 /*
102  * The variable controls the default setting of the command register
103  * for pci devices.  See simba_initchild() for details.
104  */
105 static ushort_t simba_command_default = PCI_COMM_SERR_ENABLE |
106 					PCI_COMM_WAIT_CYC_ENAB |
107 					PCI_COMM_PARITY_DETECT |
108 					PCI_COMM_ME |
109 					PCI_COMM_MAE |
110 					PCI_COMM_IO;
111 
112 static int simba_bus_map(dev_info_t *, dev_info_t *, ddi_map_req_t *,
113 	off_t, off_t, caddr_t *);
114 static int simba_ctlops(dev_info_t *, dev_info_t *, ddi_ctl_enum_t,
115 	void *, void *);
116 static int simba_fm_init_child(dev_info_t *dip, dev_info_t *tdip, int cap,
117 		ddi_iblock_cookie_t *ibc);
118 static void simba_bus_enter(dev_info_t *dip, ddi_acc_handle_t handle);
119 static void simba_bus_exit(dev_info_t *dip, ddi_acc_handle_t handle);
120 
121 struct bus_ops simba_bus_ops = {
122 	BUSO_REV,
123 	simba_bus_map,
124 	0,
125 	0,
126 	0,
127 	i_ddi_map_fault,
128 	ddi_dma_map,
129 	ddi_dma_allochdl,
130 	ddi_dma_freehdl,
131 	ddi_dma_bindhdl,
132 	ddi_dma_unbindhdl,
133 	ddi_dma_flush,
134 	ddi_dma_win,
135 	ddi_dma_mctl,
136 	simba_ctlops,
137 	ddi_bus_prop_op,
138 	ndi_busop_get_eventcookie,
139 	ndi_busop_add_eventcall,
140 	ndi_busop_remove_eventcall,
141 	ndi_post_event,
142 	0,
143 	0,
144 	0,
145 	simba_fm_init_child,
146 	NULL,
147 	simba_bus_enter,
148 	simba_bus_exit,
149 	0,
150 	i_ddi_intr_ops
151 };
152 
153 static int simba_open(dev_t *devp, int flags, int otyp, cred_t *credp);
154 static int simba_close(dev_t dev, int flags, int otyp, cred_t *credp);
155 static int simba_ioctl(dev_t dev, int cmd, intptr_t arg, int mode,
156     cred_t *credp, int *rvalp);
157 
158 static struct cb_ops simba_cb_ops = {
159 	simba_open,			/* open */
160 	simba_close,			/* close */
161 	nulldev,			/* strategy */
162 	nulldev,			/* print */
163 	nulldev,			/* dump */
164 	nulldev,			/* read */
165 	nulldev,			/* write */
166 	simba_ioctl,			/* ioctl */
167 	nodev,				/* devmap */
168 	nodev,				/* mmap */
169 	nodev,				/* segmap */
170 	nochpoll,			/* poll */
171 	ddi_prop_op,			/* cb_prop_op */
172 	NULL,				/* streamtab */
173 	D_NEW | D_MP | D_HOTPLUG,	/* Driver compatibility flag */
174 	CB_REV,				/* rev */
175 	nodev,				/* int (*cb_aread)() */
176 	nodev				/* int (*cb_awrite)() */
177 };
178 
179 static int simba_probe(dev_info_t *);
180 static int simba_attach(dev_info_t *devi, ddi_attach_cmd_t cmd);
181 static int simba_detach(dev_info_t *devi, ddi_detach_cmd_t cmd);
182 static int simba_info(dev_info_t *dip, ddi_info_cmd_t infocmd,
183 	void *arg, void **result);
184 
185 struct dev_ops simba_ops = {
186 	DEVO_REV,		/* devo_rev */
187 	0,			/* refcnt  */
188 	simba_info,		/* info */
189 	nulldev,		/* identify */
190 	simba_probe,		/* probe */
191 	simba_attach,		/* attach */
192 	simba_detach,		/* detach */
193 	nulldev,		/* reset */
194 	&simba_cb_ops,		/* driver operations */
195 	&simba_bus_ops		/* bus operations */
196 
197 };
198 
199 /*
200  * Module linkage information for the kernel.
201  */
202 
203 static struct modldrv modldrv = {
204 	&mod_driverops, /* Type of module */
205 	"SIMBA PCI to PCI bridge nexus driver %I%",
206 	&simba_ops,	/* driver ops */
207 };
208 
209 static struct modlinkage modlinkage = {
210 	MODREV_1,
211 	(void *)&modldrv,
212 	NULL
213 };
214 
215 /*
216  * Simba specific error state structure
217  */
218 static struct simba_errstate {
219 	char *error;
220 	ushort_t pci_cfg_stat;
221 	ushort_t pci_cfg_sec_stat;
222 	uint64_t afsr;
223 	uint64_t afar;
224 	int bridge_secondary;
225 };
226 
227 static struct simba_cfg_state {
228 	dev_info_t *dip;
229 	ushort_t command;
230 	uchar_t cache_line_size;
231 	uchar_t latency_timer;
232 	uchar_t header_type;
233 	uchar_t bus_number;
234 	uchar_t sec_bus_number;
235 	uchar_t sub_bus_number;
236 	uchar_t sec_latency_timer;
237 	ushort_t bridge_control;
238 };
239 
240 /*
241  * soft state pointer and structure template:
242  */
243 static void *simba_state;
244 
245 typedef struct {
246 
247 	dev_info_t *dip;
248 
249 	/*
250 	 * configuration register state for the bus:
251 	 */
252 	ddi_acc_handle_t config_handle;
253 	uchar_t simba_cache_line_size;
254 	uchar_t simba_latency_timer;
255 
256 	/*
257 	 * cpr support:
258 	 */
259 	uint_t config_state_index;
260 	struct simba_cfg_state *simba_config_state_p;
261 	ddi_iblock_cookie_t fm_ibc;
262 	int fm_cap;
263 	kmutex_t simba_mutex;
264 	uint_t simba_soft_state;
265 #define	SIMBA_SOFT_STATE_CLOSED		0x00
266 #define	SIMBA_SOFT_STATE_OPEN		0x01
267 #define	SIMBA_SOFT_STATE_OPEN_EXCL	0x02
268 } simba_devstate_t;
269 
270 /*
271  * The following variable enables a workaround for the following obp bug:
272  *
273  *	1234181 - obp should set latency timer registers in pci
274  *		configuration header
275  *
276  * Until this bug gets fixed in the obp, the following workaround should
277  * be enabled.
278  */
279 static uint_t simba_set_latency_timer_register = 1;
280 
281 /*
282  * The following variable enables a workaround for an obp bug to be
283  * submitted.  A bug requesting a workaround fof this problem has
284  * been filed:
285  *
286  *	1235094 - need workarounds on positron nexus drivers to set cache
287  *		line size registers
288  *
289  * Until this bug gets fixed in the obp, the following workaround should
290  * be enabled.
291  */
292 static uint_t simba_set_cache_line_size_register = 1;
293 
294 
295 /*
296  * forward function declarations:
297  */
298 static void simba_uninitchild(dev_info_t *);
299 static int simba_initchild(dev_info_t *child);
300 static void simba_save_config_regs(simba_devstate_t *simba_p);
301 static void simba_restore_config_regs(simba_devstate_t *simba_p);
302 static int simba_err_callback(dev_info_t *dip, ddi_fm_error_t *derr,
303 		const void *impl_data);
304 
305 int
306 _init(void)
307 {
308 	int e;
309 
310 	DEBUG0(D_ATTACH, "_init() installing module...\n");
311 	if ((e = ddi_soft_state_init(&simba_state, sizeof (simba_devstate_t),
312 	    1)) == 0 && (e = mod_install(&modlinkage)) != 0)
313 		ddi_soft_state_fini(&simba_state);
314 
315 	DEBUG0(D_ATTACH, "_init() module installed\n");
316 	return (e);
317 }
318 
319 int
320 _fini(void)
321 {
322 	int e;
323 	DEBUG0(D_ATTACH, "_fini() removing module...\n");
324 	if ((e = mod_remove(&modlinkage)) == 0)
325 		ddi_soft_state_fini(&simba_state);
326 	return (e);
327 }
328 
329 int
330 _info(struct modinfo *modinfop)
331 {
332 	DEBUG0(D_ATTACH, "_info() called.\n");
333 	return (mod_info(&modlinkage, modinfop));
334 }
335 
336 /*ARGSUSED*/
337 static int
338 simba_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result)
339 {
340 	simba_devstate_t *simba_p;	/* per simba state pointer */
341 	int instance;
342 
343 	instance = getminor((dev_t)arg);
344 	simba_p = (simba_devstate_t *)ddi_get_soft_state(simba_state,
345 	    instance);
346 
347 	switch (infocmd) {
348 	default:
349 		return (DDI_FAILURE);
350 
351 	case DDI_INFO_DEVT2INSTANCE:
352 		*result = (void *)instance;
353 		return (DDI_SUCCESS);
354 
355 	case DDI_INFO_DEVT2DEVINFO:
356 		if (simba_p == NULL)
357 			return (DDI_FAILURE);
358 		*result = (void *)simba_p->dip;
359 		return (DDI_SUCCESS);
360 	}
361 }
362 
363 /*ARGSUSED*/
364 static int
365 simba_probe(register dev_info_t *devi)
366 {
367 	DEBUG0(D_ATTACH, "simba_probe() called.\n");
368 	return (DDI_PROBE_SUCCESS);
369 }
370 
371 /*ARGSUSED*/
372 static int
373 simba_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
374 {
375 	int instance;
376 	simba_devstate_t *simba;
377 	ddi_fm_error_t derr;
378 
379 	switch (cmd) {
380 	case DDI_ATTACH:
381 
382 		DEBUG1(D_ATTACH, "attach(%x) ATTACH\n", (int)devi);
383 
384 		/*
385 		 * Make sure the "device_type" property exists.
386 		 */
387 		(void) ddi_prop_update_string(DDI_DEV_T_NONE, devi,
388 			"device_type", "pci");
389 
390 		/*
391 		 * Allocate and get soft state structure.
392 		 */
393 		instance = ddi_get_instance(devi);
394 		if (ddi_soft_state_zalloc(simba_state, instance) != DDI_SUCCESS)
395 			return (DDI_FAILURE);
396 		simba = (simba_devstate_t *)ddi_get_soft_state(simba_state,
397 		    instance);
398 		simba->dip = devi;
399 		mutex_init(&simba->simba_mutex, NULL, MUTEX_DRIVER, NULL);
400 		simba->simba_soft_state = SIMBA_SOFT_STATE_CLOSED;
401 
402 		/*
403 		 * create minor node for devctl interfaces
404 		 */
405 		if (ddi_create_minor_node(devi, "devctl", S_IFCHR, instance,
406 		    DDI_NT_NEXUS, 0) != DDI_SUCCESS) {
407 			mutex_destroy(&simba->simba_mutex);
408 			ddi_soft_state_free(simba_state, instance);
409 			return (DDI_FAILURE);
410 		}
411 
412 		if (pci_config_setup(devi, &simba->config_handle) !=
413 		    DDI_SUCCESS) {
414 			ddi_remove_minor_node(devi, "devctl");
415 			mutex_destroy(&simba->simba_mutex);
416 			ddi_soft_state_free(simba_state, instance);
417 			return (DDI_FAILURE);
418 		}
419 
420 		/*
421 		 * Simba cache line size is 64 bytes and hardwired.
422 		 */
423 		simba->simba_cache_line_size =
424 		    pci_config_get8(simba->config_handle,
425 			PCI_CONF_CACHE_LINESZ);
426 		simba->simba_latency_timer =
427 		    pci_config_get8(simba->config_handle,
428 			PCI_CONF_LATENCY_TIMER);
429 
430 		/* simba specific, clears up the pri/sec status registers */
431 		pci_config_put16(simba->config_handle, 0x6, 0xffff);
432 		pci_config_put16(simba->config_handle, 0x1e, 0xffff);
433 
434 		DEBUG2(D_ATTACH, "simba_attach(): clsz=%x, lt=%x\n",
435 			simba->simba_cache_line_size,
436 			simba->simba_latency_timer);
437 
438 		/*
439 		 * Initialize FMA support
440 		 */
441 		simba->fm_cap = DDI_FM_EREPORT_CAPABLE | DDI_FM_ERRCB_CAPABLE |
442 			DDI_FM_ACCCHK_CAPABLE | DDI_FM_DMACHK_CAPABLE;
443 
444 		/*
445 		 * Call parent to get it's capablity
446 		 */
447 		ddi_fm_init(devi, &simba->fm_cap, &simba->fm_ibc);
448 
449 		ASSERT((simba->fm_cap & DDI_FM_ERRCB_CAPABLE) &&
450 		    (simba->fm_cap & DDI_FM_EREPORT_CAPABLE));
451 
452 		pci_ereport_setup(devi);
453 
454 		/*
455 		 * clear any outstanding error bits
456 		 */
457 		bzero(&derr, sizeof (ddi_fm_error_t));
458 		derr.fme_version = DDI_FME_VERSION;
459 		derr.fme_flag = DDI_FM_ERR_EXPECTED;
460 		pci_ereport_post(devi, &derr, NULL);
461 		pci_bdg_ereport_post(devi, &derr, NULL);
462 
463 		ddi_fm_handler_register(devi, simba_err_callback, simba);
464 
465 		ddi_report_dev(devi);
466 		DEBUG0(D_ATTACH, "attach(): ATTACH done\n");
467 		return (DDI_SUCCESS);
468 
469 	case DDI_RESUME:
470 
471 		/*
472 		 * Get the soft state structure for the bridge.
473 		 */
474 		simba = (simba_devstate_t *)
475 			ddi_get_soft_state(simba_state, ddi_get_instance(devi));
476 		simba_restore_config_regs(simba);
477 		return (DDI_SUCCESS);
478 	}
479 	return (DDI_FAILURE);
480 }
481 
482 /*ARGSUSED*/
483 static int
484 simba_detach(dev_info_t *devi, ddi_detach_cmd_t cmd)
485 {
486 	simba_devstate_t *simba;
487 	simba = (simba_devstate_t *)
488 		ddi_get_soft_state(simba_state, ddi_get_instance(devi));
489 
490 	switch (cmd) {
491 	case DDI_DETACH:
492 		DEBUG0(D_DETACH, "detach() called\n");
493 		ddi_fm_handler_unregister(devi);
494 		pci_ereport_teardown(devi);
495 		ddi_fm_fini(devi);
496 		pci_config_teardown(&simba->config_handle);
497 		(void) ddi_prop_remove(DDI_DEV_T_NONE, devi, "device_type");
498 		ddi_remove_minor_node(devi, "devctl");
499 		mutex_destroy(&simba->simba_mutex);
500 		ddi_soft_state_free(simba_state, ddi_get_instance(devi));
501 		return (DDI_SUCCESS);
502 
503 	case DDI_SUSPEND:
504 		simba_save_config_regs(simba);
505 		return (DDI_SUCCESS);
506 	}
507 	return (DDI_FAILURE);
508 }
509 
510 /*ARGSUSED*/
511 static int
512 simba_bus_map(dev_info_t *dip, dev_info_t *rdip, ddi_map_req_t *mp,
513 	off_t offset, off_t len, caddr_t *vaddrp)
514 {
515 	register dev_info_t *pdip;
516 
517 	DEBUG3(D_MAP, "simba_bus_map(): dip=%x, rdip=%x, mp=%x", dip, rdip, mp);
518 	DEBUG3(D_MAP, "simba_bus_map(): offset=%x, len=%x, vaddrp=%x",
519 	    offset, len, vaddrp);
520 
521 	pdip = (dev_info_t *)DEVI(dip)->devi_parent;
522 	return ((DEVI(pdip)->devi_ops->devo_bus_ops->bus_map)
523 	    (pdip, rdip, mp, offset, len, vaddrp));
524 }
525 
526 /*
527  * Registered error handling callback with our parent
528  */
529 static int
530 simba_err_callback(dev_info_t *dip, ddi_fm_error_t *derr, const void *impl_data)
531 {
532 	simba_devstate_t *simba = (simba_devstate_t *)impl_data;
533 	struct simba_errstate simba_err;
534 	int ret = 0;
535 
536 	bzero(&simba_err, sizeof (struct simba_errstate));
537 	simba_err.afsr = pci_config_get64(simba->config_handle, 0xe8);
538 	simba_err.afar = pci_config_get64(simba->config_handle, 0xf0);
539 	derr->fme_ena = fm_ena_generate(0, FM_ENA_FMT1);
540 
541 	pci_ereport_post(dip, derr, &simba_err.pci_cfg_stat);
542 	pci_bdg_ereport_post(dip, derr, &simba_err.pci_cfg_sec_stat);
543 	ret = pci_bdg_check_status(dip, derr, simba_err.pci_cfg_stat,
544 	    simba_err.pci_cfg_sec_stat);
545 
546 	DEBUG6(D_FAULT, "%s-%d: cleaning up fault bits %x %x %x.%8x\n",
547 			ddi_driver_name(simba->dip),
548 			ddi_get_instance(simba->dip), simba_err.pci_cfg_stat,
549 			simba_err.pci_cfg_sec_stat,
550 			(uint_t)(simba_err.afsr >> 32),
551 			(uint_t)simba_err.afsr);
552 	pci_config_put64(simba->config_handle, 0xe8, simba_err.afsr);
553 
554 	return (ret);
555 }
556 
557 #if defined(DEBUG) && !defined(lint)
558 static char *ops[] =
559 {
560 	"DDI_CTLOPS_DMAPMAPC",
561 	"DDI_CTLOPS_INITCHILD",
562 	"DDI_CTLOPS_UNINITCHILD",
563 	"DDI_CTLOPS_REPORTDEV",
564 	"DDI_CTLOPS_REPORTINT",
565 	"DDI_CTLOPS_REGSIZE",
566 	"DDI_CTLOPS_NREGS",
567 	"DDI_CTLOPS_NINTRS",
568 	"DDI_CTLOPS_SIDDEV",
569 	"DDI_CTLOPS_SLAVEONLY",
570 	"DDI_CTLOPS_AFFINITY",
571 	"DDI_CTLOPS_IOMIN",
572 	"DDI_CTLOPS_PTOB",
573 	"DDI_CTLOPS_BTOP",
574 	"DDI_CTLOPS_BTOPR",
575 	"DDI_CTLOPS_RESERVED1",
576 	"DDI_CTLOPS_RESERVED2",
577 	"DDI_CTLOPS_RESERVED3",
578 	"DDI_CTLOPS_INTR_HILEVEL",
579 	"DDI_CTLOPS_XLATE_INTRS",
580 	"DDI_CTLOPS_DVMAPAGESIZE",
581 	"DDI_CTLOPS_POWER",
582 	"DDI_CTLOPS_ATTACH",
583 	"DDI_CTLOPS_DETACH",
584 	"DDI_CTLOPS_POKE",
585 	"DDI_CTLOPS_PEEK"
586 };
587 #endif
588 
589 /*ARGSUSED*/
590 static int
591 simba_ctlops(dev_info_t *dip, dev_info_t *rdip, ddi_ctl_enum_t ctlop,
592 	void *arg, void *result)
593 {
594 	int reglen;
595 	int rn;
596 	int totreg;
597 	pci_regspec_t *drv_regp;
598 
599 	DEBUG6(D_CTLOPS,
600 		"simba_ctlops(): dip=%x rdip=%x ctlop=%x-%s arg=%x result=%x",
601 		dip, rdip, ctlop, ctlop < (sizeof (ops) / sizeof (ops[0])) ?
602 		ops[ctlop] : "Unknown", arg, result);
603 
604 	switch (ctlop) {
605 	case DDI_CTLOPS_REPORTDEV:
606 		if (rdip == (dev_info_t *)0)
607 			return (DDI_FAILURE);
608 		cmn_err(CE_CONT, "?PCI-device: %s@%s, %s%d\n",
609 		    ddi_node_name(rdip), ddi_get_name_addr(rdip),
610 		    ddi_driver_name(rdip),
611 		    ddi_get_instance(rdip));
612 		return (DDI_SUCCESS);
613 
614 	case DDI_CTLOPS_INITCHILD:
615 		return (simba_initchild((dev_info_t *)arg));
616 
617 	case DDI_CTLOPS_UNINITCHILD:
618 		simba_uninitchild((dev_info_t *)arg);
619 		return (DDI_SUCCESS);
620 
621 	case DDI_CTLOPS_SIDDEV:
622 		return (DDI_SUCCESS);
623 
624 	case DDI_CTLOPS_REGSIZE:
625 	case DDI_CTLOPS_NREGS:
626 		if (rdip == (dev_info_t *)0)
627 			return (DDI_FAILURE);
628 		break;
629 
630 	default:
631 		DEBUG0(D_CTLOPS, "simba_ctlops(): calling ddi_ctlops()");
632 		return (ddi_ctlops(dip, rdip, ctlop, arg, result));
633 	}
634 
635 	*(int *)result = 0;
636 	if (ddi_getlongprop(DDI_DEV_T_NONE, rdip,
637 		DDI_PROP_DONTPASS | DDI_PROP_CANSLEEP, "reg",
638 		(caddr_t)&drv_regp, &reglen) != DDI_SUCCESS)
639 		return (DDI_FAILURE);
640 
641 	totreg = reglen / sizeof (pci_regspec_t);
642 	if (ctlop == DDI_CTLOPS_NREGS)
643 		*(int *)result = totreg;
644 	else if (ctlop == DDI_CTLOPS_REGSIZE) {
645 		rn = *(int *)arg;
646 		if (rn >= totreg) {
647 			kmem_free(drv_regp, reglen);
648 			return (DDI_FAILURE);
649 		}
650 		*(off_t *)result = drv_regp[rn].pci_size_low |
651 			((uint64_t)drv_regp[rn].pci_size_hi << 32);
652 	}
653 
654 	kmem_free(drv_regp, reglen);
655 	DEBUG1(D_CTLOPS, "simba_ctlops(): *result=%x\n", *(off_t *)result);
656 	return (DDI_SUCCESS);
657 }
658 
659 static int
660 simba_name_child(dev_info_t *child, char *name, int namelen)
661 {
662 	uint_t n, slot, func;
663 	pci_regspec_t *pci_rp;
664 
665 	if (ndi_dev_is_persistent_node(child) == 0) {
666 		char **unit_addr;
667 
668 		/* name .conf nodes by "unit-address" property" */
669 		if (ddi_prop_lookup_string_array(DDI_DEV_T_ANY, child,
670 		    DDI_PROP_DONTPASS, "unit-address", &unit_addr, &n) !=
671 		    DDI_PROP_SUCCESS) {
672 			cmn_err(CE_WARN, "cannot name node from %s.conf",
673 			    ddi_driver_name(child));
674 			return (DDI_FAILURE);
675 		}
676 		if (n != 1 || *unit_addr == NULL || **unit_addr == 0) {
677 			cmn_err(CE_WARN, "unit-address property in %s.conf"
678 			    " not well-formed", ddi_driver_name(child));
679 			ddi_prop_free(unit_addr);
680 			return (DDI_FAILURE);
681 		}
682 
683 		(void) snprintf(name, namelen, "%s", *unit_addr);
684 		ddi_prop_free(unit_addr);
685 		return (DDI_SUCCESS);
686 	}
687 
688 	/* name hardware nodes by "reg" property */
689 	if (ddi_prop_lookup_int_array(DDI_DEV_T_ANY, child, 0, "reg",
690 	    (int **)&pci_rp, &n) != DDI_SUCCESS)
691 		return (DDI_FAILURE);
692 
693 	/* get the device identifications */
694 	slot = PCI_REG_DEV_G(pci_rp->pci_phys_hi);
695 	func = PCI_REG_FUNC_G(pci_rp->pci_phys_hi);
696 
697 	if (func != 0)
698 		(void) snprintf(name, namelen, "%x,%x", slot, func);
699 	else
700 		(void) snprintf(name, namelen, "%x", slot);
701 
702 	ddi_prop_free(pci_rp);
703 	return (DDI_SUCCESS);
704 }
705 
706 static int
707 simba_initchild(dev_info_t *child)
708 {
709 	char name[MAXNAMELEN];
710 	int i;
711 	ddi_acc_handle_t config_handle;
712 	ushort_t command_preserve, command;
713 	uchar_t header_type;
714 	uchar_t min_gnt, latency_timer;
715 	simba_devstate_t *simba;
716 	uint_t n;
717 
718 	DEBUG1(D_INIT_CLD, "simba_initchild(): child=%x\n", child);
719 
720 	/*
721 	 * Pseudo nodes indicate a prototype node with per-instance
722 	 * properties to be merged into the real h/w device node.
723 	 * The interpretation of the unit-address is DD[,F]
724 	 * where DD is the device id and F is the function.
725 	 */
726 	if (ndi_dev_is_persistent_node(child) == 0) {
727 		extern int pci_allow_pseudo_children;
728 		pci_regspec_t *pci_rp;
729 
730 		if (ddi_getlongprop(DDI_DEV_T_ANY, child,
731 		    DDI_PROP_DONTPASS, "reg", (caddr_t)&pci_rp, &i) ==
732 		    DDI_SUCCESS) {
733 			cmn_err(CE_WARN,
734 			    "cannot merge prototype from %s.conf",
735 			    ddi_driver_name(child));
736 			kmem_free(pci_rp, i);
737 			return (DDI_NOT_WELL_FORMED);
738 		}
739 
740 		if (simba_name_child(child, name, MAXNAMELEN) != DDI_SUCCESS)
741 			return (DDI_NOT_WELL_FORMED);
742 
743 		ddi_set_name_addr(child, name);
744 		ddi_set_parent_data(child, NULL);
745 
746 		/*
747 		 * Try to merge the properties from this prototype
748 		 * node into real h/w nodes.
749 		 */
750 		if (ndi_merge_node(child, simba_name_child) == DDI_SUCCESS) {
751 			/*
752 			 * Merged ok - return failure to remove the node.
753 			 */
754 			simba_uninitchild(child);
755 			return (DDI_FAILURE);
756 		}
757 
758 		/* workaround for ddivs to run under PCI */
759 		if (pci_allow_pseudo_children)
760 			return (DDI_SUCCESS);
761 
762 		/*
763 		 * The child was not merged into a h/w node,
764 		 * but there's not much we can do with it other
765 		 * than return failure to cause the node to be removed.
766 		 */
767 		cmn_err(CE_WARN, "!%s@%s: %s.conf properties not merged",
768 		    ddi_driver_name(child), ddi_get_name_addr(child),
769 		    ddi_driver_name(child));
770 		simba_uninitchild(child);
771 		return (DDI_NOT_WELL_FORMED);
772 	}
773 
774 	/*
775 	 * Initialize real h/w nodes
776 	 */
777 	if (simba_name_child(child, name, MAXNAMELEN) != DDI_SUCCESS)
778 		return (DDI_FAILURE);
779 
780 	ddi_set_name_addr(child, name);
781 	ddi_set_parent_data(child, NULL);
782 
783 	if (pci_config_setup(child, &config_handle) != DDI_SUCCESS) {
784 		simba_uninitchild(child);
785 		return (DDI_FAILURE);
786 	}
787 
788 	DEBUG0(D_INIT_CLD, "simba_initchild(): pci_config_setup success!\n");
789 
790 	/*
791 	 * Determine the configuration header type.
792 	 */
793 	header_type = pci_config_get8(config_handle, PCI_CONF_HEADER);
794 
795 	/*
796 	 * Support for the "command-preserve" property.
797 	 */
798 	command_preserve = ddi_prop_get_int(DDI_DEV_T_ANY, child,
799 	    DDI_PROP_DONTPASS, "command-preserve", 0);
800 	command = pci_config_get16(config_handle, PCI_CONF_COMM);
801 	command &= (command_preserve | PCI_COMM_BACK2BACK_ENAB);
802 	command |= (simba_command_default & ~command_preserve);
803 	pci_config_put16(config_handle, PCI_CONF_COMM, command);
804 
805 	/* clean up all PCI child devices status register */
806 	pci_config_put16(config_handle, PCI_CONF_STAT, 0xffff);
807 
808 	/*
809 	 * If the device has a primary bus control register then program it
810 	 * based on the settings in the command register.
811 	 */
812 	if ((header_type & PCI_HEADER_TYPE_M) == PCI_HEADER_ONE) {
813 		ushort_t bcr =
814 		    pci_config_get16(config_handle, PCI_BCNF_BCNTRL);
815 		if (simba_command_default & PCI_COMM_PARITY_DETECT)
816 			bcr |= PCI_BCNF_BCNTRL_PARITY_ENABLE;
817 		if (simba_command_default & PCI_COMM_SERR_ENABLE)
818 			bcr |= PCI_BCNF_BCNTRL_SERR_ENABLE;
819 		bcr |= PCI_BCNF_BCNTRL_MAST_AB_MODE;
820 		pci_config_put8(config_handle, PCI_BCNF_BCNTRL, bcr);
821 	}
822 
823 	simba = (simba_devstate_t *)ddi_get_soft_state(simba_state,
824 		ddi_get_instance(ddi_get_parent(child)));
825 	/*
826 	 * Initialize cache-line-size configuration register if needed.
827 	 */
828 	if (simba_set_cache_line_size_register &&
829 	    ddi_getprop(DDI_DEV_T_ANY, child, DDI_PROP_DONTPASS,
830 		"cache-line-size", 0) == 0) {
831 		pci_config_put8(config_handle, PCI_CONF_CACHE_LINESZ,
832 		    simba->simba_cache_line_size);
833 		n = pci_config_get8(config_handle, PCI_CONF_CACHE_LINESZ);
834 		if (n != 0)
835 			(void) ndi_prop_update_int(DDI_DEV_T_NONE, child,
836 				"cache-line-size", n);
837 	}
838 
839 	/*
840 	 * Initialize latency timer configuration registers if needed.
841 	 */
842 	if (simba_set_latency_timer_register &&
843 	    ddi_getprop(DDI_DEV_T_ANY, child, DDI_PROP_DONTPASS,
844 		"latency-timer", 0) == 0) {
845 
846 		if ((header_type & PCI_HEADER_TYPE_M) == PCI_HEADER_ONE) {
847 			latency_timer = simba->simba_latency_timer;
848 			pci_config_put8(config_handle, PCI_BCNF_LATENCY_TIMER,
849 			    simba->simba_latency_timer);
850 		} else {
851 			min_gnt = pci_config_get8(config_handle,
852 			    PCI_CONF_MIN_G);
853 			latency_timer = min_gnt * 8;
854 		}
855 		pci_config_put8(config_handle, PCI_CONF_LATENCY_TIMER,
856 		    latency_timer);
857 		n = pci_config_get8(config_handle, PCI_CONF_LATENCY_TIMER);
858 		if (n != 0)
859 			(void) ndi_prop_update_int(DDI_DEV_T_NONE, child,
860 			    "latency-timer", n);
861 	}
862 
863 	pci_config_teardown(&config_handle);
864 	DEBUG0(D_INIT_CLD, "simba_initchild(): pci_config_teardown called\n");
865 	return (DDI_SUCCESS);
866 }
867 
868 static void
869 simba_uninitchild(dev_info_t *dip)
870 {
871 	ddi_set_name_addr(dip, NULL);
872 
873 	/*
874 	 * Strip the node to properly convert it back to prototype form
875 	 */
876 	impl_rem_dev_props(dip);
877 }
878 
879 /*
880  * simba_save_config_regs
881  *
882  * This routine saves the state of the configuration registers of all
883  * the child nodes of each PBM.
884  *
885  * used by: simba_detach() on suspends
886  *
887  * return value: none
888  */
889 static void
890 simba_save_config_regs(simba_devstate_t *simba_p)
891 {
892 	int i;
893 	dev_info_t *dip;
894 	ddi_acc_handle_t ch;
895 	struct simba_cfg_state *statep;
896 
897 	for (i = 0, dip = ddi_get_child(simba_p->dip); dip != NULL;
898 		dip = ddi_get_next_sibling(dip)) {
899 		if (i_ddi_node_state(dip) >= DS_ATTACHED)
900 			i++;
901 	}
902 	if (!i)
903 		return;
904 	simba_p->simba_config_state_p =
905 		kmem_zalloc(i * sizeof (struct simba_cfg_state), KM_NOSLEEP);
906 	if (!simba_p->simba_config_state_p) {
907 		cmn_err(CE_WARN, "not enough memrory to save simba child\n");
908 		return;
909 	}
910 	simba_p->config_state_index = i;
911 
912 	for (statep = simba_p->simba_config_state_p,
913 		dip = ddi_get_child(simba_p->dip);
914 		dip != NULL;
915 		dip = ddi_get_next_sibling(dip)) {
916 
917 		if (i_ddi_node_state(dip) < DS_ATTACHED) {
918 			DEBUG4(D_DETACH, "%s%d: skipping unattached %s%d\n",
919 				ddi_driver_name(simba_p->dip),
920 				ddi_get_instance(simba_p->dip),
921 				ddi_driver_name(dip),
922 				ddi_get_instance(dip));
923 			continue;
924 		}
925 
926 		DEBUG4(D_DETACH, "%s%d: saving regs for %s%d\n",
927 			ddi_driver_name(simba_p->dip),
928 			ddi_get_instance(simba_p->dip),
929 			ddi_driver_name(dip),
930 			ddi_get_instance(dip));
931 
932 		if (pci_config_setup(dip, &ch) != DDI_SUCCESS) {
933 			DEBUG4(D_DETACH, "%s%d: can't config space for %s%d\n",
934 				ddi_driver_name(simba_p->dip),
935 				ddi_get_instance(simba_p->dip),
936 				ddi_driver_name(dip),
937 				ddi_get_instance(dip));
938 			continue;
939 		}
940 
941 		DEBUG3(D_DETACH, "%s%d: saving child dip=%x\n",
942 			ddi_driver_name(simba_p->dip),
943 			ddi_get_instance(simba_p->dip),
944 			dip);
945 
946 		statep->dip = dip;
947 		statep->command = pci_config_get16(ch, PCI_CONF_COMM);
948 		statep->header_type = pci_config_get8(ch, PCI_CONF_HEADER);
949 		if ((statep->header_type & PCI_HEADER_TYPE_M) == PCI_HEADER_ONE)
950 			statep->bridge_control =
951 			    pci_config_get16(ch, PCI_BCNF_BCNTRL);
952 		statep->cache_line_size =
953 			pci_config_get8(ch, PCI_CONF_CACHE_LINESZ);
954 		statep->latency_timer =
955 			pci_config_get8(ch, PCI_CONF_LATENCY_TIMER);
956 		if ((statep->header_type & PCI_HEADER_TYPE_M) == PCI_HEADER_ONE)
957 			statep->sec_latency_timer =
958 				pci_config_get8(ch, PCI_BCNF_LATENCY_TIMER);
959 		/*
960 		 * Simba specific.
961 		 */
962 		if (pci_config_get16(ch, PCI_CONF_VENID) == PCI_SIMBA_VENID &&
963 		    pci_config_get16(ch, PCI_CONF_DEVID) == PCI_SIMBA_DEVID) {
964 
965 			statep->bus_number =
966 				pci_config_get8(ch, PCI_BCNF_PRIBUS);
967 			statep->sec_bus_number =
968 				pci_config_get8(ch, PCI_BCNF_SECBUS);
969 			statep->sub_bus_number =
970 				pci_config_get8(ch, PCI_BCNF_SUBBUS);
971 			statep->bridge_control =
972 				pci_config_get16(ch, PCI_BCNF_BCNTRL);
973 		}
974 		pci_config_teardown(&ch);
975 		statep++;
976 	}
977 }
978 
979 
980 /*
981  * simba_restore_config_regs
982  *
983  * This routine restores the state of the configuration registers of all
984  * the child nodes of each PBM.
985  *
986  * used by: simba_attach() on resume
987  *
988  * return value: none
989  */
990 static void
991 simba_restore_config_regs(simba_devstate_t *simba_p)
992 {
993 	int i;
994 	dev_info_t *dip;
995 	ddi_acc_handle_t ch;
996 	struct simba_cfg_state *statep = simba_p->simba_config_state_p;
997 	if (!simba_p->config_state_index)
998 		return;
999 
1000 	for (i = 0; i < simba_p->config_state_index; i++, statep++) {
1001 		dip = statep->dip;
1002 		if (!dip) {
1003 			cmn_err(CE_WARN,
1004 				"%s%d: skipping bad dev info (%d)\n",
1005 				ddi_driver_name(simba_p->dip),
1006 				ddi_get_instance(simba_p->dip),
1007 				i);
1008 			continue;
1009 		}
1010 
1011 		DEBUG5(D_ATTACH, "%s%d: restoring regs for %x-%s%d\n",
1012 			ddi_driver_name(simba_p->dip),
1013 			ddi_get_instance(simba_p->dip),
1014 			dip,
1015 			ddi_driver_name(dip),
1016 			ddi_get_instance(dip));
1017 
1018 		if (pci_config_setup(dip, &ch) != DDI_SUCCESS) {
1019 			DEBUG4(D_ATTACH, "%s%d: can't config space for %s%d\n",
1020 				ddi_driver_name(simba_p->dip),
1021 				ddi_get_instance(simba_p->dip),
1022 				ddi_driver_name(dip),
1023 				ddi_get_instance(dip));
1024 			continue;
1025 		}
1026 		pci_config_put16(ch, PCI_CONF_COMM, statep->command);
1027 		if ((statep->header_type & PCI_HEADER_TYPE_M) == PCI_HEADER_ONE)
1028 			pci_config_put16(ch, PCI_BCNF_BCNTRL,
1029 				statep->bridge_control);
1030 		/*
1031 		 * Simba specific.
1032 		 */
1033 		if (pci_config_get16(ch, PCI_CONF_VENID) == PCI_SIMBA_VENID &&
1034 		    pci_config_get16(ch, PCI_CONF_DEVID) == PCI_SIMBA_DEVID) {
1035 			pci_config_put8(ch, PCI_BCNF_PRIBUS,
1036 				statep->bus_number);
1037 			pci_config_put8(ch, PCI_BCNF_SECBUS,
1038 				statep->sec_bus_number);
1039 			pci_config_put8(ch, PCI_BCNF_SUBBUS,
1040 				statep->sub_bus_number);
1041 			pci_config_put16(ch, PCI_BCNF_BCNTRL,
1042 				statep->bridge_control);
1043 		}
1044 
1045 		pci_config_put8(ch, PCI_CONF_CACHE_LINESZ,
1046 			statep->cache_line_size);
1047 		pci_config_put8(ch, PCI_CONF_LATENCY_TIMER,
1048 			statep->latency_timer);
1049 		if ((statep->header_type & PCI_HEADER_TYPE_M) == PCI_HEADER_ONE)
1050 			pci_config_put8(ch, PCI_BCNF_LATENCY_TIMER,
1051 				statep->sec_latency_timer);
1052 		pci_config_teardown(&ch);
1053 	}
1054 
1055 	kmem_free(simba_p->simba_config_state_p,
1056 		simba_p->config_state_index * sizeof (struct simba_cfg_state));
1057 	simba_p->simba_config_state_p = NULL;
1058 	simba_p->config_state_index = 0;
1059 }
1060 
1061 /* ARGSUSED */
1062 static int
1063 simba_open(dev_t *devp, int flags, int otyp, cred_t *credp)
1064 {
1065 	simba_devstate_t *simba_p;
1066 
1067 	/*
1068 	 * Make sure the open is for the right file type.
1069 	 */
1070 	if (otyp != OTYP_CHR)
1071 		return (EINVAL);
1072 
1073 	/*
1074 	 * Get the soft state structure for the device.
1075 	 */
1076 	simba_p = (simba_devstate_t *)ddi_get_soft_state(simba_state,
1077 	    getminor(*devp));
1078 	if (simba_p == NULL)
1079 		return (ENXIO);
1080 
1081 	/*
1082 	 * Handle the open by tracking the device state.
1083 	 */
1084 	mutex_enter(&simba_p->simba_mutex);
1085 	if (flags & FEXCL) {
1086 		if (simba_p->simba_soft_state != SIMBA_SOFT_STATE_CLOSED) {
1087 			mutex_exit(&simba_p->simba_mutex);
1088 			return (EBUSY);
1089 		}
1090 		simba_p->simba_soft_state = SIMBA_SOFT_STATE_OPEN_EXCL;
1091 	} else {
1092 		if (simba_p->simba_soft_state == SIMBA_SOFT_STATE_OPEN_EXCL) {
1093 			mutex_exit(&simba_p->simba_mutex);
1094 			return (EBUSY);
1095 		}
1096 		simba_p->simba_soft_state = SIMBA_SOFT_STATE_OPEN;
1097 	}
1098 	mutex_exit(&simba_p->simba_mutex);
1099 	return (0);
1100 }
1101 
1102 
1103 /* ARGSUSED */
1104 static int
1105 simba_close(dev_t dev, int flags, int otyp, cred_t *credp)
1106 {
1107 	simba_devstate_t *simba_p;
1108 
1109 	if (otyp != OTYP_CHR)
1110 		return (EINVAL);
1111 
1112 	simba_p = (simba_devstate_t *)ddi_get_soft_state(simba_state,
1113 	    getminor(dev));
1114 	if (simba_p == NULL)
1115 		return (ENXIO);
1116 
1117 	mutex_enter(&simba_p->simba_mutex);
1118 	simba_p->simba_soft_state = SIMBA_SOFT_STATE_CLOSED;
1119 	mutex_exit(&simba_p->simba_mutex);
1120 	return (0);
1121 }
1122 
1123 
1124 /*
1125  * simba_ioctl: devctl hotplug controls
1126  */
1127 /* ARGSUSED */
1128 static int
1129 simba_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *credp,
1130 	int *rvalp)
1131 {
1132 	simba_devstate_t *simba_p;
1133 	dev_info_t *self;
1134 	struct devctl_iocdata *dcp;
1135 	uint_t bus_state;
1136 	int rv = 0;
1137 
1138 	simba_p = (simba_devstate_t *)ddi_get_soft_state(simba_state,
1139 	    getminor(dev));
1140 	if (simba_p == NULL)
1141 		return (ENXIO);
1142 
1143 	self = simba_p->dip;
1144 
1145 	/*
1146 	 * We can use the generic implementation for these ioctls
1147 	 */
1148 	switch (cmd) {
1149 	case DEVCTL_DEVICE_GETSTATE:
1150 	case DEVCTL_DEVICE_ONLINE:
1151 	case DEVCTL_DEVICE_OFFLINE:
1152 	case DEVCTL_BUS_GETSTATE:
1153 		return (ndi_devctl_ioctl(self, cmd, arg, mode, 0));
1154 	}
1155 
1156 	/*
1157 	 * read devctl ioctl data
1158 	 */
1159 	if (ndi_dc_allochdl((void *)arg, &dcp) != NDI_SUCCESS)
1160 		return (EFAULT);
1161 
1162 	switch (cmd) {
1163 
1164 	case DEVCTL_DEVICE_RESET:
1165 		rv = ENOTSUP;
1166 		break;
1167 
1168 
1169 	case DEVCTL_BUS_QUIESCE:
1170 		if (ndi_get_bus_state(self, &bus_state) == NDI_SUCCESS)
1171 			if (bus_state == BUS_QUIESCED)
1172 				break;
1173 		(void) ndi_set_bus_state(self, BUS_QUIESCED);
1174 		break;
1175 
1176 	case DEVCTL_BUS_UNQUIESCE:
1177 		if (ndi_get_bus_state(self, &bus_state) == NDI_SUCCESS)
1178 			if (bus_state == BUS_ACTIVE)
1179 				break;
1180 		(void) ndi_set_bus_state(self, BUS_ACTIVE);
1181 		break;
1182 
1183 	case DEVCTL_BUS_RESET:
1184 		rv = ENOTSUP;
1185 		break;
1186 
1187 	case DEVCTL_BUS_RESETALL:
1188 		rv = ENOTSUP;
1189 		break;
1190 
1191 	default:
1192 		rv = ENOTTY;
1193 	}
1194 
1195 	ndi_dc_freehdl(dcp);
1196 	return (rv);
1197 }
1198 
1199 /*
1200  * Initialize FMA resources for children devices. Called when
1201  * child calls ddi_fm_init().
1202  */
1203 /*ARGSUSED*/
1204 static int
1205 simba_fm_init_child(dev_info_t *dip, dev_info_t *tdip, int cap,
1206 		ddi_iblock_cookie_t *ibc)
1207 {
1208 	simba_devstate_t *simba_p = ddi_get_soft_state(simba_state,
1209 			ddi_get_instance(dip));
1210 
1211 	*ibc = simba_p->fm_ibc;
1212 	return (simba_p->fm_cap);
1213 }
1214 
1215 static void
1216 simba_bus_enter(dev_info_t *dip, ddi_acc_handle_t handle)
1217 {
1218 	i_ndi_busop_access_enter(dip, handle);
1219 }
1220 
1221 /* ARGSUSED */
1222 static void
1223 simba_bus_exit(dev_info_t *dip, ddi_acc_handle_t handle)
1224 {
1225 	i_ndi_busop_access_exit(dip, handle);
1226 }
1227