xref: /illumos-gate/usr/src/uts/common/io/1394/nx1394.c (revision cd21e7c5)
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  * Copyright 2012 Garrett D'Amore <garrett@damore.org>.  All rights reserved.
28  */
29 
30 /*
31  * nx1394.c
32  *    1394 Services Layer Nexus Support Routines
33  *    Routines in this file implement nexus bus_ops.
34  */
35 
36 #include <sys/conf.h>
37 #include <sys/ddi.h>
38 #include <sys/modctl.h>
39 #include <sys/sunddi.h>
40 #include <sys/cmn_err.h>
41 #include <sys/types.h>
42 #include <sys/ddi_impldefs.h>
43 
44 #include <sys/tnf_probe.h>
45 
46 #include <sys/1394/t1394.h>
47 #include <sys/1394/s1394.h>
48 #include <sys/1394/h1394.h>
49 
50 static int nx1394_dma_allochdl(dev_info_t *dip, dev_info_t *rdip,
51     ddi_dma_attr_t *attr, int (*waitfnp)(caddr_t), caddr_t arg,
52     ddi_dma_handle_t *handlep);
53 
54 static int nx1394_bus_ctl(dev_info_t *dip, dev_info_t *rdip, ddi_ctl_enum_t op,
55     void *arg, void *result);
56 
57 static int nx1394_get_event_cookie(dev_info_t *dip, dev_info_t *rdip,
58     char *name, ddi_eventcookie_t *event_cookiep);
59 
60 static int nx1394_add_eventcall(dev_info_t *dip, dev_info_t *rdip,
61     ddi_eventcookie_t eventhdl, void (*callback)(), void *arg,
62     ddi_callback_id_t *cb_id);
63 
64 static int nx1394_remove_eventcall(dev_info_t *dip, ddi_callback_id_t cb_id);
65 
66 static int nx1394_post_event(dev_info_t *dip, dev_info_t *rdip,
67     ddi_eventcookie_t eventhdl, void *impl_data);
68 
69 struct bus_ops nx1394_busops = {
70 	BUSO_REV,
71 	nullbusmap,			/* bus_map */
72 	NULL,				/* bus_get_intrspec */
73 	NULL,				/* bus_add_intrspec */
74 	NULL,				/* bus_remove_intrspec */
75 	i_ddi_map_fault,		/* XXXX bus_map_fault */
76 	NULL,				/* bus_dma_map */
77 	nx1394_dma_allochdl,
78 	ddi_dma_freehdl,
79 	ddi_dma_bindhdl,
80 	ddi_dma_unbindhdl,
81 	ddi_dma_flush,
82 	ddi_dma_win,
83 	ddi_dma_mctl,			/* bus_dma_ctl */
84 	nx1394_bus_ctl,			/* bus_ctl */
85 	ddi_bus_prop_op,		/* bus_prop_op */
86 	nx1394_get_event_cookie,	/* (*bus_get_eventcookie() */
87 	nx1394_add_eventcall,		/* (*bus_add_eventcall)(); */
88 	nx1394_remove_eventcall,	/* (*bus_remove_eventcall)(); */
89 	nx1394_post_event,		/* (*bus_post_event)(); */
90 	0,				/* (*interrupt control)();	*/
91 	0,				/* (*bus_config)();	*/
92 	0,				/* (*bus_unconfig)();	*/
93 	0,				/* (*bus_fm_init)();	*/
94 	0,				/* (*bus_fm_fini)();	*/
95 	0,				/* (*bus_fm_access_enter)();	*/
96 	0,				/* (*bus_fm_access_exit)();	*/
97 	0,				/* (*bus_power)();	*/
98 	i_ddi_intr_ops			/* (*bus_intr_op)();	*/
99 };
100 
101 /*
102  * removal/insertion/reset events
103  */
104 #define	NX1394_EVENT_TAG_HOT_REMOVAL		0
105 #define	NX1394_EVENT_TAG_HOT_INSERTION		1
106 #define	NX1394_EVENT_TAG_BUS_RESET		2
107 
108 static ndi_event_definition_t nx1394_event_defs[] = {
109 	{NX1394_EVENT_TAG_HOT_REMOVAL, DDI_DEVI_REMOVE_EVENT, EPL_KERNEL,
110 	    NDI_EVENT_POST_TO_TGT},
111 	{NX1394_EVENT_TAG_HOT_INSERTION, DDI_DEVI_INSERT_EVENT, EPL_KERNEL,
112 	    NDI_EVENT_POST_TO_TGT},
113 	{NX1394_EVENT_TAG_BUS_RESET, DDI_DEVI_BUS_RESET_EVENT, EPL_KERNEL,
114 	    NDI_EVENT_POST_TO_ALL},
115 };
116 
117 #define	NX1394_N_EVENTS \
118 	(sizeof (nx1394_event_defs) / sizeof (ndi_event_definition_t))
119 
120 static ndi_event_set_t nx1394_events = {
121 	NDI_EVENTS_REV1, NX1394_N_EVENTS, nx1394_event_defs
122 };
123 
124 /*
125  * nx1394_bus_ctl()
126  *    This routine implements nexus bus ctl operations. Of importance are
127  *    DDI_CTLOPS_REPORTDEV, DDI_CTLOPS_INITCHILD, DDI_CTLOPS_UNINITCHILD
128  *    and DDI_CTLOPS_POWER. For DDI_CTLOPS_INITCHILD, it tries to lookup
129  *    reg property on the child node and builds and sets the name
130  *    (name is of the form GGGGGGGGGGGGGGGG[,AAAAAAAAAAAA], where
131  *    GGGGGGGGGGGGGGGG is the GUID and AAAAAAAAAAAA is the optional unit
132  *    address).
133  */
134 static int
nx1394_bus_ctl(dev_info_t * dip,dev_info_t * rdip,ddi_ctl_enum_t op,void * arg,void * result)135 nx1394_bus_ctl(dev_info_t *dip, dev_info_t *rdip, ddi_ctl_enum_t op, void *arg,
136     void *result)
137 {
138 	int status;
139 
140 	TNF_PROBE_0_DEBUG(nx1394_bus_ctl_enter, S1394_TNF_SL_NEXUS_STACK, "");
141 
142 	switch (op) {
143 	case DDI_CTLOPS_REPORTDEV: {
144 		dev_info_t *pdip = ddi_get_parent(rdip);
145 		cmn_err(CE_CONT, "?%s%d at %s%d",
146 		    ddi_node_name(rdip), ddi_get_instance(rdip),
147 		    ddi_node_name(pdip), ddi_get_instance(pdip));
148 		TNF_PROBE_0_DEBUG(nx1394_bus_ctl_exit, S1394_TNF_SL_NEXUS_STACK,
149 		    "");
150 		return (DDI_SUCCESS);
151 	}
152 
153 	case DDI_CTLOPS_INITCHILD: {
154 		dev_info_t *ocdip, *cdip = (dev_info_t *)arg;
155 		dev_info_t *pdip = ddi_get_parent(cdip);
156 		int reglen, i;
157 		uint32_t *regptr;
158 		char addr[MAXNAMELEN];
159 
160 		TNF_PROBE_1(nx1394_bus_ctl_init_child,
161 		    S1394_TNF_SL_HOTPLUG_STACK, "", tnf_opaque, dip, cdip);
162 
163 		i = ddi_prop_lookup_int_array(DDI_DEV_T_ANY, cdip,
164 		    DDI_PROP_DONTPASS, "reg", (int **)&regptr,
165 		    (uint_t *)&reglen);
166 
167 		if (i != DDI_PROP_SUCCESS) {
168 			cmn_err(CE_NOTE, "!%s(%d): \"reg\" property not found",
169 			    ddi_node_name(cdip), ddi_get_instance(cdip));
170 			TNF_PROBE_2(nx1394_bus_ctl,
171 			    S1394_TNF_SL_NEXUS_ERROR, "", tnf_string, msg,
172 			    "Reg property not found", tnf_int, reason, i);
173 			TNF_PROBE_1_DEBUG(nx1394_bus_ctl_exit,
174 			    S1394_TNF_SL_NEXUS_STACK, "", tnf_string, op,
175 			    "initchild");
176 			return (DDI_NOT_WELL_FORMED);
177 		}
178 
179 		ASSERT(reglen != 0);
180 
181 		/*
182 		 * addr is of the format GGGGGGGGGGGGGGGG[,AAAAAAAAAAAA]
183 		 */
184 		if (regptr[2] || regptr[3]) {
185 			(void) sprintf(addr, "%08x%08x,%04x%08x", regptr[0],
186 			    regptr[1], regptr[2], regptr[3]);
187 		} else {
188 			(void) sprintf(addr, "%08x%08x", regptr[0], regptr[1]);
189 		}
190 		ddi_prop_free(regptr);
191 		ddi_set_name_addr(cdip, addr);
192 
193 		/*
194 		 * Check for a node with the same name & addr as the current
195 		 * node. If such a node exists, return failure.
196 		 */
197 		if ((ocdip = ndi_devi_find(pdip, ddi_node_name(cdip), addr)) !=
198 		    NULL && ocdip != cdip) {
199 			cmn_err(CE_NOTE,
200 			    "!%s(%d): Duplicate dev_info node found %s@%s",
201 			    ddi_node_name(cdip), ddi_get_instance(cdip),
202 			    ddi_node_name(ocdip), addr);
203 			TNF_PROBE_1(nx1394_bus_ctl,
204 			    S1394_TNF_SL_NEXUS_ERROR, "", tnf_string, msg,
205 			    "Duplicate nodes");
206 			TNF_PROBE_1_DEBUG(nx1394_bus_ctl_exit,
207 			    S1394_TNF_SL_NEXUS_STACK, "", tnf_string, op,
208 			    "initchild");
209 			ddi_set_name_addr(cdip, NULL);
210 			return (DDI_NOT_WELL_FORMED);
211 		}
212 
213 		/*
214 		 * If HAL (parent dip) has "active-dma-flush" property, then
215 		 * add property to child as well.  Workaround for active
216 		 * context flushing bug in Schizo rev 2.1 and 2.2.
217 		 */
218 		if (ddi_prop_exists(DDI_DEV_T_ANY, pdip, DDI_PROP_DONTPASS,
219 		    "active-dma-flush") != 0) {
220 			status = ndi_prop_update_int(DDI_DEV_T_NONE, cdip,
221 			    "active-dma-flush", 1);
222 			if (status != NDI_SUCCESS) {
223 				cmn_err(CE_NOTE, "!%s(%d): Unable to add "
224 				    "\"active-dma-flush\" property",
225 				    ddi_node_name(cdip),
226 				    ddi_get_instance(cdip));
227 				TNF_PROBE_1(nx1394_bus_ctl,
228 				    S1394_TNF_SL_NEXUS_ERROR, "", tnf_string,
229 				    msg, "Unable to add \"active-dma-flush\" "
230 				    "property");
231 				TNF_PROBE_1_DEBUG(nx1394_bus_ctl_exit,
232 				    S1394_TNF_SL_NEXUS_STACK, "", tnf_string,
233 				    op, "initchild");
234 				ddi_set_name_addr(cdip, NULL);
235 				return (DDI_NOT_WELL_FORMED);
236 			}
237 		}
238 
239 		TNF_PROBE_1_DEBUG(nx1394_bus_ctl_exit,
240 		    S1394_TNF_SL_NEXUS_STACK, "", tnf_string, op, "initchild");
241 		return (DDI_SUCCESS);
242 	}
243 
244 	case DDI_CTLOPS_UNINITCHILD: {
245 		ddi_prop_remove_all((dev_info_t *)arg);
246 		ddi_set_name_addr((dev_info_t *)arg, NULL);
247 		TNF_PROBE_1_DEBUG(nx1394_bus_ctl_exit, S1394_TNF_SL_NEXUS_STACK,
248 		    "", tnf_string, op, "uninitchild");
249 		return (DDI_SUCCESS);
250 	}
251 
252 	case DDI_CTLOPS_IOMIN: {
253 		status = ddi_ctlops(dip, rdip, op, arg, result);
254 		TNF_PROBE_1_DEBUG(nx1394_bus_ctl_exit, S1394_TNF_SL_NEXUS_STACK,
255 		    "", tnf_string, op, "iomin");
256 		return (status);
257 	}
258 
259 	case DDI_CTLOPS_POWER: {
260 		return (DDI_SUCCESS);
261 	}
262 
263 	/*
264 	 * These ops correspond to functions that "shouldn't" be called
265 	 * by a 1394 client driver.
266 	 */
267 	case DDI_CTLOPS_DMAPMAPC:
268 	case DDI_CTLOPS_REPORTINT:
269 	case DDI_CTLOPS_REGSIZE:
270 	case DDI_CTLOPS_NREGS:
271 	case DDI_CTLOPS_SIDDEV:
272 	case DDI_CTLOPS_SLAVEONLY:
273 	case DDI_CTLOPS_AFFINITY:
274 	case DDI_CTLOPS_POKE:
275 	case DDI_CTLOPS_PEEK: {
276 		cmn_err(CE_CONT, "!%s(%d): invalid op (%d) from %s(%d)",
277 		    ddi_node_name(dip), ddi_get_instance(dip),
278 		    op, ddi_node_name(rdip), ddi_get_instance(rdip));
279 		TNF_PROBE_2(nx1394_bus_ctl, S1394_TNF_SL_NEXUS_ERROR, "",
280 		    tnf_string, msg, "invalid op", tnf_int, op, op);
281 		TNF_PROBE_0_DEBUG(nx1394_bus_ctl_exit, S1394_TNF_SL_NEXUS_STACK,
282 		    "");
283 		return (DDI_FAILURE);
284 	}
285 
286 	/*
287 	 * Everything else (e.g. PTOB/BTOP/BTOPR requests) we pass up
288 	 */
289 	default: {
290 		status = ddi_ctlops(dip, rdip, op, arg, result);
291 		TNF_PROBE_0_DEBUG(nx1394_bus_ctl_exit, S1394_TNF_SL_NEXUS_STACK,
292 		    "");
293 		return (status);
294 	}
295 	}
296 }
297 
298 /*
299  * nx1394_dma_allochdl()
300  *    Merges the ddi_dma_attr_t passed in by the target (using
301  *    ddi_dma_alloc_handle() call) with that of the hal and passes the alloc
302  *    handle request up the device by calling ddi_dma_allochdl().
303  */
304 static int
nx1394_dma_allochdl(dev_info_t * dip,dev_info_t * rdip,ddi_dma_attr_t * attr,int (* waitfnp)(caddr_t),caddr_t arg,ddi_dma_handle_t * handlep)305 nx1394_dma_allochdl(dev_info_t *dip, dev_info_t *rdip, ddi_dma_attr_t *attr,
306     int (*waitfnp)(caddr_t), caddr_t arg, ddi_dma_handle_t *handlep)
307 {
308 	s1394_hal_t *hal;
309 	ddi_dma_attr_t *hal_attr;
310 	int status;
311 
312 	_NOTE(SCHEME_PROTECTS_DATA("unique (per thread)", ddi_dma_attr_t))
313 
314 	TNF_PROBE_0_DEBUG(nx1394_dma_allochdl_enter, S1394_TNF_SL_NEXUS_STACK,
315 	    "");
316 
317 	/*
318 	 * If hal calls ddi_dma_alloc_handle, dip == rdip == hal dip.
319 	 * Unfortunately, we cannot verify this (by way of looking up for hal
320 	 * dip) here because h1394_attach() may happen much later.
321 	 */
322 	if (dip != rdip) {
323 		hal = s1394_dip_to_hal(ddi_get_parent(rdip));
324 		ASSERT(hal);
325 		hal_attr = &hal->halinfo.dma_attr;
326 		ASSERT(hal_attr);
327 		ddi_dma_attr_merge(attr, hal_attr);
328 	}
329 	status = ddi_dma_allochdl(dip, rdip, attr, waitfnp, arg, handlep);
330 	TNF_PROBE_1_DEBUG(nx1394_dma_allochdl_exit, S1394_TNF_SL_NEXUS_STACK,
331 	    "", tnf_int, status, status);
332 	return (status);
333 }
334 
335 /*
336  * nx1394_get_event_cookie()
337  *    Called when a child node calls ddi_get_eventcookie().
338  *    Returns event cookie corresponding to event "name".
339  */
340 static int
nx1394_get_event_cookie(dev_info_t * dip,dev_info_t * rdip,char * name,ddi_eventcookie_t * event_cookiep)341 nx1394_get_event_cookie(dev_info_t *dip, dev_info_t *rdip, char *name,
342     ddi_eventcookie_t *event_cookiep)
343 {
344 	int ret;
345 	s1394_hal_t *hal;
346 
347 	TNF_PROBE_1_DEBUG(nx1394_get_event_cookie_enter,
348 	    S1394_TNF_SL_NEXUS_STACK, "", tnf_string, name, name);
349 
350 	hal = s1394_dip_to_hal(dip);
351 	ASSERT(hal);
352 
353 	ret = ndi_event_retrieve_cookie(hal->hal_ndi_event_hdl,
354 	    rdip, name, event_cookiep, 0);
355 
356 	TNF_PROBE_4_DEBUG(nx1394_get_event_cookie_exit,
357 	    S1394_TNF_SL_NEXUS_STACK, "", tnf_opaque, parent_dip, (void *)dip,
358 	    tnf_opaque, requestor_dip, (void *)rdip, tnf_string, event_name,
359 	    name, tnf_int, request_status, ret);
360 
361 	return (ret);
362 
363 }
364 
365 /*
366  * nx1394_add_eventcall()
367  *    This gets called when a child node calls ddi_add_eventcall(). Registers
368  *    the specified callback for the requested event cookie with the ndi
369  *    event framework.
370  *    dip is the hal dip. This routine calls ndi_event_add_callback(),
371  *    allowing requests for events we don't generate to pass up the tree.
372  */
373 static int
nx1394_add_eventcall(dev_info_t * dip,dev_info_t * rdip,ddi_eventcookie_t cookie,void (* callback)(),void * arg,ddi_callback_id_t * cb_id)374 nx1394_add_eventcall(dev_info_t *dip, dev_info_t *rdip,
375     ddi_eventcookie_t cookie, void (*callback)(), void *arg,
376     ddi_callback_id_t *cb_id)
377 {
378 	int ret;
379 	s1394_hal_t *hal;
380 #if defined(DEBUG)
381 	char *event_name = NULL;
382 #endif
383 
384 	hal = s1394_dip_to_hal(dip);
385 	ASSERT(hal);
386 
387 	TNF_PROBE_0_DEBUG(nx1394_add_eventcall_enter, S1394_TNF_SL_NEXUS_STACK,
388 	    "");
389 
390 	ret = ndi_event_add_callback(hal->hal_ndi_event_hdl, rdip, cookie,
391 	    callback, arg, NDI_NOSLEEP, cb_id);
392 #if defined(DEBUG)
393 	event_name = ndi_event_cookie_to_name(hal->hal_ndi_event_hdl, cookie);
394 	if (event_name == NULL)
395 		event_name = "";
396 #endif
397 	TNF_PROBE_4_DEBUG(nx1394_add_eventcall_exit, S1394_TNF_SL_NEXUS_STACK,
398 	    "", tnf_opaque, parent_dip, (void *)dip, tnf_opaque, requestor_dip,
399 	    (void *)rdip, tnf_string, event_name, event_name, tnf_int,
400 	    request_status, ret);
401 
402 	return (ret);
403 }
404 
405 /*
406  * nx1394_remove_eventcall()
407  *    Called as a result of a child node calling ddi_remove_eventcall().
408  *    Unregisters the callback corresponding to the callback id passed in.
409  */
410 static int
nx1394_remove_eventcall(dev_info_t * dip,ddi_callback_id_t cb_id)411 nx1394_remove_eventcall(dev_info_t *dip, ddi_callback_id_t cb_id)
412 {
413 	int ret;
414 	s1394_hal_t *hal;
415 	ddi_eventcookie_t cookie;
416 #if defined(DEBUG)
417 	char *event_name = NULL;
418 #endif
419 
420 	ASSERT(cb_id);
421 	cookie = ((ndi_event_callbacks_t *)cb_id)->ndi_evtcb_cookie;
422 
423 	hal = s1394_dip_to_hal(dip);
424 	ASSERT(hal);
425 
426 	TNF_PROBE_0_DEBUG(nx1394_remove_eventcall_enter,
427 	    S1394_TNF_SL_NEXUS_STACK, "");
428 
429 	ret = ndi_event_remove_callback(hal->hal_ndi_event_hdl, cb_id);
430 
431 #if defined(DEBUG)
432 	event_name = ndi_event_cookie_to_name(hal->hal_ndi_event_hdl, cookie);
433 	if (event_name == NULL)
434 		event_name = "";
435 
436 	TNF_PROBE_4_DEBUG(nx1394_remove_eventcall_exit,
437 	    S1394_TNF_SL_NEXUS_STACK, "", tnf_opaque, parent_dip, (void *)dip,
438 	    tnf_opaque, callback_id, (void *)cb_id, tnf_string, event_name,
439 	    event_name, tnf_int, request_status, ret);
440 #endif
441 
442 	return (ret);
443 }
444 
445 /*
446  * nx1394_post_event()
447  *    Called when a child node calls ddi_post_event. If the event is one of
448  *    the events supported by us (bus reset/insert/remove, for now), builds
449  *    a t1394_localinfo_t structure and calls ndi_event_run_callbacks(). This
450  *    will result in all registered callbacks being invoked with
451  *    t1394_localinfo_t as the impl_data. (see ddi_add_eventcall for callback
452  *    arguments.) If the event is not defined by us, the request is
453  *    propagated up the device tree by calling ndi_post_event().
454  */
455 static int
nx1394_post_event(dev_info_t * dip,dev_info_t * rdip,ddi_eventcookie_t cookie,void * impl_data)456 nx1394_post_event(dev_info_t *dip, dev_info_t *rdip, ddi_eventcookie_t cookie,
457     void *impl_data)
458 {
459 	int ret;
460 	char *name;
461 	s1394_hal_t *hal;
462 	t1394_localinfo_t localinfo;
463 
464 	hal = s1394_dip_to_hal(dip);
465 	ASSERT(hal);
466 
467 	TNF_PROBE_0_DEBUG(nx1394_post_event_enter, S1394_TNF_SL_NEXUS_STACK,
468 	    "");
469 
470 	name = ndi_event_cookie_to_name(hal->hal_ndi_event_hdl, cookie);
471 	/* name is NULL if we don't generate the event */
472 	if (name != NULL) {
473 
474 		mutex_enter(&hal->topology_tree_mutex);
475 		localinfo.bus_generation = hal->generation_count;
476 		localinfo.local_nodeID = hal->node_id;
477 		mutex_exit(&hal->topology_tree_mutex);
478 		impl_data = &localinfo;
479 
480 		ret = ndi_event_run_callbacks(hal->hal_ndi_event_hdl,
481 		    rdip, cookie, impl_data);
482 
483 		TNF_PROBE_4_DEBUG(nx1394_post_event_exit,
484 		    S1394_TNF_SL_NEXUS_STACK, "", tnf_opaque, parent_dip,
485 		    (void *)dip, tnf_opaque, requestor_dip, (void *)rdip,
486 		    tnf_string, event_name, name, tnf_int, request_status, ret);
487 		return (ret);
488 
489 	} else {
490 		ret = ndi_post_event(ddi_get_parent(dip), rdip, cookie,
491 		    impl_data);
492 		TNF_PROBE_2_DEBUG(nx1394_post_event_exit,
493 		    S1394_TNF_SL_NEXUS_STACK, "", tnf_string, msg,
494 		    "Not our event", tnf_int, ret, ret);
495 		return (ret);
496 	}
497 }
498 
499 /*
500  * nx1394_define_events()
501  *    Allocates event handle for the hal dip and binds event set to it.
502  */
503 int
nx1394_define_events(s1394_hal_t * hal)504 nx1394_define_events(s1394_hal_t *hal)
505 {
506 	int ret;
507 
508 	TNF_PROBE_0_DEBUG(nx1394_define_events_enter, S1394_TNF_SL_NEXUS_STACK,
509 	    "");
510 
511 	/* get event handle */
512 	ret = ndi_event_alloc_hdl(hal->halinfo.dip, hal->halinfo.hw_interrupt,
513 	    &hal->hal_ndi_event_hdl, NDI_SLEEP);
514 	if (ret != NDI_SUCCESS) {
515 		TNF_PROBE_1(nx1394_define_events_alloc_fail,
516 		    S1394_TNF_SL_NEXUS_ERROR, "", tnf_int, ret, ret);
517 	} else {
518 		/* and bind to it */
519 		ret = ndi_event_bind_set(hal->hal_ndi_event_hdl, &nx1394_events,
520 		    NDI_SLEEP);
521 		if (ret != NDI_SUCCESS) {
522 			TNF_PROBE_1(nx1394_define_events_bind_fail,
523 			    S1394_TNF_SL_NEXUS_ERROR, "", tnf_int, ret, ret);
524 			(void) ndi_event_free_hdl(hal->hal_ndi_event_hdl);
525 			TNF_PROBE_0_DEBUG(nx1394_define_events_exit,
526 			    S1394_TNF_SL_NEXUS_STACK, "");
527 			return (DDI_FAILURE);
528 		}
529 	}
530 
531 	TNF_PROBE_0_DEBUG(nx1394_define_events_exit, S1394_TNF_SL_NEXUS_STACK,
532 	    "");
533 
534 	return (DDI_SUCCESS);
535 }
536 
537 /*
538  * nx1394_undefine_events()
539  *    Unbinds event set bound to the hal and frees the event handle.
540  */
541 void
nx1394_undefine_events(s1394_hal_t * hal)542 nx1394_undefine_events(s1394_hal_t *hal)
543 {
544 	int ret;
545 
546 	TNF_PROBE_0_DEBUG(nx1394_undefine_events_enter,
547 	    S1394_TNF_SL_NEXUS_STACK, "");
548 
549 	ret = ndi_event_unbind_set(hal->hal_ndi_event_hdl, &nx1394_events,
550 	    NDI_SLEEP);
551 	if (ret != NDI_SUCCESS) {
552 		TNF_PROBE_1(nx1394_undefine_events_unbind_fail,
553 		    S1394_TNF_SL_NEXUS_ERROR, "", tnf_int, ret, ret);
554 	} else {
555 		ret = ndi_event_free_hdl(hal->hal_ndi_event_hdl);
556 		if (ret != NDI_SUCCESS) {
557 			TNF_PROBE_1(nx1394_undefine_events_free_hdl_fail,
558 			    S1394_TNF_SL_NEXUS_ERROR, "", tnf_int, ret, ret);
559 		}
560 	}
561 
562 	TNF_PROBE_0_DEBUG(nx1394_undefine_events_exit,
563 	    S1394_TNF_SL_NEXUS_STACK, "");
564 }
565