/* * 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 2007 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ #pragma ident "%Z%%M% %I% %E% SMI" #include <sys/types.h> #include <sys/systm.h> #include <sys/sysmacros.h> #include <sys/kobj.h> #include <sys/membar.h> #include <sys/dmv.h> #include <sys/prom_debug.h> #include <sys/machsystm.h> #include <vm/vm_dep.h> /* * Implementation of databearing mondo vector handler registration routines. * See PSARC 1998/222 for more details. */ /* * The dmv_interface_*_version variables are provided to protect a * driver against changes in the databearing mondo interfaces. * * The major version is incremented when an incompatible change * is made to an interface; for instance, a routine which used to take * 3 parameters now takes 4, or a routine which used have the semantics * "do X" now has the semantics "do Y". Before calling any of the * databearing mondo routines, a driver must check the major version * it was compiled with (i.e., the constant DMV_INTERFACE_MAJOR_VERSION) * against the contents of dmv_interface_major_version. If the two * are different, the driver must refuse to operate. * * The minor version is incremented when an upward-compatible change * is made to an interface; for instance, a routine now supports a new * flag bit (in an existing flags argument). A client can use the * minor version to see whether a feature it depends on is available * in its environment; in order to enable this, the documentation * for new features should note which major and minor version the * feature first appears in. */ int dmv_interface_major_version = DMV_INTERFACE_MAJOR_VERSION; int dmv_interface_minor_version = DMV_INTERFACE_MINOR_VERSION; /* * These are where the number of hardware and software DMV inums are kept. * If they're zero, we use the platform's default values. (These are not * patchable in /etc/system, since the dispatch table is allocated before * /etc/system is loaded; however, you could patch them by adb'ing unix.) */ uint_t dmv_hwint = 0; uint_t dmv_swint = 0; uint_t dmv_totalints = 0; struct dmv_disp *dmv_dispatch_table = (struct dmv_disp *)0; /* * dmv_disp_lock protects the dispatch table from being modified by two * threads concurrently. It is not used to protect the table from being * modified while being used by the actual interrupt dispatch code; see * comments at the end of dmv.h for the rationale. */ kmutex_t dmv_disp_lock; /* * dmv_add_intr is called to add a databearing mondo interrupt handler * for a real device to the system. Only one handler may be registered * for a dmv_inum at any one time. * * Note that if a processor receives a databearing mondo interrupt * for which a handler has not been registered, the behavior is * undefined. (Current practice for normal mondos which are unhandled * depends on whether DEBUG is on; a DEBUG kernel prints an error * and breaks to OBP, while a non-DEBUG kernel simply panics. This * model will likely be followed for databearing mondos.) * * Parameters: * dmv_inum interrupt number for the device. * * routine pointer to the device's vectored interrupt * handler. This routine is subject to the * constraints outlined below in "Handler * Characteristics and Environment". * * arg argument which will be passed to the device's * handler. * * Return value: 0 if the handler was added successfully, -1 if * handler was already registered for the given * dmv_inum. * * Handler Characteristics and Environment * * Handler Entry: * * On entry to the handler, the %g registers are set as follows: * * %g1 The argument (arg) passed to dmv_add_intr(). * %g2 Word 0 of the incoming mondo vector. * * * Handler Constraints: * * While executing, the handler must obey the following rules: * * 1. The handler is limited to the use of registers %g1 through * %g7. * * 2. The handler may not modify %cwp (i.e., may not execute a * SAVE or RESTORE instruction). * * 3. The handler may not read or write the stack. * * 4. The handler may not call any other DDI or kernel routines. * * 5. The handler may not call any other routines inside the * handler's own driver, since this would modify %o7; however, * it is permissible to jump to a routine within the handler's * driver. * * 6. The handler may read the Incoming Interrupt Vector Data * registers, and the Interrupt Vector Receive register, but * must not modify these registers. (Note: symbols for the * ASIs and addresses of these registers are in <sys/spitasi.h> * and <sys/intreg.h>.) * * 7. The handler may read or write driver-private data * structures; in order to protect against simultaneous * modification by other driver routines, nonblocking data * sharing algorithms must be used. (For instance, * compare-and-swap could be used to update counters or add * entries to linked lists; producer-consumer queues are * another possibility.) * * 8. The handler should neither read nor write any other * processor register nor kernel data item which is not * explicitly mentioned in this list. [Yes, this is rather * strict; the intent here is that as handler implementations * are done, and more experience is gained, additional items * may be permitted.] * * * Handler Exit: * * When the handler's processing is complete, the handler must * exit by jumping to the label dmv_finish_intr. At this time, * the handler may optionally request the execution of a soft * interrupt routine in order to do further processing at normal * interrupt level. It is strongly advised that drivers do * minimal processing in their databearing mondo handlers; * whenever possible, tasks should be postponed to a later * soft interrupt routine. (This is analogous to the DDI * "high-level interrupt" concept, although a databearing mondo * handler's environment is even more restrictive than that of * a high-level interrupt routine.) * * Soft interrupt routines should be registered by calling * add_softintr(), which will return an interrupt number. This * interrupt number should be saved in a driver-private data * structure for later use. * * The contents of %g1 on entry to dmv_finish_intr determine * whether a soft interrupt routine will be called, as follows: * * If %g1 is less than zero, no interrupt will be queued. * * Otherwise, %g1 is assumed to be an interrupt number * obtained from add_softintr. This interrupt routine * will be executed in the normal way at the requested * priority. (Note that this routine may or may not * execute on the same CPU as the current handler.) */ int dmv_add_intr(int dmv_inum, void (*routine)(), void *arg) { if (dmv_inum < 0 || dmv_inum >= dmv_hwint) return (-1); mutex_enter(&dmv_disp_lock); if (dmv_dispatch_table[dmv_inum].dmv_func != 0) { mutex_exit(&dmv_disp_lock); return (-1); } dmv_dispatch_table[dmv_inum].dmv_arg = arg; membar_sync(); dmv_dispatch_table[dmv_inum].dmv_func = routine; mutex_exit(&dmv_disp_lock); return (0); } /* * dmv_add_softintr is called to add a databearing mondo interrupt * handler for a pseudo-device to the system. * * Parameters: * routine pointer to the device's vectored interrupt * handler. This routine is subject to the * constraints outlined above in "Handler * Characteristics and Environment". * * arg argument which will be passed to the device's * handler. * * Return value: dmv_inum allocated if one was available, -1 if * all soft dmv_inums are already allocated */ int dmv_add_softintr(void (*routine)(void), void *arg) { int i; mutex_enter(&dmv_disp_lock); for (i = dmv_hwint; i < dmv_totalints; i++) { if (dmv_dispatch_table[i].dmv_func == 0) { dmv_dispatch_table[i].dmv_arg = arg; membar_sync(); dmv_dispatch_table[i].dmv_func = routine; mutex_exit(&dmv_disp_lock); return (i); } } mutex_exit(&dmv_disp_lock); return (-1); } /* * dmv_rem_intr is called to remove a databearing interrupt handler * from the system. * * Parameters: * dmv_inum interrupt number for the device. * * Return value: 0 if the handler was removed successfully, -1 * if no handler was registered for the given * dmv_inum. */ int dmv_rem_intr(int dmv_inum) { if (dmv_inum < 0 || dmv_inum >= (dmv_totalints)) return (-1); mutex_enter(&dmv_disp_lock); if (dmv_dispatch_table[dmv_inum].dmv_func == 0) { mutex_exit(&dmv_disp_lock); return (-1); } dmv_dispatch_table[dmv_inum].dmv_func = 0; mutex_exit(&dmv_disp_lock); return (0); } /* * Allocate the dmv dispatch table from nucleus data memory. */ int ndata_alloc_dmv(struct memlist *ndata) { size_t alloc_sz; uint_t plat_hwint = 0; uint_t plat_swint = 0; void (*plat_dmv_params)(uint_t *, uint_t *); /* * Get platform default values, if they exist */ plat_dmv_params = (void (*)(uint_t *, uint_t *)) kobj_getsymvalue("plat_dmv_params", 0); if (plat_dmv_params) (*plat_dmv_params)(&plat_hwint, &plat_swint); /* * Set sizes to platform defaults if user hasn't set them */ if (dmv_hwint == 0) dmv_hwint = plat_hwint; if (dmv_swint == 0) dmv_swint = plat_swint; /* * Allocate table if we need it */ dmv_totalints = dmv_hwint + dmv_swint; if (dmv_totalints != 0) { alloc_sz = sizeof (struct dmv_disp) * (dmv_totalints + 1); dmv_dispatch_table = ndata_alloc(ndata, alloc_sz, sizeof (struct dmv_disp)); if (dmv_dispatch_table == NULL) return (-1); bzero(dmv_dispatch_table, alloc_sz); /* use uintptr_t to suppress the gcc warning */ PRM_DEBUG((uintptr_t)dmv_dispatch_table); } return (0); }
