?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
8786 s1394: variable 'type' set but not used
[unleashed.git] / usr / src / uts / common / io / 1394 / s1394_hotplug.c
bloba020ee2d53e4bc91862e8ae2fc5e636718578f33
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 /*
28 * s1394_hotplug.c
29 * 1394 Services Layer Hotplug Routines
30 * This file contains routines that walk the old and topology
31 * trees, at bus reset time, creating devinfo's for new nodes and offlining
32 * nodes that are removed.
33 */
34
35 #include <sys/conf.h>
36 #include <sys/sysmacros.h>
37 #include <sys/ddi.h>
38 #include <sys/sunddi.h>
39 #include <sys/sunndi.h>
40 #include <sys/modctl.h>
41 #include <sys/sunddi.h>
42 #include <sys/ddi_impldefs.h>
43 #include <sys/types.h>
44
45 #include <sys/tnf_probe.h>
46
47 #include <sys/1394/t1394.h>
48 #include <sys/1394/s1394.h>
49 #include <sys/1394/h1394.h>
50 #include <sys/1394/ieee1394.h>
51
52 static void s1394_send_remove_event(s1394_hal_t *hal, dev_info_t *dip,
53 t1394_localinfo_t *localinfo);
54 static void s1394_send_insert_event(s1394_hal_t *hal, dev_info_t *dip,
55 t1394_localinfo_t *localinfo);
56 static dev_info_t *s1394_create_devinfo(s1394_hal_t *hal, s1394_node_t *node,
57 uint32_t *unit_dir, int nunit);
58 static void s1394_update_unit_dir_location(s1394_hal_t *hal, dev_info_t *tdip,
59 uint_t offset);
60
61 /*
62 * s1394_send_remove_event()
63 * Invokes any "remove event" callback registered for dip. Passes
64 * t1394_localinfo_t as impl_data for the callback.
65 */
66 static void
67 s1394_send_remove_event(s1394_hal_t *hal, dev_info_t *dip,
68 t1394_localinfo_t *localinfo)
69 {
70 char name[128];
71 ddi_eventcookie_t cookie;
72
73 (void) sprintf(name, "%s%d", ddi_driver_name(dip),
74 ddi_get_instance(dip));
75
76 TNF_PROBE_1_DEBUG(s1394_send_remove_event_enter,
77 S1394_TNF_SL_HOTPLUG_STACK, "", tnf_string, device,
78 name);
79
80 if (ndi_event_retrieve_cookie(hal->hal_ndi_event_hdl, dip,
81 DDI_DEVI_REMOVE_EVENT, &cookie, NDI_EVENT_NOPASS)
82 == NDI_SUCCESS) {
83 (void) ndi_event_run_callbacks(hal->hal_ndi_event_hdl, dip,
84 cookie, localinfo);
85 }
86 TNF_PROBE_0_DEBUG(s1394_send_remove_event_exit,
87 S1394_TNF_SL_HOTPLUG_STACK, "");
88 }
89
90 /*
91 * s1394_send_insert_event()
92 * Invokes any "insert event" callback registered for dip. Passes
93 * t1394_localinfo_t as impl_data for the callback.
94 */
95 static void
96 s1394_send_insert_event(s1394_hal_t *hal, dev_info_t *dip,
97 t1394_localinfo_t *localinfo)
98 {
99 char name[128];
100 ddi_eventcookie_t cookie;
101
102 (void) sprintf(name, "%s%d", ddi_driver_name(dip),
103 ddi_get_instance(dip));
104
105 TNF_PROBE_1_DEBUG(s1394_send_insert_event_enter,
106 S1394_TNF_SL_HOTPLUG_STACK, "", tnf_string, device,
107 name);
108
109 if (ndi_event_retrieve_cookie(hal->hal_ndi_event_hdl, dip,
110 DDI_DEVI_INSERT_EVENT, &cookie, NDI_EVENT_NOPASS) ==
111 NDI_SUCCESS)
112 (void) ndi_event_run_callbacks(hal->hal_ndi_event_hdl, dip,
113 cookie, localinfo);
114
115 TNF_PROBE_0_DEBUG(s1394_send_insert_event_exit,
116 S1394_TNF_SL_HOTPLUG_STACK, "");
117 }
118
119 /*
120 * s1394_create_devinfo()
121 * This routine creates a devinfo corresponding to the unit_dir passed in.
122 * It adds "hp-node", "reg", "compatible" properties to the devinfo
123 * (formats for "reg" and "compatible" properties are specified by 1275
124 * binding for IEEE1394). If unable to create the devinfo and/or add the
125 * the properties, returns NULL, otherwise, returns the devinfo created.
126 *
127 * NOTE: All ndi_* routines are interrupt callable (and thus won't sleep).
128 * So, we don't drop topology_mutex across ndi calls.
129 */
130 static dev_info_t *
131 s1394_create_devinfo(s1394_hal_t *hal, s1394_node_t *node, uint32_t *unit_dir,
132 int nunit)
133 {
134 dev_info_t *hal_dip;
135 uint32_t *root_dir;
136 dev_info_t *target_dip;
137
138 int root_dir_len;
139 int result, i, j, spec_id, sw_version;
140 int mod_ven, mod_hw, mod_spec, mod_sw;
141 int node_ven, node_hw, node_spec, node_sw;
142
143 /*LINTED type is unused*/
144 uint32_t type __unused, key, value;
145 uint32_t unit_spec_id, unit_sw_version;
146 uint32_t node_spec_id, node_sw_version;
147 uint32_t node_vendor_id, node_hw_version;
148 uint32_t module_spec_id, module_sw_version;
149 uint32_t module_vendor_id, module_hw_version;
150
151 char *fmt = "firewire%06x,%06x";
152
153 char *buf[5], data[5][24];
154 uint32_t reg[6];
155
156 ASSERT(MUTEX_HELD(&hal->topology_tree_mutex));
157
158 TNF_PROBE_2_DEBUG(s1394_create_devinfo_enter,
159 S1394_TNF_SL_HOTPLUG_STACK, "", tnf_uint, guid_hi,
160 node->node_guid_hi, tnf_uint, guid_lo, node->node_guid_lo);
161
162 hal_dip = hal->halinfo.dip;
163
164 /* Allocate and init a new device node instance. */
165 result = ndi_devi_alloc(hal_dip, "unit", (pnode_t)DEVI_SID_NODEID,
166 &target_dip);
167
168 if (result != NDI_SUCCESS) {
169 cmn_err(CE_NOTE, "!Unable to create devinfo"
170 " (node's GUID %08x%08x)", node->node_guid_hi,
171 node->node_guid_lo);
172 TNF_PROBE_2(s1394_create_devinfo_fail_alloc,
173 S1394_TNF_SL_HOTPLUG_ERROR, "", tnf_uint, guid_hi,
174 node->node_guid_hi, tnf_uint, guid_lo, node->node_guid_lo);
175 TNF_PROBE_0_DEBUG(s1394_create_devinfo_exit,
176 S1394_TNF_SL_HOTPLUG_STACK, "");
177 return (NULL);
178 }
179
180 /* Add "hp-node" property */
181 result = ndi_prop_update_int(DDI_DEV_T_NONE, target_dip, "hp-node", 0);
182 if (result != NDI_SUCCESS) {
183 cmn_err(CE_NOTE, "!Unable to add \"hp-node\" property"
184 " (node's GUID %08x%08x)", node->node_guid_hi,
185 node->node_guid_lo);
186 #if defined(DEBUG)
187 cmn_err(CE_CONT, "!Error code %d", result);
188 #endif
189 TNF_PROBE_3(s1394_create_devinfo_hp_node,
190 S1394_TNF_SL_HOTPLUG_ERROR, "", tnf_uint, guid_hi,
191 node->node_guid_hi, tnf_uint, guid_lo, node->node_guid_lo,
192 tnf_int, error, result);
193 ndi_prop_remove_all(target_dip);
194 (void) ndi_devi_free(target_dip);
195 TNF_PROBE_0_DEBUG(s1394_create_devinfo_exit,
196 S1394_TNF_SL_HOTPLUG_STACK, "");
197 return (NULL);
198 }
199
200 spec_id = sw_version = mod_ven = mod_hw = mod_spec = mod_sw =
201 node_ven = node_hw = node_spec = node_sw = 0;
202 unit_sw_version = node_sw_version = node_hw_version =
203 module_sw_version = module_hw_version = 0;
204
205
206 root_dir = CFGROM_ROOT_DIR(node->cfgrom);
207 root_dir_len = CFGROM_DIR_LEN(root_dir);
208
209 for (i = 0; i < root_dir_len; i++) {
210
211 CFGROM_TYPE_KEY_VALUE(root_dir[i + 1], type, key, value);
212 switch (key) {
213
214 case IEEE1212_MODULE_VENDOR_ID:
215 module_vendor_id = value;
216 mod_ven++;
217 break;
218 case IEEE1212_MODULE_HW_VERSION:
219 module_hw_version = value;
220 mod_hw++;
221 break;
222 case IEEE1212_MODULE_SPEC_ID:
223 module_spec_id = value;
224 mod_spec++;
225 break;
226 case IEEE1212_MODULE_SW_VERSION:
227 module_sw_version = value;
228 mod_sw++;
229 break;
230 case IEEE1212_NODE_VENDOR_ID:
231 node_vendor_id = value;
232 node_ven++;
233 break;
234 case IEEE1212_NODE_UNIQUE_ID: {
235 uint32_t *node_unique_leaf =
236 &root_dir[i + 1] + value;
237 node_vendor_id = (node_unique_leaf[1] >> 8);
238 node_ven++;
239 }
240 break;
241 case IEEE1212_NODE_HW_VERSION:
242 node_hw_version = value;
243 node_hw++;
244 break;
245 case IEEE1212_NODE_SPEC_ID:
246 node_spec_id = value;
247 node_spec++;
248 break;
249 case IEEE1212_NODE_SW_VERSION:
250 node_sw_version = value;
251 node_sw++;
252 break;
253 }
254
255 if (mod_ven && mod_hw && mod_spec && mod_sw && node_ven &&
256 node_hw && node_spec && node_sw) {
257 break;
258 }
259 }
260
261 /*
262 * Search for unit spec and version
263 */
264 for (i = 0; i < CFGROM_DIR_LEN(unit_dir); i++) {
265
266 CFGROM_TYPE_KEY_VALUE(unit_dir[i + 1], type, key, value);
267 if (key == IEEE1212_UNIT_SPEC_ID) {
268
269 unit_spec_id = value;
270 spec_id++;
271 } else if (key == IEEE1212_UNIT_SW_VERSION) {
272
273 unit_sw_version = value;
274 sw_version++;
275 }
276 if (spec_id && sw_version)
277 break;
278 }
279
280 /*
281 * Refer to IEEE1212 (pages 90-92) for information regarding various
282 * id's. Module_Vendor_Id is required. Node_Vendor_Id is optional and
283 * if not implemented, its assumed value is Module_Vendor_Id.
284 * Module_Spec_Id is optional and if not implemented, its assumed value
285 * is Module_Vendor_Id. Node_Spec_Id is optional, and if not
286 * implemented, its assumed value is Node_Vendor_Id. Unit_Spec_Id is
287 * optional, and if not implemented, its assumed value is
288 * Node_Vendor_Id.
289 */
290 if (node_ven == 0) {
291 node_vendor_id = module_vendor_id;
292 node_ven++;
293 }
294
295 if (node_spec == 0) {
296 node_spec_id = node_vendor_id;
297 node_spec++;
298 }
299
300 if (mod_spec == 0) {
301 module_spec_id = module_vendor_id;
302 mod_spec++;
303 }
304
305 if (spec_id == 0) {
306 unit_spec_id = node_vendor_id;
307 spec_id++;
308 }
309
310 i = 0;
311 if (sw_version != 0) {
312 buf[i] = data[i];
313 (void) sprintf(data[i++], fmt, unit_spec_id, unit_sw_version);
314 }
315 if (node_sw != 0) {
316 buf[i] = data[i];
317 (void) sprintf(data[i++], fmt, node_spec_id, node_sw_version);
318 }
319 if (node_hw != 0) {
320 buf[i] = data[i];
321 (void) sprintf(data[i++], fmt, node_vendor_id, node_hw_version);
322 }
323 if (mod_sw != 0) {
324 buf[i] = data[i];
325 (void) sprintf(data[i++], fmt, module_spec_id,
326 module_sw_version);
327 }
328 if (mod_hw != 0) {
329 buf[i] = data[i];
330 (void) sprintf(data[i++], fmt, module_vendor_id,
331 module_hw_version);
332 }
333
334 result = ndi_prop_update_string_array(DDI_DEV_T_NONE, target_dip,
335 "compatible", (char **)&buf, i);
336 if (result != NDI_SUCCESS) {
337 cmn_err(CE_NOTE, "!Unable to add \"compatible\" property"
338 " (node's GUID %08x%08x)", node->node_guid_hi,
339 node->node_guid_lo);
340 #if defined(DEBUG)
341 cmn_err(CE_CONT, "!Error code %d; nelements %d", result, i);
342 for (j = 0; j < i; j++) {
343 cmn_err(CE_CONT, "!buf[%d]: %s", j, buf[j]);
344 }
345 #endif
346 ndi_prop_remove_all(target_dip);
347 (void) ndi_devi_free(target_dip);
348 TNF_PROBE_4(s1394_create_devinfo_fail_compat,
349 S1394_TNF_SL_HOTPLUG_ERROR, "", tnf_uint, guid_hi,
350 node->node_guid_hi, tnf_uint, guid_lo, node->node_guid_lo,
351 tnf_int, error, result, tnf_int, nelements, i);
352 TNF_PROBE_0_DEBUG(s1394_create_devinfo_exit,
353 S1394_TNF_SL_HOTPLUG_STACK, "");
354 return (NULL);
355 }
356
357 for (j = 0; j < i; j++) {
358 TNF_PROBE_2_DEBUG(s1394_create_devinfo_props,
359 S1394_TNF_SL_HOTPLUG_STACK, "",
360 tnf_int, compat_index, j,
361 tnf_string, compat_prop, buf[j]);
362 }
363
364 /* GUID,ADDR */
365 reg[0] = node->node_guid_hi;
366 reg[1] = node->node_guid_lo;
367 s1394_cfgrom_parse_unit_dir(unit_dir, &reg[2], &reg[3], &reg[4],
368 &reg[5]);
369
370 reg[3] = nunit;
371
372 result = ndi_prop_update_int_array(DDI_DEV_T_NONE, target_dip, "reg",
373 (int *)reg, 6);
374 if (result != NDI_SUCCESS) {
375 cmn_err(CE_NOTE, "!Unable to add \"reg\" property");
376 #if defined(DEBUG)
377 cmn_err(CE_CONT, "!Error code %d", result);
378 for (j = 0; j < 6; j++) {
379 cmn_err(CE_CONT, "!reg[%d]: 0x%08x", j, reg[j]);
380 }
381 #endif
382 ndi_prop_remove_all(target_dip);
383 (void) ndi_devi_free(target_dip);
384 TNF_PROBE_3(s1394_create_devinfo_fail_reg,
385 S1394_TNF_SL_HOTPLUG_ERROR, "", tnf_uint, guid_hi,
386 node->node_guid_hi, tnf_uint, guid_lo, node->node_guid_lo,
387 tnf_int, error, result);
388 TNF_PROBE_0_DEBUG(s1394_create_devinfo_exit,
389 S1394_TNF_SL_HOTPLUG_STACK, "");
390 return (NULL);
391 }
392
393 TNF_PROBE_1_DEBUG(s1394_create_devinfo_exit,
394 S1394_TNF_SL_HOTPLUG_STACK, "",
395 tnf_opaque, target_dip, target_dip);
396
397 return (target_dip);
398 }
399
400 /*
401 * s1394_devi_find()
402 * Searches all children of pdip for a match of name@caddr. Builds the
403 * name and address of each child node by looking up the reg property on
404 * the node and compares the built name@addr with the name@addr passed in.
405 * Returns the child dip if a match is found, otherwise, returns NULL.
406 * NOTE:
407 * This routine is decidedly non-ddi. We had to use this one since
408 * ndi_devi_find() can find only nodes that have valid addr field
409 * set and that won't happen unless the node goes through INITCHILD
410 * (at which time nx1394.c calls ddi_set_name_addr()). If, in future,
411 * the ndi_devi_find() provides a way of looking up nodes using criteria
412 * other than addr, we can get rid of this routine.
413 */
414 /*ARGSUSED*/
415 dev_info_t *
416 s1394_devi_find(dev_info_t *pdip, char *name, char *caddr)
417 {
418 int i, reglen;
419 char addr[32];
420 uint32_t *regptr;
421 dev_info_t *cdip = NULL;
422
423 ASSERT((name != NULL) && (caddr != NULL));
424
425 TNF_PROBE_1_DEBUG(s1394_devi_find_enter, S1394_TNF_SL_HOTPLUG_STACK,
426 "", tnf_string, addr, caddr);
427
428 /*
429 * for each child of this parent, find name and addr and match with
430 * name and caddr passed in.
431 */
432 for (cdip = (dev_info_t *)DEVI(pdip)->devi_child; cdip != NULL;
433 cdip = (dev_info_t *)DEVI(cdip)->devi_sibling) {
434
435 i = ddi_prop_lookup_int_array(DDI_DEV_T_ANY, cdip,
436 DDI_PROP_DONTPASS, "reg", (int **)&regptr,
437 (uint_t *)&reglen);
438
439 if (i != DDI_PROP_SUCCESS)
440 continue;
441
442 /*
443 * Construct addr from the reg property (addr is of the format
444 * GGGGGGGGGGGGGGGG[,AAAAAAAAAAAA], where GGGGGGGGGGGGGGGG is
445 * the address and AAAAAAAAAAAA is the optional unit address)
446 */
447 if (regptr[2] != NULL || regptr[3] != NULL) {
448 (void) sprintf(addr, "%08x%08x,%04x%08x", regptr[0],
449 regptr[1], regptr[2], regptr[3]);
450 } else {
451 (void) sprintf(addr, "%08x%08x", regptr[0], regptr[1]);
452 }
453 ddi_prop_free(regptr);
454
455 if (strcmp(caddr, addr) == 0) {
456 ASSERT(strcmp(ddi_node_name(cdip), name) == 0);
457 break;
458 }
459 }
460
461 if (cdip == NULL) {
462 TNF_PROBE_1(s1394_devi_find_no_match,
463 S1394_TNF_SL_HOTPLUG_ERROR, "", tnf_string, addr, caddr);
464 }
465
466 TNF_PROBE_0_DEBUG(s1394_devi_find_exit, S1394_TNF_SL_HOTPLUG_STACK, "");
467
468 return (cdip);
469 }
470
471 /*
472 * s1394_update_devinfo_tree()
473 * Parses the config rom for the passed in node and creates/updates devinfo's
474 * for each unit directory found. If the devinfo corresponding to a unit
475 * already exists, any insert event callbacks registered for that devinfo
476 * are called (topology tree is unlocked and relocked around these
477 * callbacks). Returns DDI_SUCCESS if everything went fine and DDI_FAILURE
478 * if unable to reacquire the lock after callbacks (relock fails because of
479 * an intervening bus reset or if the services layer kills the bus reset
480 * thread). The node is marked as parsed before returning.
481 */
482 int
483 s1394_update_devinfo_tree(s1394_hal_t *hal, s1394_node_t *node)
484 {
485 dev_info_t *tdip;
486 int j, units, d, lockfail = 0;
487 s1394_target_t *target, *t;
488 uint32_t hi, lo, size_hi, size_lo, type, key, value;
489 uint32_t *ptr, *root_dir, dir_len;
490 t1394_localinfo_t linfo;
491
492 uint32_t *unit_dir_ptrs[32];
493 dev_info_t *devinfo_ptrs[32];
494 uint32_t new_devinfo = 0; /* to keep track of new allocations */
495
496 char caddr[32];
497
498 ASSERT(MUTEX_HELD(&hal->topology_tree_mutex));
499
500 ASSERT(CFGROM_PARSED(node) == B_FALSE);
501 ASSERT(node->cfgrom != NULL);
502
503 TNF_PROBE_2_DEBUG(s1394_update_devinfo_tree_enter,
504 S1394_TNF_SL_HOTPLUG_STACK, "", tnf_int, node_num,
505 node->node_num, tnf_opaque, cfgrom, node->cfgrom);
506
507 /* scan through config rom looking for unit dirs */
508 root_dir = CFGROM_ROOT_DIR(node->cfgrom);
509
510 if (node->cfgrom_valid_size < CFGROM_DIR_LEN(root_dir))
511 dir_len = node->cfgrom_valid_size;
512 else
513 dir_len = CFGROM_DIR_LEN(root_dir);
514
515 CFGROM_TYPE_KEY_VALUE(root_dir[0], type, key, value);
516 if (s1394_valid_dir(hal, node, key, root_dir) == B_FALSE) {
517 cmn_err(CE_NOTE,
518 "!Bad root directory in config rom (node's GUID %08x%08x)",
519 node->node_guid_hi, node->node_guid_lo);
520
521 TNF_PROBE_1_DEBUG(s1394_update_devinfo_tree_exit,
522 S1394_TNF_SL_HOTPLUG_STACK, "", tnf_string, msg,
523 "bad directory");
524
525 SET_CFGROM_PARSED(node);
526 CLEAR_CFGROM_GEN_CHANGED(node); /* if set */
527 CLEAR_CFGROM_NEW_ALLOC(node);
528
529 return (DDI_SUCCESS);
530 }
531
532 for (units = 0, j = 1; j <= dir_len; j++) {
533 CFGROM_TYPE_KEY_VALUE(root_dir[j], type, key, value);
534 if (key == IEEE1212_UNIT_DIRECTORY && type ==
535 IEEE1212_DIRECTORY_TYPE) {
536 ptr = &root_dir[j] + value;
537 if (s1394_valid_dir(hal, node, key, ptr) == B_TRUE) {
538 unit_dir_ptrs[units++] = ptr;
539 } else {
540 cmn_err(CE_NOTE, "!Bad unit directory in config"
541 " rom (node's GUID %08x%08x)",
542 node->node_guid_hi, node->node_guid_lo);
543 TNF_PROBE_2(s1394_update_devinfo_tree_bad_dir,
544 S1394_TNF_SL_HOTPLUG_ERROR, "", tnf_uint,
545 guid_hi, node->node_guid_hi, tnf_uint,
546 guid_lo, node->node_guid_lo);
547 }
548 }
549 }
550
551 for (d = 0, j = 0; j < units; j++) {
552
553 s1394_cfgrom_parse_unit_dir(unit_dir_ptrs[j],
554 &hi, &lo, &size_hi, &size_lo);
555
556 lo = j;
557
558 if (hi || lo) {
559 (void) sprintf(caddr, "%08x%08x,%04x%08x",
560 node->node_guid_hi, node->node_guid_lo, hi, lo);
561 } else {
562 (void) sprintf(caddr, "%08x%08x",
563 node->node_guid_hi, node->node_guid_lo);
564 }
565
566 tdip = s1394_devi_find(hal->halinfo.dip, "unit", caddr);
567 if (tdip != NULL) {
568
569 rw_enter(&hal->target_list_rwlock, RW_WRITER);
570 target = s1394_target_from_dip_locked(hal, tdip);
571 if (target != NULL) {
572 target->target_sibling = NULL;
573 target->on_node = node;
574 target->target_state &= ~S1394_TARG_GONE;
575 target->unit_dir = unit_dir_ptrs[j] - root_dir;
576
577 if ((t = node->target_list) != NULL) {
578 ASSERT(t != target);
579 while (t->target_sibling != NULL) {
580 t = t->target_sibling;
581 ASSERT(t != target);
582 }
583 t->target_sibling = target;
584 } else {
585 node->target_list = target;
586 }
587
588 target->target_list = node->target_list;
589 }
590 rw_exit(&hal->target_list_rwlock);
591
592 s1394_update_unit_dir_location(hal, tdip,
593 unit_dir_ptrs[j] - root_dir);
594
595 } else {
596 /* create devinfo for unit@caddr */
597 tdip = s1394_create_devinfo(hal, node,
598 unit_dir_ptrs[j], j);
599 if (tdip != NULL) {
600 new_devinfo |= (1 << d);
601 s1394_update_unit_dir_location(hal, tdip,
602 unit_dir_ptrs[j] - root_dir);
603 }
604 }
605 if (tdip != NULL)
606 devinfo_ptrs[d++] = tdip;
607 }
608
609 ASSERT(MUTEX_HELD(&hal->topology_tree_mutex));
610 /* Online all valid units */
611 for (j = 0; j < d; j++) {
612 if ((new_devinfo & (1 << j)) == 0) {
613 linfo.bus_generation = hal->generation_count;
614 linfo.local_nodeID = hal->node_id;
615 }
616 /* don't need to drop topology_tree_mutex across ndi calls */
617 (void) ndi_devi_online_async(devinfo_ptrs[j], 0);
618 if ((new_devinfo & (1 << j)) == 0) {
619 /*
620 * send an insert event if this an existing devinfo.
621 * drop and reacquire topology_tree_mutex across
622 * the event calls
623 */
624 s1394_unlock_tree(hal);
625 s1394_send_insert_event(hal, devinfo_ptrs[j], &linfo);
626 if (s1394_lock_tree(hal) != DDI_SUCCESS) {
627 TNF_PROBE_4(s1394_update_devinfo_tree_lock_fail,
628 S1394_TNF_SL_HOTPLUG_ERROR, "",
629 tnf_int, node_num, node->node_num,
630 tnf_opaque, cfgrom, node->cfgrom,
631 tnf_int, unit, j,
632 tnf_opaque, devinfo, devinfo_ptrs[j]);
633 lockfail = 1;
634 break;
635 }
636 }
637 }
638
639 if (lockfail) {
640 TNF_PROBE_0_DEBUG(s1394_update_devinfo_tree_exit,
641 S1394_TNF_SL_HOTPLUG_ERROR, "");
642 return (DDI_FAILURE);
643 }
644
645 SET_CFGROM_PARSED(node);
646 CLEAR_CFGROM_GEN_CHANGED(node); /* if set */
647 CLEAR_CFGROM_NEW_ALLOC(node);
648
649 TNF_PROBE_0_DEBUG(s1394_update_devinfo_tree_exit,
650 S1394_TNF_SL_HOTPLUG_STACK, "");
651
652 return (DDI_SUCCESS);
653 }
654
655 /*
656 * s1394_offline_node()
657 * Offlines a node. This involves marking all targets attached to the
658 * node as gone, invoking any remove event callbacks and calling
659 * ndi_devi_offline to mark the devinfo as OFFLINE (for each unit
660 * directory on the node). The tree is unlocked and relocked around
661 * the callbacks. If unable to relock the tree, DDI_FAILURE, else
662 * returns DDI_SUCCESS.
663 */
664 int
665 s1394_offline_node(s1394_hal_t *hal, s1394_node_t *node)
666 {
667 s1394_target_t *t;
668 dev_info_t *tdip;
669 int j, d, units;
670 uint32_t *unit_dir_ptrs[32];
671 dev_info_t *devinfo_ptrs[32];
672 t1394_localinfo_t linfo;
673 uint_t node_num;
674 uint32_t *ptr, *root_dir, dir_len;
675 uint32_t hi, lo, size_hi, size_lo, type, key, value;
676 char caddr[32];
677
678 node_num = node->node_num;
679
680 TNF_PROBE_1_DEBUG(s1394_offline_node_enter, S1394_TNF_SL_HOTPLUG_STACK,
681 "", tnf_uint, node_num, node_num);
682
683 ASSERT(MUTEX_HELD(&hal->topology_tree_mutex));
684
685 d = 0;
686 rw_enter(&hal->target_list_rwlock, RW_WRITER);
687 t = node->target_list;
688 while (t != NULL) {
689 TNF_PROBE_2(s1394_process_old_tree_mark,
690 S1394_TNF_SL_HOTPLUG_STACK, "", tnf_int, node_num, node_num,
691 tnf_opaque, target, t);
692 t->target_state |= S1394_TARG_GONE;
693 t->on_node = NULL;
694 t = t->target_sibling;
695 }
696 rw_exit(&hal->target_list_rwlock);
697
698 /* scan through config rom looking for unit dirs */
699 root_dir = CFGROM_ROOT_DIR(node->cfgrom);
700
701 if (node->cfgrom_valid_size < CFGROM_DIR_LEN(root_dir))
702 dir_len = node->cfgrom_valid_size;
703 else
704 dir_len = CFGROM_DIR_LEN(root_dir);
705
706 CFGROM_TYPE_KEY_VALUE(root_dir[0], type, key, value);
707
708 for (units = 0, j = 1; j <= dir_len; j++) {
709 CFGROM_TYPE_KEY_VALUE(root_dir[j], type, key, value);
710 if (key == IEEE1212_UNIT_DIRECTORY && type ==
711 IEEE1212_DIRECTORY_TYPE) {
712 ptr = &root_dir[j] + value;
713 if (s1394_valid_dir(hal, node, key, ptr) == B_TRUE) {
714 unit_dir_ptrs[units++] = ptr;
715 }
716 }
717 }
718
719 for (d = 0, j = 0; j < units; j++) {
720
721 s1394_cfgrom_parse_unit_dir(unit_dir_ptrs[j],
722 &hi, &lo, &size_hi, &size_lo);
723
724 lo = j;
725
726 if (hi || lo) {
727 (void) sprintf(caddr, "%08x%08x,%04x%08x",
728 node->node_guid_hi, node->node_guid_lo, hi, lo);
729 } else {
730 (void) sprintf(caddr, "%08x%08x",
731 node->node_guid_hi, node->node_guid_lo);
732 }
733
734 if ((tdip = s1394_devi_find(hal->halinfo.dip, "unit", caddr)) !=
735 NULL)
736 devinfo_ptrs[d++] = tdip;
737 }
738
739 node->old_node = NULL;
740
741 linfo.bus_generation = hal->generation_count;
742 linfo.local_nodeID = hal->node_id;
743
744 for (j = 0; j < d; j++) {
745 s1394_unlock_tree(hal);
746
747 TNF_PROBE_2(s1394_offline_node,
748 S1394_TNF_SL_HOTPLUG_STACK, "", tnf_int, node_num, node_num,
749 tnf_opaque, devinfo, devinfo_ptrs[j]);
750
751 s1394_send_remove_event(hal, devinfo_ptrs[j], &linfo);
752 (void) ndi_devi_offline(devinfo_ptrs[j], NDI_DEVI_REMOVE);
753 if (s1394_lock_tree(hal) != DDI_SUCCESS) {
754 TNF_PROBE_2(s1394_offline_node,
755 S1394_TNF_SL_HOTPLUG_ERROR, "", tnf_string, msg,
756 "unlock to relock tree", tnf_uint, node_num,
757 node_num);
758 TNF_PROBE_0_DEBUG(s1394_offline_node_exit,
759 S1394_TNF_SL_HOTPLUG_STACK, "");
760 return (DDI_FAILURE);
761 }
762 }
763
764 ASSERT(MUTEX_HELD(&hal->topology_tree_mutex));
765 TNF_PROBE_0_DEBUG(s1394_offline_node_exit, S1394_TNF_SL_HOTPLUG_STACK,
766 "");
767 return (DDI_SUCCESS);
768 }
769
770 /*
771 * s1394_process_topology_tree()
772 * Walks the topology tree, processing each node. If node that has
773 * already been parsed, updates the generation property on all devinfos
774 * for the node. Also, if the node exists in both old & new trees, ASSERTS
775 * that both point to the same config rom. If the node has valid config
776 * rom but hasn't been parsed yet, calls s1394_update_devinfo_tree()
777 * to parse and create devinfos for the node. Kicks off further config
778 * rom reading if only the bus info block for the node is read.
779 * Returns DDI_SUCCESS if everything went fine, else returns DDI_FAILURE
780 * (for eg. unable to reacquire the tree lock etc). wait_for_cbs argument
781 * tells the caller if some completions can be expected. wait_gen tells
782 * the generation the commands were issued at.
783 */
784 int
785 s1394_process_topology_tree(s1394_hal_t *hal, int *wait_for_cbs,
786 uint_t *wait_gen)
787 {
788 int i;
789 uint_t hal_node_num, number_of_nodes;
790 s1394_node_t *node, *onode;
791 s1394_status_t status;
792
793 ASSERT(MUTEX_NOT_HELD(&hal->topology_tree_mutex));
794
795 TNF_PROBE_0_DEBUG(s1394_process_topology_tree_enter,
796 S1394_TNF_SL_HOTPLUG_STACK, "");
797
798 if (s1394_lock_tree(hal) != DDI_SUCCESS) {
799 TNF_PROBE_0(s1394_process_topology_tree_lock_failed,
800 S1394_TNF_SL_HOTPLUG_ERROR, "");
801 TNF_PROBE_0_DEBUG(s1394_process_topology_tree_exit,
802 S1394_TNF_SL_HOTPLUG_STACK, "");
803 return (DDI_FAILURE);
804 }
805
806 hal_node_num = IEEE1394_NODE_NUM(hal->node_id);
807 hal->cfgroms_being_read = 0;
808 number_of_nodes = hal->number_of_nodes;
809 s1394_unlock_tree(hal);
810
811 for (i = 0; i < number_of_nodes; i++) {
812
813 if (i == hal_node_num)
814 continue;
815 if (s1394_lock_tree(hal) != DDI_SUCCESS) {
816 return (DDI_FAILURE);
817 }
818 node = &hal->topology_tree[i];
819
820 TNF_PROBE_4_DEBUG(s1394_process_topology_tree,
821 S1394_TNF_SL_HOTPLUG_STACK, "",
822 tnf_int, node_num, i,
823 tnf_int, parsed, CFGROM_PARSED(node),
824 tnf_int, matched, NODE_MATCHED(node),
825 tnf_int, visited, NODE_VISITED(node));
826
827 if (LINK_ACTIVE(node) == B_FALSE) {
828 s1394_unlock_tree(hal);
829 continue;
830 }
831 if (node->cfgrom == NULL) {
832 s1394_unlock_tree(hal);
833 continue;
834 }
835
836 onode = node->old_node;
837
838 if (onode != NULL && onode->cfgrom != NULL && node->cfgrom !=
839 NULL) {
840 /*
841 * onode->cfgrom != node->cfgrom should have been
842 * handled by s1394_match_GUID()!!!
843 */
844 if (onode->cfgrom != node->cfgrom)
845 TNF_PROBE_5(s1394_process_topology_tree_err,
846 S1394_TNF_SL_HOTPLUG_ERROR, "",
847 tnf_int, node_num, i, tnf_int, gen_changed,
848 CFGROM_GEN_CHANGED(node), tnf_int, parsed,
849 CFGROM_PARSED(node), tnf_opaque, old_cfgrom,
850 onode->cfgrom, tnf_opaque, new_cfgrom,
851 node->cfgrom);
852 ASSERT(onode->cfgrom == node->cfgrom);
853 }
854
855 if (CFGROM_PARSED(node) == B_FALSE && CFGROM_ALL_READ(node) ==
856 B_TRUE) {
857 ASSERT((node->cfgrom_size <
858 IEEE1394_CONFIG_ROM_QUAD_SZ) ||
859 NODE_MATCHED(node) == B_TRUE);
860 rw_enter(&hal->target_list_rwlock, RW_READER);
861 ASSERT(node->target_list == NULL);
862 rw_exit(&hal->target_list_rwlock);
863 if (s1394_update_devinfo_tree(hal, node) ==
864 DDI_FAILURE) {
865 ASSERT(MUTEX_NOT_HELD(
866 &hal->topology_tree_mutex));
867 TNF_PROBE_1(s1394_process_topology_tree,
868 S1394_TNF_SL_HOTPLUG_ERROR, "", tnf_string,
869 msg, "failure from update devinfo");
870 TNF_PROBE_0_DEBUG(
871 s1394_process_topology_tree_exit,
872 S1394_TNF_SL_HOTPLUG_STACK, "");
873 return (DDI_FAILURE);
874 }
875 } else if (CFGROM_PARSED(node) == B_FALSE && CFGROM_BIB_READ(
876 node) == B_TRUE) {
877 if (s1394_read_rest_of_cfgrom(hal, node, &status) !=
878 DDI_SUCCESS) {
879 TNF_PROBE_1(s1394_process_topology_tree,
880 S1394_TNF_SL_HOTPLUG_ERROR, "", tnf_string,
881 msg, "failure reading rest of cfgrom");
882 if ((status & S1394_LOCK_FAILED) == 0) {
883 ASSERT(MUTEX_HELD(&hal->
884 topology_tree_mutex));
885 *wait_for_cbs = 0;
886 s1394_unlock_tree(hal);
887 }
888 TNF_PROBE_0_DEBUG(
889 s1394_process_topology_tree_exit,
890 S1394_TNF_SL_HOTPLUG_STACK, "");
891 return (DDI_FAILURE);
892 } else {
893 *wait_for_cbs = 1;
894 *wait_gen = hal->br_cfgrom_read_gen;
895 }
896 }
897
898 s1394_unlock_tree(hal);
899 }
900
901 /*
902 * flag the tree as processed; if a single bus reset happens after
903 * this, we will use tree matching.
904 */
905 if (s1394_lock_tree(hal) != DDI_SUCCESS) {
906 TNF_PROBE_1(s1394_process_topology_tree,
907 S1394_TNF_SL_HOTPLUG_ERROR, "", tnf_string,
908 msg, "relock failed while marking tree processed");
909 TNF_PROBE_0_DEBUG(s1394_process_topology_tree_exit,
910 S1394_TNF_SL_HOTPLUG_STACK, "");
911 return (DDI_FAILURE);
912 }
913 hal->topology_tree_processed = B_TRUE;
914 s1394_unlock_tree(hal);
915
916 TNF_PROBE_1_DEBUG(s1394_process_topology_tree_exit,
917 S1394_TNF_SL_HOTPLUG_STACK, "", tnf_int, hal_instance,
918 ddi_get_instance(hal->halinfo.dip));
919
920 return (DDI_SUCCESS);
921 }
922
923 /*
924 * s1394_process_old_tree()
925 * Walks through the old tree and offlines nodes that are removed. Nodes
926 * with an active link in the old tree but link powered off in the current
927 * generation are also offlined, as well as nodes with invalid config
928 * rom in current generation.
929 * The topology tree is locked/unlocked while walking through all the nodes;
930 * if the locking fails at any stage, stops further walking and returns
931 * DDI_FAILURE. Returns DDI_SUCCESS if everything went fine.
932 */
933 int
934 s1394_process_old_tree(s1394_hal_t *hal)
935 {
936 int i;
937 uint_t hal_node_num_old, old_number_of_nodes;
938 s1394_node_t *onode;
939
940 TNF_PROBE_0_DEBUG(s1394_process_old_tree_enter,
941 S1394_TNF_SL_HOTPLUG_STACK, "");
942
943 /*
944 * NODE_MATCHED(onode) == 0 indicates this node doesn't exist
945 * any more.
946 */
947 ASSERT(MUTEX_NOT_HELD(&hal->topology_tree_mutex));
948
949 if (s1394_lock_tree(hal) != DDI_SUCCESS) {
950 TNF_PROBE_0(s1394_process_old_tree_lock_failed,
951 S1394_TNF_SL_HOTPLUG_ERROR, "");
952 TNF_PROBE_0_DEBUG(s1394_process_old_tree_exit,
953 S1394_TNF_SL_HOTPLUG_STACK, "");
954 return (DDI_FAILURE);
955 }
956 hal_node_num_old = IEEE1394_NODE_NUM(hal->old_node_id);
957 old_number_of_nodes = hal->old_number_of_nodes;
958 s1394_unlock_tree(hal);
959
960 for (i = 0; i < old_number_of_nodes; i++) {
961
962 if (i == hal_node_num_old)
963 continue;
964 if (s1394_lock_tree(hal) != DDI_SUCCESS) {
965 TNF_PROBE_2(s1394_process_old_tree,
966 S1394_TNF_SL_HOTPLUG_ERROR, "", tnf_string, msg,
967 "lock failed while processing node", tnf_uint,
968 node_num, i);
969 TNF_PROBE_0_DEBUG(s1394_process_old_tree_exit,
970 S1394_TNF_SL_HOTPLUG_STACK, "");
971 return (DDI_FAILURE);
972 }
973
974 onode = &hal->old_tree[i];
975
976 if (onode->cfgrom == NULL) {
977 CLEAR_CFGROM_STATE(onode);
978 s1394_unlock_tree(hal);
979 continue;
980 }
981
982 TNF_PROBE_1_DEBUG(s1394_process_old_tree,
983 S1394_TNF_SL_HOTPLUG_STACK, "", tnf_opaque,
984 cfgrom, onode->cfgrom);
985
986 TNF_PROBE_5_DEBUG(s1394_process_old_tree,
987 S1394_TNF_SL_HOTPLUG_STACK, "", tnf_int,
988 node_num, i, tnf_int, parsed, CFGROM_PARSED(onode), tnf_int,
989 matched, NODE_MATCHED(onode), tnf_int, visited,
990 NODE_VISITED(onode), tnf_int, generation_changed,
991 CFGROM_GEN_CHANGED(onode));
992
993 /*
994 * onode->cur_node == NULL iff we couldn't read cfgrom in the
995 * current generation in non-tree matching case (and thus
996 * match_GUIDs couldn't set cur_node).
997 */
998 if (NODE_MATCHED(onode) == B_FALSE || (onode->cur_node ==
999 NULL || ((CFGROM_VALID(onode) == B_TRUE &&
1000 CFGROM_VALID(onode->cur_node) == B_FALSE) ||
1001 (LINK_ACTIVE(onode) == B_TRUE && LINK_ACTIVE(onode->
1002 cur_node) == B_FALSE)))) {
1003
1004 if (onode->cur_node != NULL && CFGROM_VALID(onode) ==
1005 B_TRUE &&
1006 CFGROM_VALID(onode->cur_node) == B_FALSE) {
1007 TNF_PROBE_1_DEBUG(
1008 s1394_process_old_tree_invalid_cfgrom,
1009 S1394_TNF_SL_HOTPLUG_STACK, "",
1010 tnf_int, node_num, i);
1011 }
1012 if (onode->cur_node != NULL && LINK_ACTIVE(onode) ==
1013 B_TRUE && LINK_ACTIVE(onode->cur_node) == B_FALSE) {
1014 TNF_PROBE_1_DEBUG(
1015 s1394_process_old_tree_link_off,
1016 S1394_TNF_SL_HOTPLUG_STACK,
1017 "", tnf_int, node_num, i);
1018 }
1019 if (s1394_offline_node(hal, onode) != DDI_SUCCESS) {
1020 TNF_PROBE_2(s1394_process_old_tree,
1021 S1394_TNF_SL_HOTPLUG_ERROR, "", tnf_string,
1022 msg, "failure from offline node", tnf_uint,
1023 node_num, i);
1024 TNF_PROBE_0_DEBUG(s1394_process_old_tree_exit,
1025 S1394_TNF_SL_HOTPLUG_STACK, "");
1026 return (DDI_FAILURE);
1027 }
1028 s1394_free_cfgrom(hal, onode, S1394_FREE_CFGROM_OLD);
1029 }
1030
1031 s1394_unlock_tree(hal);
1032 }
1033
1034 ASSERT(MUTEX_NOT_HELD(&hal->topology_tree_mutex));
1035
1036 TNF_PROBE_0_DEBUG(s1394_process_old_tree_exit,
1037 S1394_TNF_SL_HOTPLUG_STACK, "");
1038
1039 return (DDI_SUCCESS);
1040 }
1041
1042 /*
1043 * s1394_update_unit_dir_location()
1044 * Updates the unit-dir-offset property on the devinfo.
1045 * NOTE: ndi_prop_update_int() is interrupt callable (and thus won't block);
1046 * so, the caller doesn't drop topology_tree_mutex when calling this routine.
1047 */
1048 /*ARGSUSED*/
1049 static void
1050 s1394_update_unit_dir_location(s1394_hal_t *hal, dev_info_t *tdip,
1051 uint_t offset)
1052 {
1053 ASSERT(MUTEX_HELD(&hal->topology_tree_mutex));
1054 ASSERT(tdip != NULL);
1055
1056 TNF_PROBE_1_DEBUG(s1394_update_unit_dir_location_enter,
1057 S1394_TNF_SL_HOTPLUG_STACK, "", tnf_uint, offset, offset);
1058 (void) ndi_prop_update_int(DDI_DEV_T_NONE, tdip, "unit-dir-offset",
1059 offset);
1060 TNF_PROBE_0_DEBUG(s1394_update_unit_dir_location_exit,
1061 S1394_TNF_SL_HOTPLUG_STACK, "");
1062 }
1063
1064 /*
1065 * s1394_add_target_to_node()
1066 * adds target to the list of targets hanging off the node. Figures out
1067 * the node by searching the topology tree for the GUID corresponding
1068 * to the target. Points on_node field of target structure at the node.
1069 */
1070 void
1071 s1394_add_target_to_node(s1394_target_t *target)
1072 {
1073 s1394_target_t *t;
1074 s1394_hal_t *hal;
1075 uint32_t guid_hi;
1076 uint32_t guid_lo;
1077 int i;
1078 char name[MAXNAMELEN];
1079 char *ptr;
1080
1081 TNF_PROBE_0_DEBUG(s1394_add_target_to_node_enter,
1082 S1394_TNF_SL_HOTPLUG_STACK, "");
1083
1084 hal = target->on_hal;
1085 ASSERT(hal != NULL);
1086
1087 /* Topology tree must be locked when it gets here! */
1088 ASSERT(MUTEX_HELD(&hal->topology_tree_mutex));
1089
1090 /* target_list_rwlock should be held in write mode */
1091 ASSERT(rw_read_locked(&target->on_hal->target_list_rwlock) == 0);
1092
1093 if ((ptr = ddi_get_name_addr(target->target_dip)) == NULL) {
1094 TNF_PROBE_0_DEBUG(s1394_add_target_to_node_exit_no_name,
1095 S1394_TNF_SL_HOTPLUG_STACK, "");
1096 return;
1097 }
1098
1099 (void) sprintf(name, ptr);
1100 /* Drop the ,<ADDR> part, if present */
1101 if ((ptr = strchr(name, ',')) != NULL)
1102 *ptr = '\0';
1103
1104 ptr = name;
1105 guid_hi = s1394_stoi(ptr, 8, 16);
1106 guid_lo = s1394_stoi(ptr + 8, 8, 16);
1107
1108 /* Search the HAL's node list for this GUID */
1109 for (i = 0; i < hal->number_of_nodes; i++) {
1110 if (CFGROM_VALID(&hal->topology_tree[i]) == B_TRUE) {
1111 ASSERT(hal->topology_tree[i].cfgrom != NULL);
1112
1113 if ((hal->topology_tree[i].node_guid_hi == guid_hi) &&
1114 (hal->topology_tree[i].node_guid_lo == guid_lo)) {
1115 target->on_node = &hal->topology_tree[i];
1116 if ((t = hal->topology_tree[i].target_list) !=
1117 NULL) {
1118 ASSERT(t != target);
1119 while (t->target_sibling != NULL) {
1120 t = t->target_sibling;
1121 ASSERT(t != target);
1122 }
1123 t->target_sibling = target;
1124 } else {
1125 hal->topology_tree[i].target_list =
1126 target;
1127 }
1128
1129 /*
1130 * update target_list in all targets on the
1131 * node
1132 */
1133 t = hal->topology_tree[i].target_list;
1134 while (t != NULL) {
1135 t->target_list =
1136 hal->topology_tree[i].target_list;
1137 t = t->target_sibling;
1138 }
1139 break;
1140 }
1141 }
1142 }
1143
1144 TNF_PROBE_0_DEBUG(s1394_add_target_to_node_exit,
1145 S1394_TNF_SL_HOTPLUG_STACK, "");
1146 }
1147
1148 /*
1149 * s1394_remove_target_from_node()
1150 * Removes target from the corresponding node's target_list.
1151 */
1152 void
1153 s1394_remove_target_from_node(s1394_target_t *target)
1154 {
1155 s1394_target_t *t, *t1;
1156 s1394_hal_t *hal;
1157
1158 TNF_PROBE_0_DEBUG(s1394_remove_target_from_node_enter,
1159 S1394_TNF_SL_HOTPLUG_STACK, "");
1160
1161 hal = target->on_hal;
1162 ASSERT(hal != NULL);
1163
1164 /* Topology tree must be locked when it gets here! */
1165 ASSERT(MUTEX_HELD(&hal->topology_tree_mutex));
1166
1167 /* target_list_rwlock should be held in write mode */
1168 ASSERT(rw_read_locked(&target->on_hal->target_list_rwlock) == 0);
1169
1170 if (target->on_node == NULL) {
1171 TNF_PROBE_1_DEBUG(s1394_remove_target_from_node_NULL,
1172 S1394_TNF_SL_HOTPLUG_STACK, "",
1173 tnf_uint, target_state, target->target_state);
1174 }
1175
1176 t = target->target_list;
1177 t1 = NULL;
1178 while (t != NULL) {
1179 if (t == target) {
1180 if (t1 == NULL) {
1181 target->target_list = t->target_sibling;
1182 } else {
1183 t1->target_sibling = t->target_sibling;
1184 }
1185 break;
1186 }
1187 t1 = t;
1188 t = t->target_sibling;
1189 }
1190 /* Update the target_list pointer in all the targets */
1191 if (target->on_node != NULL)
1192 target->on_node->target_list = target->target_list;
1193
1194 t = t1 = target->target_list;
1195 while (t != NULL) {
1196 t->target_list = t1;
1197 t = t->target_sibling;
1198 }
1199
1200 target->on_node = NULL;
1201 target->target_sibling = NULL;
1202
1203 TNF_PROBE_0_DEBUG(s1394_remove_target_from_node_exit,
1204 S1394_TNF_SL_HOTPLUG_STACK, "");
1205 }
Unleashed OS