自学教程：C++ DEVTONX函数代码示例

static struct resource_list *nexus_get_reslist(device_t dev, device_t child){	struct nexus_device *ndev = DEVTONX(child);	return (&ndev->nx_resources);}

static voidnexus_delete_resource(device_t dev, device_t child, int type, int rid){	struct nexus_device	*ndev = DEVTONX(child);	struct resource_list	*rl = &ndev->nx_resources;	resource_list_delete(rl, type, rid);}

/* * Allocate a resource on behalf of child.  NB: child is usually going to be a * child of one of our descendants, not a direct child of nexus0. * (Exceptions include footbridge.) */static struct resource *nexus_alloc_resource(device_t bus, device_t child, int type, int *rid,    rman_res_t start, rman_res_t end, rman_res_t count, u_int flags){	struct nexus_device *ndev = DEVTONX(child);	struct resource *rv;	struct resource_list_entry *rle;	struct rman *rm;	int needactivate = flags & RF_ACTIVE;	/*	 * If this is an allocation of the "default" range for a given	 * RID, and we know what the resources for this device are	 * (ie. they aren't maintained by a child bus), then work out	 * the start/end values.	 */	if (RMAN_IS_DEFAULT_RANGE(start, end) && (count == 1)) {		if (device_get_parent(child) != bus || ndev == NULL)			return(NULL);		rle = resource_list_find(&ndev->nx_resources, type, *rid);		if (rle == NULL)			return(NULL);		start = rle->start;		end = rle->end;		count = rle->count;	}	switch (type) {	case SYS_RES_IRQ:		rm = &irq_rman;		break;	case SYS_RES_MEMORY:	case SYS_RES_IOPORT:		rm = &mem_rman;		break;	default:		return (NULL);	}	rv = rman_reserve_resource(rm, start, end, count, flags, child);	if (rv == NULL)		return (NULL);	rman_set_rid(rv, *rid);	rman_set_bushandle(rv, rman_get_start(rv));	if (needactivate) {		if (bus_activate_resource(child, type, *rid, rv)) {			rman_release_resource(rv);			return (NULL);		}	}	return (rv);}

static intnexus_set_resource(device_t dev, device_t child, int type, int rid, u_long start, u_long count){	struct nexus_device	*ndev = DEVTONX(child);	struct resource_list	*rl = &ndev->nx_resources;	/* XXX this should return a success/failure indicator */	resource_list_add(rl, type, rid, start, start + count - 1, count);	return(0);}

static intnexus_write_ivar(device_t dev, device_t child, int which, uintptr_t value){	struct nexus_device *ndev = DEVTONX(child);		switch (which) {	case NEXUS_IVAR_PCIBUS:		ndev->nx_pcibus = value;		break;	default:		return ENOENT;	}	return 0;}

static intnexus_read_ivar(device_t dev, device_t child, int which, uintptr_t *result){	struct nexus_device *ndev = DEVTONX(child);		switch (which) {	case NEXUS_IVAR_PCIBUS:		*result = ndev->nx_pcibus;		break;	default:		return ENOENT;	}	return 0;}

static intnexus_print_child(device_t bus, device_t child){	struct	nexus_device *ndev = DEVTONX(child);	int retval = 0;	retval += bus_print_child_header(bus, child);	retval += nexus_print_all_resources(child);	if (ndev->nx_pcibus != -1)		retval += kprintf(" pcibus %d", ndev->nx_pcibus);	retval += kprintf(" on motherboard/n");	return (retval);}

static intnexus_print_all_resources(device_t dev){	struct	nexus_device *ndev = DEVTONX(dev);	struct resource_list *rl = &ndev->nx_resources;	int retval = 0;	if (SLIST_FIRST(rl) || ndev->nx_pcibus != -1)		retval += kprintf(" at");		retval += resource_list_print_type(rl, "port", SYS_RES_IOPORT, "%#lx");	retval += resource_list_print_type(rl, "iomem", SYS_RES_MEMORY, "%#lx");	retval += resource_list_print_type(rl, "irq", SYS_RES_IRQ, "%ld");	return retval;}

static intnexus_get_resource(device_t dev, device_t child, int type, int rid, u_long *startp, u_long *countp){	struct nexus_device	*ndev = DEVTONX(child);	struct resource_list	*rl = &ndev->nx_resources;	struct resource_list_entry *rle;	rle = resource_list_find(rl, type, rid);	if (!rle)		return(ENOENT);	if (startp)		*startp = rle->start;	if (countp)		*countp = rle->count;	return(0);}

/* * Allocate a resource on behalf of child.  NB: child is usually going to be a * child of one of our descendants, not a direct child of nexus0. * (Exceptions include npx.) */static struct resource *nexus_alloc_resource(device_t bus, device_t child, int type, int *rid,		     rman_res_t start, rman_res_t end, rman_res_t count,		     u_int flags){	struct nexus_device *ndev = DEVTONX(child);	struct	resource *rv;	struct resource_list_entry *rle;	struct	rman *rm;	int needactivate = flags & RF_ACTIVE;	/*	 * If this is an allocation of the "default" range for a given	 * RID, and we know what the resources for this device are	 * (ie. they aren't maintained by a child bus), then work out	 * the start/end values.	 */	if ((start == 0UL) && (end == ~0UL) && (count == 1)) {		if (device_get_parent(child) != bus || ndev == NULL)			return(NULL);		rle = resource_list_find(&ndev->nx_resources, type, *rid);		if (rle == NULL)			return(NULL);		start = rle->start;		end = rle->end;		count = rle->count;	}	flags &= ~RF_ACTIVE;	rm = nexus_rman(type);	if (rm == NULL)		return (NULL);	rv = rman_reserve_resource(rm, start, end, count, flags, child);	if (rv == 0)		return 0;	rman_set_rid(rv, *rid);	if (needactivate) {		if (bus_activate_resource(child, type, *rid, rv)) {			rman_release_resource(rv);			return 0;		}	}	return rv;}

static intnexus_print_child(device_t bus, device_t child){	struct nexus_device *ndev = DEVTONX(child);	struct resource_list *rl = &ndev->nx_resources;	int retval = 0;	retval += bus_print_child_header(bus, child);	retval += resource_list_print_type(rl, "port", SYS_RES_IOPORT, "%#lx");	retval += resource_list_print_type(rl, "iomem", SYS_RES_MEMORY, "%#lx");	retval += resource_list_print_type(rl, "irq", SYS_RES_IRQ, "%ld");	if (ndev->nx_pcibus != -1)		retval += printf(" pcibus %d", ndev->nx_pcibus);	if (device_get_flags(child))		retval += printf(" flags %#x", device_get_flags(child));	retval += printf(" on motherboard/n");	/* XXX "motherboard", ick */	return (retval);}

/* * Allocate a resource on behalf of child.  NB: child is usually going to be a * child of one of our descendants, not a direct child of nexus0. * (Exceptions include npx.) */static struct resource *nexus_alloc_resource(device_t bus, device_t child, int type, int *rid,    u_long start, u_long end, u_long count, u_int flags, int cpuid){	struct nexus_device *ndev = DEVTONX(child);	struct	resource *rv;	struct resource_list_entry *rle;	struct	rman *rm;	int needactivate = flags & RF_ACTIVE;	/*	 * If this is an allocation of the "default" range for a given RID, and	 * we know what the resources for this device are (ie. they aren't maintained	 * by a child bus), then work out the start/end values.	 */	if ((start == 0UL) && (end == ~0UL) && (count == 1)) {		if (ndev == NULL)			return(NULL);		rle = resource_list_find(&ndev->nx_resources, type, *rid);		if (rle == NULL)			return(NULL);		start = rle->start;		end = rle->end;		count = rle->count;		cpuid = rle->cpuid;	}	flags &= ~RF_ACTIVE;	switch (type) {	case SYS_RES_IRQ:		KASSERT(cpuid >= 0 && cpuid < ncpus,		    ("nexus invalid cpuid %d:/n", cpuid));		rm = &irq_rman[cpuid];		break;	case SYS_RES_DRQ:		rm = &drq_rman;		break;	case SYS_RES_IOPORT:		rm = &port_rman;		break;	case SYS_RES_MEMORY:		rm = &mem_rman;		break;	default:		return 0;	}	rv = rman_reserve_resource(rm, start, end, count, flags, child);	if (rv == 0)		return 0;	rman_set_rid(rv, *rid);	if (type == SYS_RES_MEMORY) {		rman_set_bustag(rv, I386_BUS_SPACE_MEM);	} else if (type == SYS_RES_IOPORT) {		rman_set_bustag(rv, I386_BUS_SPACE_IO);		rman_set_bushandle(rv, rv->r_start);	}	if (needactivate) {		if (bus_activate_resource(child, type, *rid, rv)) {			rman_release_resource(rv);			return 0;		}	}		return rv;}

/* * Allocate a resource on behalf of child.  NB: child is usually going to be a * child of one of our descendants, not a direct child of nexus0. * (Exceptions include npx.) */static struct resource *nexus_alloc_resource(device_t bus, device_t child, int type, int *rid,		     u_long start, u_long end, u_long count, u_int flags){	struct nexus_device *ndev = DEVTONX(child);	struct	resource *rv;	struct resource_list_entry *rle;	struct	rman *rm;	int needactivate = flags & RF_ACTIVE;	/*	 * If this is an allocation of the "default" range for a given RID, and	 * we know what the resources for this device are (ie. they aren't maintained	 * by a child bus), then work out the start/end values.	 */	if ((start == 0UL) && (end == ~0UL) && (count == 1)) {		if (ndev == NULL)			return(NULL);		rle = resource_list_find(&ndev->nx_resources, type, *rid);		if (rle == NULL)			return(NULL);		start = rle->start;		end = rle->end;		count = rle->count;	}	flags &= ~RF_ACTIVE;	switch (type) {	case SYS_RES_IRQ:		rm = &irq_rman;		break;	case SYS_RES_DRQ:		rm = &drq_rman;		break;	case SYS_RES_IOPORT:		rm = &port_rman;		break;	case SYS_RES_MEMORY:		rm = &mem_rman;		break;	default:		return 0;	}	rv = rman_reserve_resource(rm, start, end, count, flags, child);	if (rv == 0)		return 0;	if (type == SYS_RES_MEMORY) {		rman_set_bustag(rv, I386_BUS_SPACE_MEM);	} else if (type == SYS_RES_IOPORT) {		rman_set_bustag(rv, I386_BUS_SPACE_IO);#ifndef PC98		rman_set_bushandle(rv, rv->r_start);#endif	}#ifdef PC98	if ((type == SYS_RES_MEMORY || type == SYS_RES_IOPORT) &&	    i386_bus_space_handle_alloc(rv->r_bustag, rv->r_start, count,					&rv->r_bushandle) != 0) {		rman_release_resource(rv);		return 0;	}#endif	if (needactivate) {		if (bus_activate_resource(child, type, *rid, rv)) {#ifdef PC98			if (type == SYS_RES_MEMORY || type == SYS_RES_IOPORT) {				i386_bus_space_handle_free(rv->r_bustag,				    rv->r_bushandle, rv->r_bushandle->bsh_sz);			}#endif			rman_release_resource(rv);			return 0;		}	}		return rv;}