/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2008 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/*
* sun4 root nexus driver
*/
#include <sys/conf.h>
#include <sys/modctl.h>
#include <sys/ddi_subrdefs.h>
#include <sys/sunndi.h>
#include <sys/vmsystm.h>
#include <sys/async.h>
#include <sys/intr.h>
#include <sys/ndifm.h>
#include <vm/seg_dev.h>
#include <vm/seg_kmem.h>
#include <sys/ontrap.h>
/* Useful debugging Stuff */
#include <sys/nexusdebug.h>
#define ROOTNEX_MAP_DEBUG 0x1
#define ROOTNEX_INTR_DEBUG 0x2
/*
* config information
*/
static int
rootnex_map(dev_info_t *dip, dev_info_t *rdip, ddi_map_req_t *mp,
off_t offset, off_t len, caddr_t *vaddrp);
static int
rootnex_intr_ops(dev_info_t *, dev_info_t *, ddi_intr_op_t,
ddi_intr_handle_impl_t *, void *);
static int
rootnex_map_fault(dev_info_t *dip, dev_info_t *rdip,
struct hat *hat, struct seg *seg, caddr_t addr,
struct devpage *dp, pfn_t pfn, uint_t prot, uint_t lock);
static int
rootnex_ctlops(dev_info_t *, dev_info_t *, ddi_ctl_enum_t, void *, void *);
static int
rootnex_busop_fminit(dev_info_t *dip, dev_info_t *tdip, int tcap,
ddi_iblock_cookie_t *ibc);
static void
rootnex_fm_init(dev_info_t *);
static int
rootnex_ctlops_peekpoke(ddi_ctl_enum_t, peekpoke_ctlops_t *, void *result);
/*
* Defined in $KARCH/io/mach_rootnex.c
*/
int rootnex_add_intr_impl(dev_info_t *dip, dev_info_t *rdip,
ddi_intr_handle_impl_t *hdlp);
#pragma weak rootnex_add_intr_impl
int rootnex_remove_intr_impl(dev_info_t *dip, dev_info_t *rdip,
ddi_intr_handle_impl_t *hdlp);
#pragma weak rootnex_remove_intr_impl
int rootnex_get_intr_pri(dev_info_t *dip, dev_info_t *rdip,
ddi_intr_handle_impl_t *hdlp);
#pragma weak rootnex_get_intr_pri
int rootnex_name_child_impl(dev_info_t *child, char *name, int namelen);
#pragma weak rootnex_name_child_impl
int rootnex_ctl_initchild_impl(dev_info_t *dip);
#pragma weak rootnex_initchild_impl
void rootnex_ctl_uninitchild_impl(dev_info_t *dip);
#pragma weak rootnex_uninitchild_impl
int rootnex_ctl_reportdev_impl(dev_info_t *dev);
#pragma weak rootnex_reportdev_impl
static struct cb_ops rootnex_cb_ops = {
nodev, /* open */
nodev, /* close */
nodev, /* strategy */
nodev, /* print */
nodev, /* dump */
nodev, /* read */
nodev, /* write */
nodev, /* ioctl */
nodev, /* devmap */
nodev, /* mmap */
nodev, /* segmap */
nochpoll, /* chpoll */
ddi_prop_op, /* cb_prop_op */
NULL, /* struct streamtab */
D_NEW | D_MP | D_HOTPLUG, /* compatibility flags */
CB_REV, /* Rev */
nodev, /* cb_aread */
nodev /* cb_awrite */
};
static struct bus_ops rootnex_bus_ops = {
BUSO_REV,
rootnex_map,
NULL,
NULL,
NULL,
rootnex_map_fault,
ddi_no_dma_map, /* no rootnex_dma_map- now in sysio nexus */
ddi_no_dma_allochdl,
ddi_no_dma_freehdl,
ddi_no_dma_bindhdl,
ddi_no_dma_unbindhdl,
ddi_no_dma_flush,
ddi_no_dma_win,
ddi_no_dma_mctl, /* no rootnex_dma_mctl- now in sysio nexus */
rootnex_ctlops,
ddi_bus_prop_op,
i_ddi_rootnex_get_eventcookie,
i_ddi_rootnex_add_eventcall,
i_ddi_rootnex_remove_eventcall,
i_ddi_rootnex_post_event,
NULL, /* bus_intr_ctl */
NULL, /* bus_config */
NULL, /* bus_unconfig */
rootnex_busop_fminit, /* bus_fm_init */
NULL, /* bus_fm_fini */
NULL, /* bus_fm_access_enter */
NULL, /* bus_fm_access_fini */
NULL, /* bus_power */
rootnex_intr_ops /* bus_intr_op */
};
static int rootnex_attach(dev_info_t *devi, ddi_attach_cmd_t cmd);
static int rootnex_detach(dev_info_t *devi, ddi_detach_cmd_t cmd);
static struct dev_ops rootnex_ops = {
DEVO_REV,
0, /* refcnt */
ddi_no_info, /* info */
nulldev,
nulldev, /* probe */
rootnex_attach,
rootnex_detach,
nodev, /* reset */
&rootnex_cb_ops,
&rootnex_bus_ops,
NULL, /* power */
ddi_quiesce_not_needed, /* quiesce */
};
extern uint_t root_phys_addr_lo_mask;
extern uint_t root_phys_addr_hi_mask;
extern struct mod_ops mod_driverops;
extern struct dev_ops rootnex_ops;
extern struct cpu cpu0;
extern ddi_iblock_cookie_t rootnex_err_ibc;
/*
* Add statically defined root properties to this list...
*/
static const int pagesize = PAGESIZE;
static const int mmu_pagesize = MMU_PAGESIZE;
static const int mmu_pageoffset = MMU_PAGEOFFSET;
struct prop_def {
char *prop_name;
caddr_t prop_value;
};
static struct prop_def root_props[] = {
{ "PAGESIZE", (caddr_t)&pagesize },
{ "MMU_PAGESIZE", (caddr_t)&mmu_pagesize},
{ "MMU_PAGEOFFSET", (caddr_t)&mmu_pageoffset},
};
static vmem_t *rootnex_regspec_arena;
#define NROOT_PROPS (sizeof (root_props) / sizeof (struct prop_def))
/*
* Module linkage information for the kernel.
*/
static struct modldrv modldrv = {
&mod_driverops, /* Type of module. This one is a nexus driver */
"sun4 root nexus",
&rootnex_ops, /* Driver ops */
};
static struct modlinkage modlinkage = {
MODREV_1, (void *)&modldrv, NULL
};
int
_init(void)
{
return (mod_install(&modlinkage));
}
int
_fini(void)
{
return (EBUSY);
}
int
_info(struct modinfo *modinfop)
{
return (mod_info(&modlinkage, modinfop));
}
/*
* rootnex_attach:
*
* attach the root nexus.
*/
static void add_root_props(dev_info_t *);
/*ARGSUSED*/
static int
rootnex_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
{
int length;
char *valuep = NULL;
/*
* Only do these functions when the driver is acting as the
* root nexus, not when it is driving a memory controller.
*/
if (ddi_root_node() == devi) {
rootnex_fm_init(devi);
add_root_props(devi);
i_ddi_rootnex_init_events(devi);
rootnex_regspec_arena = vmem_create("regspec",
(void *)PIOMAPBASE, PIOMAPSIZE, MMU_PAGESIZE, NULL, NULL,
NULL, 0, VM_SLEEP);
}
if (ddi_prop_op(DDI_DEV_T_ANY, devi, PROP_LEN_AND_VAL_ALLOC,
DDI_PROP_DONTPASS, "banner-name", (caddr_t)&valuep,
&length) == DDI_PROP_SUCCESS) {
cmn_err(CE_CONT, "?root nexus = %s\n", valuep);
kmem_free(valuep, length);
}
/*
* Add a no-suspend-resume property so that NDI
* does not attempt to suspend/resume the rootnex
* (or any of its aliases) node.
*/
(void) ddi_prop_update_string(DDI_DEV_T_NONE, devi,
"pm-hardware-state", "no-suspend-resume");
return (DDI_SUCCESS);
}
/*ARGSUSED*/
static int
rootnex_detach(dev_info_t *devi, ddi_detach_cmd_t cmd)
{
return (DDI_SUCCESS);
}
static void
add_root_props(dev_info_t *devi)
{
int i;
struct prop_def *rpp;
/*
* Note that this for loop works because all of the
* properties in root_prop are integers
*/
for (i = 0, rpp = root_props; i < NROOT_PROPS; ++i, ++rpp) {
(void) e_ddi_prop_update_int(DDI_DEV_T_NONE, devi,
rpp->prop_name, *((int *)rpp->prop_value));
}
/*
* Create the root node "boolean" property
* corresponding to addressing type supported in the root node:
*
* Choices are:
* "relative-addressing" (OBP PROMS)
* "generic-addressing" (SunMon -- pseudo OBP/DDI)
*/
(void) e_ddi_prop_update_int(DDI_DEV_T_NONE, devi,
DDI_RELATIVE_ADDRESSING, 1);
/*
* Create fault management capability property
*/
(void) e_ddi_prop_update_int(DDI_DEV_T_NONE, devi, "fm-capable",
ddi_fm_capable(devi));
}
static int
rootnex_map_regspec(ddi_map_req_t *mp, caddr_t *vaddrp, uint_t mapping_attr)
{
uint64_t base;
caddr_t kaddr;
pgcnt_t npages;
pfn_t pfn;
uint_t pgoffset;
struct regspec *rp = mp->map_obj.rp;
ddi_acc_hdl_t *hp;
base = (uint64_t)rp->regspec_addr & (~MMU_PAGEOFFSET); /* base addr */
/*
* Take the bustype and addr and convert it to a
* page frame number.
*/
pfn = mmu_btop(((uint64_t)(rp->regspec_bustype &
root_phys_addr_hi_mask) << 32) | base);
/*
* Do a quick sanity check to make sure we are in I/O space.
*/
if (pf_is_memory(pfn))
return (DDI_ME_INVAL);
if (rp->regspec_size == 0) {
DPRINTF(ROOTNEX_MAP_DEBUG, ("rootnex_map_regspec: zero "
"regspec_size\n"));
return (DDI_ME_INVAL);
}
if (mp->map_flags & DDI_MF_DEVICE_MAPPING)
*vaddrp = (caddr_t)pfn;
else {
pgoffset = (ulong_t)rp->regspec_addr & MMU_PAGEOFFSET;
npages = mmu_btopr(rp->regspec_size + pgoffset);
DPRINTF(ROOTNEX_MAP_DEBUG, ("rootnex_map_regspec: Mapping "
"%lu pages physical %x.%lx ", npages, rp->regspec_bustype,
base));
if ((kaddr = vmem_alloc(rootnex_regspec_arena,
ptob(npages), VM_NOSLEEP)) == NULL)
return (DDI_ME_NORESOURCES);
/*
* Now map in the pages we've allocated...
*/
hat_devload(kas.a_hat, kaddr, ptob(npages), pfn,
mp->map_prot | mapping_attr, HAT_LOAD_LOCK);
*vaddrp = kaddr + pgoffset;
hp = mp->map_handlep;
if (hp) {
hp->ah_pfn = pfn;
hp->ah_pnum = npages;
}
}
DPRINTF(ROOTNEX_MAP_DEBUG, ("at virtual 0x%p\n", (void *)*vaddrp));
return (0);
}
static int
rootnex_unmap_regspec(ddi_map_req_t *mp, caddr_t *vaddrp)
{
caddr_t addr = *vaddrp;
pgcnt_t npages;
uint_t pgoffset;
caddr_t base;
struct regspec *rp;
if (mp->map_flags & DDI_MF_DEVICE_MAPPING)
return (0);
rp = mp->map_obj.rp;
pgoffset = (uintptr_t)addr & MMU_PAGEOFFSET;
if (rp->regspec_size == 0) {
DPRINTF(ROOTNEX_MAP_DEBUG, ("rootnex_unmap_regspec: "
"zero regspec_size\n"));
return (DDI_ME_INVAL);
}
base = addr - pgoffset;
npages = mmu_btopr(rp->regspec_size + pgoffset);
hat_unload(kas.a_hat, base, ptob(npages), HAT_UNLOAD_UNLOCK);
vmem_free(rootnex_regspec_arena, base, ptob(npages));
/*
* Destroy the pointer - the mapping has logically gone
*/
*vaddrp = (caddr_t)0;
return (0);
}
static int
rootnex_map_handle(ddi_map_req_t *mp)
{
ddi_acc_hdl_t *hp;
uint_t hat_flags;
register struct regspec *rp;
/*
* Set up the hat_flags for the mapping.
*/
hp = mp->map_handlep;
switch (hp->ah_acc.devacc_attr_endian_flags) {
case DDI_NEVERSWAP_ACC:
hat_flags = HAT_NEVERSWAP | HAT_STRICTORDER;
break;
case DDI_STRUCTURE_BE_ACC:
hat_flags = HAT_STRUCTURE_BE;
break;
case DDI_STRUCTURE_LE_ACC:
hat_flags = HAT_STRUCTURE_LE;
break;
default:
return (DDI_REGS_ACC_CONFLICT);
}
switch (hp->ah_acc.devacc_attr_dataorder) {
case DDI_STRICTORDER_ACC:
break;
case DDI_UNORDERED_OK_ACC:
hat_flags |= HAT_UNORDERED_OK;
break;
case DDI_MERGING_OK_ACC:
hat_flags |= HAT_MERGING_OK;
break;
case DDI_LOADCACHING_OK_ACC:
hat_flags |= HAT_LOADCACHING_OK;
break;
case DDI_STORECACHING_OK_ACC:
hat_flags |= HAT_STORECACHING_OK;
break;
default:
return (DDI_FAILURE);
}
rp = mp->map_obj.rp;
if (rp->regspec_size == 0)
return (DDI_ME_INVAL);
hp->ah_hat_flags = hat_flags;
hp->ah_pfn = mmu_btop((ulong_t)rp->regspec_addr & (~MMU_PAGEOFFSET));
hp->ah_pnum = mmu_btopr(rp->regspec_size +
(ulong_t)rp->regspec_addr & MMU_PAGEOFFSET);
return (DDI_SUCCESS);
}
static int
rootnex_map(dev_info_t *dip, dev_info_t *rdip, ddi_map_req_t *mp,
off_t offset, off_t len, caddr_t *vaddrp)
{
struct regspec *rp, tmp_reg;
ddi_map_req_t mr = *mp; /* Get private copy of request */
int error;
uint_t mapping_attr;
ddi_acc_hdl_t *hp = NULL;
mp = &mr;
switch (mp->map_op) {
case DDI_MO_MAP_LOCKED:
case DDI_MO_UNMAP:
case DDI_MO_MAP_HANDLE:
break;
default:
DPRINTF(ROOTNEX_MAP_DEBUG, ("rootnex_map: unimplemented map "
"op %d.", mp->map_op));
return (DDI_ME_UNIMPLEMENTED);
}
if (mp->map_flags & DDI_MF_USER_MAPPING) {
DPRINTF(ROOTNEX_MAP_DEBUG, ("rootnex_map: unimplemented map "
"type: user."));
return (DDI_ME_UNIMPLEMENTED);
}
/*
* First, if given an rnumber, convert it to a regspec...
* (Presumably, this is on behalf of a child of the root node?)
*/
if (mp->map_type == DDI_MT_RNUMBER) {
int rnumber = mp->map_obj.rnumber;
rp = i_ddi_rnumber_to_regspec(rdip, rnumber);
if (rp == (struct regspec *)0) {
DPRINTF(ROOTNEX_MAP_DEBUG, ("rootnex_map: Out of "
"range rnumber <%d>, device <%s>", rnumber,
ddi_get_name(rdip)));
return (DDI_ME_RNUMBER_RANGE);
}
/*
* Convert the given ddi_map_req_t from rnumber to regspec...
*/
mp->map_type = DDI_MT_REGSPEC;
mp->map_obj.rp = rp;
}
/*
* Adjust offset and length corresponding to called values...
* XXX: A non-zero length means override the one in the regspec
* XXX: regardless of what's in the parent's range?.
*/
tmp_reg = *(mp->map_obj.rp); /* Preserve underlying data */
rp = mp->map_obj.rp = &tmp_reg; /* Use tmp_reg in request */
rp->regspec_addr += (uint_t)offset;
if (len != 0)
rp->regspec_size = (uint_t)len;
/*
* Apply any parent ranges at this level, if applicable.
* (This is where nexus specific regspec translation takes place.
* Use of this function is implicit agreement that translation is
* provided via ddi_apply_range.)
*/
DPRINTF(ROOTNEX_MAP_DEBUG, ("rootnex_map: applying range of parent "
"<%s> to child <%s>...\n", ddi_get_name(dip), ddi_get_name(rdip)));
if ((error = i_ddi_apply_range(dip, rdip, mp->map_obj.rp)) != 0)
return (error);
switch (mp->map_op) {
case DDI_MO_MAP_LOCKED:
/*
* Set up the locked down kernel mapping to the regspec...
*/
/*
* If we were passed an access handle we need to determine
* the "endian-ness" of the mapping and fill in the handle.
*/
if (mp->map_handlep) {
hp = mp->map_handlep;
switch (hp->ah_acc.devacc_attr_endian_flags) {
case DDI_NEVERSWAP_ACC:
mapping_attr = HAT_NEVERSWAP | HAT_STRICTORDER;
break;
case DDI_STRUCTURE_BE_ACC:
mapping_attr = HAT_STRUCTURE_BE;
break;
case DDI_STRUCTURE_LE_ACC:
mapping_attr = HAT_STRUCTURE_LE;
break;
default:
return (DDI_REGS_ACC_CONFLICT);
}
switch (hp->ah_acc.devacc_attr_dataorder) {
case DDI_STRICTORDER_ACC:
break;
case DDI_UNORDERED_OK_ACC:
mapping_attr |= HAT_UNORDERED_OK;
break;
case DDI_MERGING_OK_ACC:
mapping_attr |= HAT_MERGING_OK;
break;
case DDI_LOADCACHING_OK_ACC:
mapping_attr |= HAT_LOADCACHING_OK;
break;
case DDI_STORECACHING_OK_ACC:
mapping_attr |= HAT_STORECACHING_OK;
break;
default:
return (DDI_REGS_ACC_CONFLICT);
}
} else {
mapping_attr = HAT_NEVERSWAP | HAT_STRICTORDER;
}
/*
* Set up the mapping.
*/
error = rootnex_map_regspec(mp, vaddrp, mapping_attr);
/*
* Fill in the access handle if needed.
*/
if (hp) {
hp->ah_addr = *vaddrp;
hp->ah_hat_flags = mapping_attr;
if (error == 0)
impl_acc_hdl_init(hp);
}
return (error);
case DDI_MO_UNMAP:
/*
* Release mapping...
*/
return (rootnex_unmap_regspec(mp, vaddrp));
case DDI_MO_MAP_HANDLE:
return (rootnex_map_handle(mp));
}
return (DDI_ME_UNIMPLEMENTED);
}
static int
rootnex_intr_ops(dev_info_t *dip, dev_info_t *rdip, ddi_intr_op_t intr_op,
ddi_intr_handle_impl_t *hdlp, void *result)
{
int ret = DDI_SUCCESS;
DPRINTF(ROOTNEX_INTR_DEBUG, ("rootnex_intr_ops: rdip=%s%d "
"intr_op 0x%x hdlp 0x%p\n", ddi_driver_name(rdip),
ddi_get_instance(rdip), intr_op, (void *)hdlp));
switch (intr_op) {
case DDI_INTROP_GETCAP:
*(int *)result = DDI_INTR_FLAG_LEVEL;
break;
case DDI_INTROP_SETCAP:
ret = DDI_ENOTSUP;
break;
case DDI_INTROP_ALLOC:
*(int *)result = hdlp->ih_scratch1;
break;
case DDI_INTROP_FREE:
break;
case DDI_INTROP_GETPRI:
*(int *)result = rootnex_get_intr_pri(dip, rdip, hdlp);
break;
case DDI_INTROP_SETPRI:
break;
case DDI_INTROP_ADDISR:
ret = rootnex_add_intr_impl(dip, rdip, hdlp);
break;
case DDI_INTROP_REMISR:
ret = rootnex_remove_intr_impl(dip, rdip, hdlp);
break;
case DDI_INTROP_ENABLE:
case DDI_INTROP_DISABLE:
break;
case DDI_INTROP_NINTRS:
case DDI_INTROP_NAVAIL:
*(int *)result = i_ddi_get_intx_nintrs(rdip);
break;
case DDI_INTROP_SUPPORTED_TYPES:
/* Root nexus driver supports only fixed interrupts */
*(int *)result = i_ddi_get_intx_nintrs(rdip) ?
DDI_INTR_TYPE_FIXED : 0;
break;
default:
ret = DDI_ENOTSUP;
break;
}
return (ret);
}
/*
* Shorthand defines
*/
#define DMAOBJ_PP_PP dmao_obj.pp_obj.pp_pp
#define DMAOBJ_PP_OFF dmao_ogj.pp_obj.pp_offset
#define ALO dma_lim->dlim_addr_lo
#define AHI dma_lim->dlim_addr_hi
#define OBJSIZE dmareq->dmar_object.dmao_size
#define ORIGVADDR dmareq->dmar_object.dmao_obj.virt_obj.v_addr
#define RED ((mp->dmai_rflags & DDI_DMA_REDZONE)? 1 : 0)
#define DIRECTION (mp->dmai_rflags & DDI_DMA_RDWR)
/*
* rootnex_map_fault:
*
* fault in mappings for requestors
*/
/*ARGSUSED*/
static int
rootnex_map_fault(dev_info_t *dip, dev_info_t *rdip,
struct hat *hat, struct seg *seg, caddr_t addr,
struct devpage *dp, pfn_t pfn, uint_t prot, uint_t lock)
{
extern struct seg_ops segdev_ops;
DPRINTF(ROOTNEX_MAP_DEBUG, ("rootnex_map_fault: address <%p> "
"pfn <%lx>", (void *)addr, pfn));
DPRINTF(ROOTNEX_MAP_DEBUG, (" Seg <%s>\n",
seg->s_ops == &segdev_ops ? "segdev" :
seg == &kvseg ? "segkmem" : "NONE!"));
/*
* This is all terribly broken, but it is a start
*
* XXX Note that this test means that segdev_ops
* must be exported from seg_dev.c.
* XXX What about devices with their own segment drivers?
*/
if (seg->s_ops == &segdev_ops) {
register struct segdev_data *sdp =
(struct segdev_data *)seg->s_data;
if (hat == NULL) {
/*
* This is one plausible interpretation of
* a null hat i.e. use the first hat on the
* address space hat list which by convention is
* the hat of the system MMU. At alternative
* would be to panic .. this might well be better ..
*/
ASSERT(AS_READ_HELD(seg->s_as));
hat = seg->s_as->a_hat;
cmn_err(CE_NOTE, "rootnex_map_fault: nil hat");
}
hat_devload(hat, addr, MMU_PAGESIZE, pfn, prot | sdp->hat_attr,
(lock ? HAT_LOAD_LOCK : HAT_LOAD));
} else if (seg == &kvseg && dp == (struct devpage *)0) {
hat_devload(kas.a_hat, addr, MMU_PAGESIZE, pfn, prot,
HAT_LOAD_LOCK);
} else
return (DDI_FAILURE);
return (DDI_SUCCESS);
}
/*
* Name a child of rootnex
*
* This may be called multiple times, independent of initchild calls.
*/
int
rootnex_name_child(dev_info_t *child, char *name, int namelen)
{
return (rootnex_name_child_impl(child, name, namelen));
}
static int
rootnex_ctl_initchild(dev_info_t *dip)
{
return (rootnex_ctl_initchild_impl(dip));
}
int
rootnex_ctl_uninitchild(dev_info_t *dip)
{
extern void impl_free_ddi_ppd(dev_info_t *);
rootnex_ctl_uninitchild_impl(dip);
/*
* strip properties and convert node to prototype form
*/
impl_free_ddi_ppd(dip);
ddi_set_name_addr(dip, NULL);
impl_rem_dev_props(dip);
return (DDI_SUCCESS);
}
static int
rootnex_ctl_reportdev(dev_info_t *dev)
{
return (rootnex_ctl_reportdev_impl(dev));
}
static int
rootnex_ctlops_peekpoke(ddi_ctl_enum_t cmd, peekpoke_ctlops_t *in_args,
void *result)
{
int err = DDI_SUCCESS;
on_trap_data_t otd;
/* No safe access except for peek/poke is supported. */
if (in_args->handle != NULL)
return (DDI_FAILURE);
/* Set up protected environment. */
if (!on_trap(&otd, OT_DATA_ACCESS)) {
uintptr_t tramp = otd.ot_trampoline;
if (cmd == DDI_CTLOPS_POKE) {
otd.ot_trampoline = (uintptr_t)&poke_fault;
err = do_poke(in_args->size, (void *)in_args->dev_addr,
(void *)in_args->host_addr);
} else {
otd.ot_trampoline = (uintptr_t)&peek_fault;
err = do_peek(in_args->size, (void *)in_args->dev_addr,
(void *)in_args->host_addr);
result = (void *)in_args->host_addr;
}
otd.ot_trampoline = tramp;
} else
err = DDI_FAILURE;
/* Take down protected environment. */
no_trap();
return (err);
}
/*ARGSUSED*/
static int
rootnex_ctlops(dev_info_t *dip, dev_info_t *rdip,
ddi_ctl_enum_t ctlop, void *arg, void *result)
{
register int n, *ptr;
register struct ddi_parent_private_data *pdp;
static boolean_t reserved_msg_printed = B_FALSE;
switch (ctlop) {
case DDI_CTLOPS_DMAPMAPC:
return (DDI_FAILURE);
case DDI_CTLOPS_BTOP:
/*
* Convert byte count input to physical page units.
* (byte counts that are not a page-size multiple
* are rounded down)
*/
*(ulong_t *)result = btop(*(ulong_t *)arg);
return (DDI_SUCCESS);
case DDI_CTLOPS_PTOB:
/*
* Convert size in physical pages to bytes
*/
*(ulong_t *)result = ptob(*(ulong_t *)arg);
return (DDI_SUCCESS);
case DDI_CTLOPS_BTOPR:
/*
* Convert byte count input to physical page units
* (byte counts that are not a page-size multiple
* are rounded up)
*/
*(ulong_t *)result = btopr(*(ulong_t *)arg);
return (DDI_SUCCESS);
case DDI_CTLOPS_INITCHILD:
return (rootnex_ctl_initchild((dev_info_t *)arg));
case DDI_CTLOPS_UNINITCHILD:
return (rootnex_ctl_uninitchild((dev_info_t *)arg));
case DDI_CTLOPS_REPORTDEV:
return (rootnex_ctl_reportdev(rdip));
case DDI_CTLOPS_IOMIN:
/*
* Nothing to do here but reflect back..
*/
return (DDI_SUCCESS);
case DDI_CTLOPS_REGSIZE:
case DDI_CTLOPS_NREGS:
break;
case DDI_CTLOPS_SIDDEV:
if (ndi_dev_is_prom_node(rdip))
return (DDI_SUCCESS);
if (ndi_dev_is_persistent_node(rdip))
return (DDI_SUCCESS);
return (DDI_FAILURE);
case DDI_CTLOPS_POWER: {
return ((*pm_platform_power)((power_req_t *)arg));
}
case DDI_CTLOPS_RESERVED0: /* Was DDI_CTLOPS_NINTRS, obsolete */
case DDI_CTLOPS_RESERVED1: /* Was DDI_CTLOPS_POKE_INIT, obsolete */
case DDI_CTLOPS_RESERVED2: /* Was DDI_CTLOPS_POKE_FLUSH, obsolete */
case DDI_CTLOPS_RESERVED3: /* Was DDI_CTLOPS_POKE_FINI, obsolete */
case DDI_CTLOPS_RESERVED4: /* Was DDI_CTLOPS_INTR_HILEVEL, obsolete */
case DDI_CTLOPS_RESERVED5: /* Was DDI_CTLOPS_XLATE_INTRS, obsolete */
if (!reserved_msg_printed) {
reserved_msg_printed = B_TRUE;
cmn_err(CE_WARN, "Failing ddi_ctlops call(s) for "
"1 or more reserved/obsolete operations.");
}
return (DDI_FAILURE);
case DDI_CTLOPS_POKE:
case DDI_CTLOPS_PEEK:
return (rootnex_ctlops_peekpoke(ctlop, (peekpoke_ctlops_t *)arg,
result));
default:
return (DDI_FAILURE);
}
/*
* The rest are for "hardware" properties
*/
if ((pdp = ddi_get_parent_data(rdip)) == NULL)
return (DDI_FAILURE);
if (ctlop == DDI_CTLOPS_NREGS) {
ptr = (int *)result;
*ptr = pdp->par_nreg;
} else { /* ctlop == DDI_CTLOPS_REGSIZE */
off_t *size = (off_t *)result;
ptr = (int *)arg;
n = *ptr;
if (n >= pdp->par_nreg) {
return (DDI_FAILURE);
}
*size = (off_t)pdp->par_reg[n].regspec_size;
}
return (DDI_SUCCESS);
}
/* ARGSUSED */
int
rootnex_busop_fminit(dev_info_t *dip, dev_info_t *tdip, int cap,
ddi_iblock_cookie_t *ibc)
{
*ibc = rootnex_err_ibc;
return (ddi_system_fmcap | DDI_FM_ACCCHK_CAPABLE |
DDI_FM_DMACHK_CAPABLE);
}
static void
rootnex_fm_init(dev_info_t *dip)
{
int fmcap;
/* Minimum fm capability level for sun4u platforms */
ddi_system_fmcap = DDI_FM_EREPORT_CAPABLE | DDI_FM_ERRCB_CAPABLE;
fmcap = ddi_system_fmcap;
/*
* Initialize ECC error handling
*/
rootnex_err_ibc = (ddi_iblock_cookie_t)PIL_15;
ddi_fm_init(dip, &fmcap, &rootnex_err_ibc);
}