/* * This file is subject to the terms and conditions of the GNU General Public * License. See the file "COPYING" in the main directory of this archive * for more details. * * Copyright (c) 1992-1997,2000-2003 Silicon Graphics, Inc. All rights reserved. */ #include #include #include #include #include #include #include #include #include #include #include #include #include /* * Implement io channel provider operations. The xtalk* layer provides a * platform-independent interface for io channel devices. This layer * switches among the possible implementations of a io channel adapter. * * On platforms with only one possible xtalk provider, macros can be * set up at the top that cause the table lookups and indirections to * completely disappear. */ char widget_info_fingerprint[] = "widget_info"; /* ===================================================================== * Function Table of Contents */ xtalk_piomap_t xtalk_piomap_alloc(vertex_hdl_t, device_desc_t, iopaddr_t, size_t, size_t, unsigned); void xtalk_piomap_free(xtalk_piomap_t); caddr_t xtalk_piomap_addr(xtalk_piomap_t, iopaddr_t, size_t); void xtalk_piomap_done(xtalk_piomap_t); caddr_t xtalk_piotrans_addr(vertex_hdl_t, device_desc_t, iopaddr_t, size_t, unsigned); caddr_t xtalk_pio_addr(vertex_hdl_t, device_desc_t, iopaddr_t, size_t, xtalk_piomap_t *, unsigned); void xtalk_set_early_piotrans_addr(xtalk_early_piotrans_addr_f *); caddr_t xtalk_early_piotrans_addr(xwidget_part_num_t, xwidget_mfg_num_t, int, iopaddr_t, size_t, unsigned); static caddr_t null_xtalk_early_piotrans_addr(xwidget_part_num_t, xwidget_mfg_num_t, int, iopaddr_t, size_t, unsigned); xtalk_dmamap_t xtalk_dmamap_alloc(vertex_hdl_t, device_desc_t, size_t, unsigned); void xtalk_dmamap_free(xtalk_dmamap_t); iopaddr_t xtalk_dmamap_addr(xtalk_dmamap_t, paddr_t, size_t); void xtalk_dmamap_done(xtalk_dmamap_t); iopaddr_t xtalk_dmatrans_addr(vertex_hdl_t, device_desc_t, paddr_t, size_t, unsigned); void xtalk_dmamap_drain(xtalk_dmamap_t); void xtalk_dmaaddr_drain(vertex_hdl_t, iopaddr_t, size_t); xtalk_intr_t xtalk_intr_alloc(vertex_hdl_t, device_desc_t, vertex_hdl_t); xtalk_intr_t xtalk_intr_alloc_nothd(vertex_hdl_t, device_desc_t, vertex_hdl_t); void xtalk_intr_free(xtalk_intr_t); int xtalk_intr_connect(xtalk_intr_t, intr_func_t, intr_arg_t, xtalk_intr_setfunc_t, void *); void xtalk_intr_disconnect(xtalk_intr_t); vertex_hdl_t xtalk_intr_cpu_get(xtalk_intr_t); int xtalk_error_handler(vertex_hdl_t, int, ioerror_mode_t, ioerror_t *); void xtalk_provider_startup(vertex_hdl_t); void xtalk_provider_shutdown(vertex_hdl_t); vertex_hdl_t xtalk_intr_dev_get(xtalk_intr_t); xwidgetnum_t xtalk_intr_target_get(xtalk_intr_t); xtalk_intr_vector_t xtalk_intr_vector_get(xtalk_intr_t); iopaddr_t xtalk_intr_addr_get(struct xtalk_intr_s *); void *xtalk_intr_sfarg_get(xtalk_intr_t); vertex_hdl_t xtalk_pio_dev_get(xtalk_piomap_t); xwidgetnum_t xtalk_pio_target_get(xtalk_piomap_t); iopaddr_t xtalk_pio_xtalk_addr_get(xtalk_piomap_t); ulong xtalk_pio_mapsz_get(xtalk_piomap_t); caddr_t xtalk_pio_kvaddr_get(xtalk_piomap_t); vertex_hdl_t xtalk_dma_dev_get(xtalk_dmamap_t); xwidgetnum_t xtalk_dma_target_get(xtalk_dmamap_t); xwidget_info_t xwidget_info_chk(vertex_hdl_t); xwidget_info_t xwidget_info_get(vertex_hdl_t); void xwidget_info_set(vertex_hdl_t, xwidget_info_t); vertex_hdl_t xwidget_info_dev_get(xwidget_info_t); xwidgetnum_t xwidget_info_id_get(xwidget_info_t); vertex_hdl_t xwidget_info_master_get(xwidget_info_t); xwidgetnum_t xwidget_info_masterid_get(xwidget_info_t); xwidget_part_num_t xwidget_info_part_num_get(xwidget_info_t); xwidget_mfg_num_t xwidget_info_mfg_num_get(xwidget_info_t); char *xwidget_info_name_get(xwidget_info_t); void xtalk_provider_register(vertex_hdl_t, xtalk_provider_t *); void xtalk_provider_unregister(vertex_hdl_t); xtalk_provider_t *xtalk_provider_fns_get(vertex_hdl_t); int xwidget_driver_register(xwidget_part_num_t, xwidget_mfg_num_t, char *, unsigned); void xwidget_driver_unregister(char *); int xwidget_register(xwidget_hwid_t, vertex_hdl_t, xwidgetnum_t, vertex_hdl_t, xwidgetnum_t); int xwidget_unregister(vertex_hdl_t); void xwidget_reset(vertex_hdl_t); char *xwidget_name_get(vertex_hdl_t); #if !defined(DEV_FUNC) /* * There is more than one possible provider * for this platform. We need to examine the * master vertex of the current vertex for * a provider function structure, and indirect * through the appropriately named member. */ #define DEV_FUNC(dev,func) xwidget_to_provider_fns(dev)->func #define CAST_PIOMAP(x) ((xtalk_piomap_t)(x)) #define CAST_DMAMAP(x) ((xtalk_dmamap_t)(x)) #define CAST_INTR(x) ((xtalk_intr_t)(x)) xtalk_provider_t * xwidget_info_pops_get(xwidget_info_t info); static xtalk_provider_t * xwidget_to_provider_fns(vertex_hdl_t xconn) { xwidget_info_t widget_info; xtalk_provider_t *provider_fns; widget_info = xwidget_info_get(xconn); ASSERT(widget_info != NULL); provider_fns = xwidget_info_pops_get(widget_info); ASSERT(provider_fns != NULL); return (provider_fns); } xtalk_provider_t * xwidget_info_pops_get(xwidget_info_t info) { vertex_hdl_t master = info->w_master; xtalk_provider_t *provider_fns; provider_fns = xtalk_provider_fns_get(master); ASSERT(provider_fns != NULL); return provider_fns; } #endif /* * Many functions are not passed their vertex * information directly; rather, they must * dive through a resource map. These macros * are available to coordinate this detail. */ #define PIOMAP_FUNC(map,func) DEV_FUNC(map->xp_dev,func) #define DMAMAP_FUNC(map,func) DEV_FUNC(map->xd_dev,func) #define INTR_FUNC(intr,func) DEV_FUNC(intr_hdl->xi_dev,func) /* ===================================================================== * PIO MANAGEMENT * * For mapping system virtual address space to * xtalk space on a specified widget */ xtalk_piomap_t xtalk_piomap_alloc(vertex_hdl_t dev, /* set up mapping for this device */ device_desc_t dev_desc, /* device descriptor */ iopaddr_t xtalk_addr, /* map for this xtalk_addr range */ size_t byte_count, size_t byte_count_max, /* maximum size of a mapping */ unsigned flags) { /* defined in sys/pio.h */ return (xtalk_piomap_t) DEV_FUNC(dev, piomap_alloc) (dev, dev_desc, xtalk_addr, byte_count, byte_count_max, flags); } void xtalk_piomap_free(xtalk_piomap_t xtalk_piomap) { PIOMAP_FUNC(xtalk_piomap, piomap_free) (CAST_PIOMAP(xtalk_piomap)); } caddr_t xtalk_piomap_addr(xtalk_piomap_t xtalk_piomap, /* mapping resources */ iopaddr_t xtalk_addr, /* map for this xtalk address */ size_t byte_count) { /* map this many bytes */ return PIOMAP_FUNC(xtalk_piomap, piomap_addr) (CAST_PIOMAP(xtalk_piomap), xtalk_addr, byte_count); } void xtalk_piomap_done(xtalk_piomap_t xtalk_piomap) { PIOMAP_FUNC(xtalk_piomap, piomap_done) (CAST_PIOMAP(xtalk_piomap)); } caddr_t xtalk_piotrans_addr(vertex_hdl_t dev, /* translate for this device */ device_desc_t dev_desc, /* device descriptor */ iopaddr_t xtalk_addr, /* Crosstalk address */ size_t byte_count, /* map this many bytes */ unsigned flags) { /* (currently unused) */ return DEV_FUNC(dev, piotrans_addr) (dev, dev_desc, xtalk_addr, byte_count, flags); } caddr_t xtalk_pio_addr(vertex_hdl_t dev, /* translate for this device */ device_desc_t dev_desc, /* device descriptor */ iopaddr_t addr, /* starting address (or offset in window) */ size_t byte_count, /* map this many bytes */ xtalk_piomap_t *mapp, /* where to return the map pointer */ unsigned flags) { /* PIO flags */ xtalk_piomap_t map = 0; caddr_t res; if (mapp) *mapp = 0; /* record "no map used" */ res = xtalk_piotrans_addr (dev, dev_desc, addr, byte_count, flags); if (res) return res; /* xtalk_piotrans worked */ map = xtalk_piomap_alloc (dev, dev_desc, addr, byte_count, byte_count, flags); if (!map) return res; /* xtalk_piomap_alloc failed */ res = xtalk_piomap_addr (map, addr, byte_count); if (!res) { xtalk_piomap_free(map); return res; /* xtalk_piomap_addr failed */ } if (mapp) *mapp = map; /* pass back map used */ return res; /* xtalk_piomap_addr succeeded */ } /* ===================================================================== * EARLY PIOTRANS SUPPORT * * There are places where drivers (mgras, for instance) * need to get PIO translations before the infrastructure * is extended to them (setting up textports, for * instance). These drivers should call * xtalk_early_piotrans_addr with their xtalk ID * information, a sequence number (so we can use the second * mgras for instance), and the usual piotrans parameters. * * Machine specific code should provide an implementation * of early_piotrans_addr, and present a pointer to this * function to xtalk_set_early_piotrans_addr so it can be * used by clients without the clients having to know what * platform or what xtalk provider is in use. */ static xtalk_early_piotrans_addr_f null_xtalk_early_piotrans_addr; xtalk_early_piotrans_addr_f *impl_early_piotrans_addr = null_xtalk_early_piotrans_addr; /* xtalk_set_early_piotrans_addr: * specify the early_piotrans_addr implementation function. */ void xtalk_set_early_piotrans_addr(xtalk_early_piotrans_addr_f *impl) { impl_early_piotrans_addr = impl; } /* xtalk_early_piotrans_addr: * figure out a PIO address for the "nth" io channel widget that * matches the specified part and mfgr number. Returns NULL if * there is no such widget, or if the requested mapping can not * be constructed. * Limitations on which io channel slots (and busses) are * checked, and definitions of the ordering of the search across * the io channel slots, are defined by the platform. */ caddr_t xtalk_early_piotrans_addr(xwidget_part_num_t part_num, xwidget_mfg_num_t mfg_num, int which, iopaddr_t xtalk_addr, size_t byte_count, unsigned flags) { return impl_early_piotrans_addr (part_num, mfg_num, which, xtalk_addr, byte_count, flags); } /* null_xtalk_early_piotrans_addr: * used as the early_piotrans_addr implementation until and * unless a real implementation is provided. In DEBUG kernels, * we want to know who is calling before the implementation is * registered; in non-DEBUG kernels, return NULL representing * lack of mapping support. */ /*ARGSUSED */ static caddr_t null_xtalk_early_piotrans_addr(xwidget_part_num_t part_num, xwidget_mfg_num_t mfg_num, int which, iopaddr_t xtalk_addr, size_t byte_count, unsigned flags) { #if DEBUG panic("null_xtalk_early_piotrans_addr"); #endif return NULL; } /* ===================================================================== * DMA MANAGEMENT * * For mapping from io channel space to system * physical space. */ xtalk_dmamap_t xtalk_dmamap_alloc(vertex_hdl_t dev, /* set up mappings for this device */ device_desc_t dev_desc, /* device descriptor */ size_t byte_count_max, /* max size of a mapping */ unsigned flags) { /* defined in dma.h */ return (xtalk_dmamap_t) DEV_FUNC(dev, dmamap_alloc) (dev, dev_desc, byte_count_max, flags); } void xtalk_dmamap_free(xtalk_dmamap_t xtalk_dmamap) { DMAMAP_FUNC(xtalk_dmamap, dmamap_free) (CAST_DMAMAP(xtalk_dmamap)); } iopaddr_t xtalk_dmamap_addr(xtalk_dmamap_t xtalk_dmamap, /* use these mapping resources */ paddr_t paddr, /* map for this address */ size_t byte_count) { /* map this many bytes */ return DMAMAP_FUNC(xtalk_dmamap, dmamap_addr) (CAST_DMAMAP(xtalk_dmamap), paddr, byte_count); } void xtalk_dmamap_done(xtalk_dmamap_t xtalk_dmamap) { DMAMAP_FUNC(xtalk_dmamap, dmamap_done) (CAST_DMAMAP(xtalk_dmamap)); } iopaddr_t xtalk_dmatrans_addr(vertex_hdl_t dev, /* translate for this device */ device_desc_t dev_desc, /* device descriptor */ paddr_t paddr, /* system physical address */ size_t byte_count, /* length */ unsigned flags) { /* defined in dma.h */ return DEV_FUNC(dev, dmatrans_addr) (dev, dev_desc, paddr, byte_count, flags); } void xtalk_dmamap_drain(xtalk_dmamap_t map) { DMAMAP_FUNC(map, dmamap_drain) (CAST_DMAMAP(map)); } void xtalk_dmaaddr_drain(vertex_hdl_t dev, paddr_t addr, size_t size) { DEV_FUNC(dev, dmaaddr_drain) (dev, addr, size); } /* ===================================================================== * INTERRUPT MANAGEMENT * * Allow io channel devices to establish interrupts */ /* * Allocate resources required for an interrupt as specified in intr_desc. * Return resource handle in intr_hdl. */ xtalk_intr_t xtalk_intr_alloc(vertex_hdl_t dev, /* which Crosstalk device */ device_desc_t dev_desc, /* device descriptor */ vertex_hdl_t owner_dev) { /* owner of this interrupt */ return (xtalk_intr_t) DEV_FUNC(dev, intr_alloc) (dev, dev_desc, owner_dev); } /* * Allocate resources required for an interrupt as specified in dev_desc. * Unconditionally setup resources to be non-threaded. * Return resource handle in intr_hdl. */ xtalk_intr_t xtalk_intr_alloc_nothd(vertex_hdl_t dev, /* which Crosstalk device */ device_desc_t dev_desc, /* device descriptor */ vertex_hdl_t owner_dev) /* owner of this interrupt */ { return (xtalk_intr_t) DEV_FUNC(dev, intr_alloc_nothd) (dev, dev_desc, owner_dev); } /* * Free resources consumed by intr_alloc. */ void xtalk_intr_free(xtalk_intr_t intr_hdl) { INTR_FUNC(intr_hdl, intr_free) (CAST_INTR(intr_hdl)); } /* * Associate resources allocated with a previous xtalk_intr_alloc call with the * described handler, arg, name, etc. * * Returns 0 on success, returns <0 on failure. */ int xtalk_intr_connect(xtalk_intr_t intr_hdl, /* xtalk intr resource handle */ intr_func_t intr_func, /* xtalk intr handler */ intr_arg_t intr_arg, /* arg to intr handler */ xtalk_intr_setfunc_t setfunc, /* func to set intr hw */ void *setfunc_arg) /* arg to setfunc */ { return INTR_FUNC(intr_hdl, intr_connect) (CAST_INTR(intr_hdl), intr_func, intr_arg, setfunc, setfunc_arg); } /* * Disassociate handler with the specified interrupt. */ void xtalk_intr_disconnect(xtalk_intr_t intr_hdl) { INTR_FUNC(intr_hdl, intr_disconnect) (CAST_INTR(intr_hdl)); } /* * Return a hwgraph vertex that represents the CPU currently * targeted by an interrupt. */ vertex_hdl_t xtalk_intr_cpu_get(xtalk_intr_t intr_hdl) { return (vertex_hdl_t)0; } /* * ===================================================================== * ERROR MANAGEMENT */ /* * xtalk_error_handler: * pass this error on to the handler registered * at the specified xtalk connecdtion point, * or complain about it here if there is no handler. * * This routine plays two roles during error delivery * to most widgets: first, the external agent (heart, * hub, or whatever) calls in with the error and the * connect point representing the io channel switch, * or whatever io channel device is directly connected * to the agent. * * If there is a switch, it will generally look at the * widget number stashed in the ioerror structure; and, * if the error came from some widget other than the * switch, it will call back into xtalk_error_handler * with the connection point of the offending port. */ int xtalk_error_handler( vertex_hdl_t xconn, int error_code, ioerror_mode_t mode, ioerror_t *ioerror) { xwidget_info_t xwidget_info; char name[MAXDEVNAME]; xwidget_info = xwidget_info_get(xconn); /* Make sure that xwidget_info is a valid pointer before derefencing it. * We could come in here during very early initialization. */ if (xwidget_info && xwidget_info->w_efunc) return xwidget_info->w_efunc (xwidget_info->w_einfo, error_code, mode, ioerror); /* * no error handler registered for * the offending port. it's not clear * what needs to be done, but reporting * it would be a good thing, unless it * is a mode that requires nothing. */ if ((mode == MODE_DEVPROBE) || (mode == MODE_DEVUSERERROR) || (mode == MODE_DEVREENABLE)) return IOERROR_HANDLED; printk(KERN_WARNING "Xbow at %s encountered Fatal error", vertex_to_name(xconn, name, MAXDEVNAME)); return IOERROR_UNHANDLED; } /* ===================================================================== * CONFIGURATION MANAGEMENT */ /* * Startup an io channel provider */ void xtalk_provider_startup(vertex_hdl_t xtalk_provider) { ((xtalk_provider_t *) hwgraph_fastinfo_get(xtalk_provider))->provider_startup(xtalk_provider); } /* * Shutdown an io channel provider */ void xtalk_provider_shutdown(vertex_hdl_t xtalk_provider) { ((xtalk_provider_t *) hwgraph_fastinfo_get(xtalk_provider))->provider_shutdown(xtalk_provider); } /* * Enable a device on a xtalk widget */ void xtalk_widgetdev_enable(vertex_hdl_t xconn_vhdl, int devnum) { return; } /* * Shutdown a device on a xtalk widget */ void xtalk_widgetdev_shutdown(vertex_hdl_t xconn_vhdl, int devnum) { return; } /* * Generic io channel functions, for use with all io channel providers * and all io channel devices. */ /* Generic io channel interrupt interfaces */ vertex_hdl_t xtalk_intr_dev_get(xtalk_intr_t xtalk_intr) { return (xtalk_intr->xi_dev); } xwidgetnum_t xtalk_intr_target_get(xtalk_intr_t xtalk_intr) { return (xtalk_intr->xi_target); } xtalk_intr_vector_t xtalk_intr_vector_get(xtalk_intr_t xtalk_intr) { return (xtalk_intr->xi_vector); } iopaddr_t xtalk_intr_addr_get(struct xtalk_intr_s *xtalk_intr) { return (xtalk_intr->xi_addr); } void * xtalk_intr_sfarg_get(xtalk_intr_t xtalk_intr) { return (xtalk_intr->xi_sfarg); } /* Generic io channel pio interfaces */ vertex_hdl_t xtalk_pio_dev_get(xtalk_piomap_t xtalk_piomap) { return (xtalk_piomap->xp_dev); } xwidgetnum_t xtalk_pio_target_get(xtalk_piomap_t xtalk_piomap) { return (xtalk_piomap->xp_target); } iopaddr_t xtalk_pio_xtalk_addr_get(xtalk_piomap_t xtalk_piomap) { return (xtalk_piomap->xp_xtalk_addr); } ulong xtalk_pio_mapsz_get(xtalk_piomap_t xtalk_piomap) { return (xtalk_piomap->xp_mapsz); } caddr_t xtalk_pio_kvaddr_get(xtalk_piomap_t xtalk_piomap) { return (xtalk_piomap->xp_kvaddr); } /* Generic io channel dma interfaces */ vertex_hdl_t xtalk_dma_dev_get(xtalk_dmamap_t xtalk_dmamap) { return (xtalk_dmamap->xd_dev); } xwidgetnum_t xtalk_dma_target_get(xtalk_dmamap_t xtalk_dmamap) { return (xtalk_dmamap->xd_target); } /* Generic io channel widget information interfaces */ /* xwidget_info_chk: * check to see if this vertex is a widget; * if so, return its widget_info (if any). * if not, return NULL. */ xwidget_info_t xwidget_info_chk(vertex_hdl_t xwidget) { arbitrary_info_t ainfo = 0; hwgraph_info_get_LBL(xwidget, INFO_LBL_XWIDGET, &ainfo); return (xwidget_info_t) ainfo; } xwidget_info_t xwidget_info_get(vertex_hdl_t xwidget) { xwidget_info_t widget_info; widget_info = (xwidget_info_t) hwgraph_fastinfo_get(xwidget); return (widget_info); } void xwidget_info_set(vertex_hdl_t xwidget, xwidget_info_t widget_info) { if (widget_info != NULL) widget_info->w_fingerprint = widget_info_fingerprint; hwgraph_fastinfo_set(xwidget, (arbitrary_info_t) widget_info); /* Also, mark this vertex as an xwidget, * and use the widget_info, so xwidget_info_chk * can work (and be fairly efficient). */ hwgraph_info_add_LBL(xwidget, INFO_LBL_XWIDGET, (arbitrary_info_t) widget_info); } vertex_hdl_t xwidget_info_dev_get(xwidget_info_t xwidget_info) { if (xwidget_info == NULL) panic("xwidget_info_dev_get: null xwidget_info"); return (xwidget_info->w_vertex); } xwidgetnum_t xwidget_info_id_get(xwidget_info_t xwidget_info) { if (xwidget_info == NULL) panic("xwidget_info_id_get: null xwidget_info"); return (xwidget_info->w_id); } vertex_hdl_t xwidget_info_master_get(xwidget_info_t xwidget_info) { if (xwidget_info == NULL) panic("xwidget_info_master_get: null xwidget_info"); return (xwidget_info->w_master); } xwidgetnum_t xwidget_info_masterid_get(xwidget_info_t xwidget_info) { if (xwidget_info == NULL) panic("xwidget_info_masterid_get: null xwidget_info"); return (xwidget_info->w_masterid); } xwidget_part_num_t xwidget_info_part_num_get(xwidget_info_t xwidget_info) { if (xwidget_info == NULL) panic("xwidget_info_part_num_get: null xwidget_info"); return (xwidget_info->w_hwid.part_num); } xwidget_mfg_num_t xwidget_info_mfg_num_get(xwidget_info_t xwidget_info) { if (xwidget_info == NULL) panic("xwidget_info_mfg_num_get: null xwidget_info"); return (xwidget_info->w_hwid.mfg_num); } /* Extract the widget name from the widget information * for the xtalk widget. */ char * xwidget_info_name_get(xwidget_info_t xwidget_info) { if (xwidget_info == NULL) panic("xwidget_info_name_get: null xwidget_info"); return(xwidget_info->w_name); } /* Generic io channel initialization interfaces */ /* * Associate a set of xtalk_provider functions with a vertex. */ void xtalk_provider_register(vertex_hdl_t provider, xtalk_provider_t *xtalk_fns) { hwgraph_fastinfo_set(provider, (arbitrary_info_t) xtalk_fns); } /* * Disassociate a set of xtalk_provider functions with a vertex. */ void xtalk_provider_unregister(vertex_hdl_t provider) { hwgraph_fastinfo_set(provider, (arbitrary_info_t)NULL); } /* * Obtain a pointer to the xtalk_provider functions for a specified Crosstalk * provider. */ xtalk_provider_t * xtalk_provider_fns_get(vertex_hdl_t provider) { return ((xtalk_provider_t *) hwgraph_fastinfo_get(provider)); } /* * Inform xtalk infrastructure that a driver is no longer available for * handling any widgets. */ void xwidget_driver_unregister(char *driver_prefix) { return; } /* * Call some function with each vertex that * might be one of this driver's attach points. */ void xtalk_iterate(char *driver_prefix, xtalk_iter_f *func) { } /* * xwidget_register: * Register a xtalk device (xwidget) by doing the following. * -allocate and initialize xwidget_info data * -allocate a hwgraph vertex with name based on widget number (id) * -look up the widget's initialization function and call it, * or remember the vertex for later initialization. * */ int xwidget_register(xwidget_hwid_t hwid, /* widget's hardware ID */ vertex_hdl_t widget, /* widget to initialize */ xwidgetnum_t id, /* widget's target id (0..f) */ vertex_hdl_t master, /* widget's master vertex */ xwidgetnum_t targetid) /* master's target id (9/a) */ { xwidget_info_t widget_info; char *s,devnm[MAXDEVNAME]; /* Allocate widget_info and associate it with widget vertex */ widget_info = kmalloc(sizeof(*widget_info), GFP_KERNEL); if (!widget_info) return - ENOMEM; /* Initialize widget_info */ widget_info->w_vertex = widget; widget_info->w_id = id; widget_info->w_master = master; widget_info->w_masterid = targetid; widget_info->w_hwid = *hwid; /* structure copy */ widget_info->w_efunc = 0; widget_info->w_einfo = 0; /* * get the name of this xwidget vertex and keep the info. * This is needed during errors and interupts, but as * long as we have it, we can use it elsewhere. */ s = dev_to_name(widget,devnm,MAXDEVNAME); widget_info->w_name = kmalloc(strlen(s) + 1, GFP_KERNEL); strcpy(widget_info->w_name,s); xwidget_info_set(widget, widget_info); device_master_set(widget, master); /* * Add pointer to async attach info -- tear down will be done when * the particular descendant is done with the info. */ return cdl_add_connpt(hwid->part_num, hwid->mfg_num, widget, 0); } /* * xwidget_unregister : * Unregister the xtalk device and detach all its hwgraph namespace. */ int xwidget_unregister(vertex_hdl_t widget) { xwidget_info_t widget_info; xwidget_hwid_t hwid; /* Make sure that we have valid widget information initialized */ if (!(widget_info = xwidget_info_get(widget))) return 1; hwid = &(widget_info->w_hwid); kfree(widget_info->w_name); kfree(widget_info); return 0; } void xwidget_error_register(vertex_hdl_t xwidget, error_handler_f *efunc, error_handler_arg_t einfo) { xwidget_info_t xwidget_info; xwidget_info = xwidget_info_get(xwidget); ASSERT(xwidget_info != NULL); xwidget_info->w_efunc = efunc; xwidget_info->w_einfo = einfo; } /* * Issue a link reset to a widget. */ void xwidget_reset(vertex_hdl_t xwidget) { xswitch_reset_link(xwidget); } void xwidget_gfx_reset(vertex_hdl_t xwidget) { return; } #define ANON_XWIDGET_NAME "No Name" /* Default Widget Name */ /* Get the canonical hwgraph name of xtalk widget */ char * xwidget_name_get(vertex_hdl_t xwidget_vhdl) { xwidget_info_t info; /* If we have a bogus widget handle then return * a default anonymous widget name. */ if (xwidget_vhdl == GRAPH_VERTEX_NONE) return(ANON_XWIDGET_NAME); /* Read the widget name stored in the widget info * for the widget setup during widget initialization. */ info = xwidget_info_get(xwidget_vhdl); ASSERT(info != NULL); return(xwidget_info_name_get(info)); }