Commit | Line | Data |
---|---|---|
1a59d1b8 | 1 | // SPDX-License-Identifier: GPL-2.0-or-later |
c781c06d KH |
2 | /* |
3 | * Incremental bus scan, based on bus topology | |
3038e353 KH |
4 | * |
5 | * Copyright (C) 2004-2006 Kristian Hoegsberg <krh@bitplanet.net> | |
3038e353 KH |
6 | */ |
7 | ||
e8ca9702 | 8 | #include <linux/bug.h> |
3038e353 | 9 | #include <linux/errno.h> |
77c9a5da SR |
10 | #include <linux/firewire.h> |
11 | #include <linux/firewire-constants.h> | |
e8ca9702 SR |
12 | #include <linux/jiffies.h> |
13 | #include <linux/kernel.h> | |
14 | #include <linux/list.h> | |
15 | #include <linux/module.h> | |
16 | #include <linux/slab.h> | |
17 | #include <linux/spinlock.h> | |
e8ca9702 | 18 | |
60063497 | 19 | #include <linux/atomic.h> |
cb7c96da | 20 | #include <asm/byteorder.h> |
e8ca9702 | 21 | |
77c9a5da | 22 | #include "core.h" |
3038e353 | 23 | |
a77754a7 KH |
24 | #define SELF_ID_PHY_ID(q) (((q) >> 24) & 0x3f) |
25 | #define SELF_ID_EXTENDED(q) (((q) >> 23) & 0x01) | |
26 | #define SELF_ID_LINK_ON(q) (((q) >> 22) & 0x01) | |
27 | #define SELF_ID_GAP_COUNT(q) (((q) >> 16) & 0x3f) | |
28 | #define SELF_ID_PHY_SPEED(q) (((q) >> 14) & 0x03) | |
29 | #define SELF_ID_CONTENDER(q) (((q) >> 11) & 0x01) | |
30 | #define SELF_ID_PHY_INITIATOR(q) (((q) >> 1) & 0x01) | |
31 | #define SELF_ID_MORE_PACKETS(q) (((q) >> 0) & 0x01) | |
3038e353 | 32 | |
a77754a7 | 33 | #define SELF_ID_EXT_SEQUENCE(q) (((q) >> 20) & 0x07) |
3038e353 | 34 | |
77c9a5da SR |
35 | #define SELFID_PORT_CHILD 0x3 |
36 | #define SELFID_PORT_PARENT 0x2 | |
37 | #define SELFID_PORT_NCONN 0x1 | |
38 | #define SELFID_PORT_NONE 0x0 | |
39 | ||
3038e353 KH |
40 | static u32 *count_ports(u32 *sid, int *total_port_count, int *child_port_count) |
41 | { | |
42 | u32 q; | |
43 | int port_type, shift, seq; | |
44 | ||
45 | *total_port_count = 0; | |
46 | *child_port_count = 0; | |
47 | ||
48 | shift = 6; | |
49 | q = *sid; | |
50 | seq = 0; | |
51 | ||
52 | while (1) { | |
53 | port_type = (q >> shift) & 0x03; | |
54 | switch (port_type) { | |
55 | case SELFID_PORT_CHILD: | |
56 | (*child_port_count)++; | |
eba6120d | 57 | /* fall through */ |
3038e353 KH |
58 | case SELFID_PORT_PARENT: |
59 | case SELFID_PORT_NCONN: | |
60 | (*total_port_count)++; | |
61 | case SELFID_PORT_NONE: | |
62 | break; | |
63 | } | |
64 | ||
65 | shift -= 2; | |
66 | if (shift == 0) { | |
a77754a7 | 67 | if (!SELF_ID_MORE_PACKETS(q)) |
3038e353 KH |
68 | return sid + 1; |
69 | ||
70 | shift = 16; | |
71 | sid++; | |
72 | q = *sid; | |
73 | ||
c781c06d KH |
74 | /* |
75 | * Check that the extra packets actually are | |
3038e353 KH |
76 | * extended self ID packets and that the |
77 | * sequence numbers in the extended self ID | |
c781c06d KH |
78 | * packets increase as expected. |
79 | */ | |
3038e353 | 80 | |
a77754a7 KH |
81 | if (!SELF_ID_EXTENDED(q) || |
82 | seq != SELF_ID_EXT_SEQUENCE(q)) | |
3038e353 KH |
83 | return NULL; |
84 | ||
85 | seq++; | |
86 | } | |
87 | } | |
88 | } | |
89 | ||
90 | static int get_port_type(u32 *sid, int port_index) | |
91 | { | |
92 | int index, shift; | |
93 | ||
94 | index = (port_index + 5) / 8; | |
95 | shift = 16 - ((port_index + 5) & 7) * 2; | |
96 | return (sid[index] >> shift) & 0x03; | |
97 | } | |
98 | ||
95688e97 | 99 | static struct fw_node *fw_node_create(u32 sid, int port_count, int color) |
3038e353 KH |
100 | { |
101 | struct fw_node *node; | |
102 | ||
acafe7e3 | 103 | node = kzalloc(struct_size(node, ports, port_count), GFP_ATOMIC); |
3038e353 KH |
104 | if (node == NULL) |
105 | return NULL; | |
106 | ||
107 | node->color = color; | |
a77754a7 KH |
108 | node->node_id = LOCAL_BUS | SELF_ID_PHY_ID(sid); |
109 | node->link_on = SELF_ID_LINK_ON(sid); | |
110 | node->phy_speed = SELF_ID_PHY_SPEED(sid); | |
c9755e14 | 111 | node->initiated_reset = SELF_ID_PHY_INITIATOR(sid); |
3038e353 KH |
112 | node->port_count = port_count; |
113 | ||
392910cf | 114 | refcount_set(&node->ref_count, 1); |
3038e353 KH |
115 | INIT_LIST_HEAD(&node->link); |
116 | ||
117 | return node; | |
118 | } | |
119 | ||
c781c06d KH |
120 | /* |
121 | * Compute the maximum hop count for this node and it's children. The | |
83db801c KH |
122 | * maximum hop count is the maximum number of connections between any |
123 | * two nodes in the subtree rooted at this node. We need this for | |
124 | * setting the gap count. As we build the tree bottom up in | |
125 | * build_tree() below, this is fairly easy to do: for each node we | |
126 | * maintain the max hop count and the max depth, ie the number of hops | |
127 | * to the furthest leaf. Computing the max hop count breaks down into | |
128 | * two cases: either the path goes through this node, in which case | |
129 | * the hop count is the sum of the two biggest child depths plus 2. | |
130 | * Or it could be the case that the max hop path is entirely | |
131 | * containted in a child tree, in which case the max hop count is just | |
132 | * the max hop count of this child. | |
133 | */ | |
134 | static void update_hop_count(struct fw_node *node) | |
135 | { | |
136 | int depths[2] = { -1, -1 }; | |
137 | int max_child_hops = 0; | |
138 | int i; | |
139 | ||
140 | for (i = 0; i < node->port_count; i++) { | |
dae1a3aa | 141 | if (node->ports[i] == NULL) |
83db801c KH |
142 | continue; |
143 | ||
dae1a3aa SR |
144 | if (node->ports[i]->max_hops > max_child_hops) |
145 | max_child_hops = node->ports[i]->max_hops; | |
83db801c | 146 | |
dae1a3aa | 147 | if (node->ports[i]->max_depth > depths[0]) { |
83db801c | 148 | depths[1] = depths[0]; |
dae1a3aa SR |
149 | depths[0] = node->ports[i]->max_depth; |
150 | } else if (node->ports[i]->max_depth > depths[1]) | |
151 | depths[1] = node->ports[i]->max_depth; | |
83db801c KH |
152 | } |
153 | ||
154 | node->max_depth = depths[0] + 1; | |
155 | node->max_hops = max(max_child_hops, depths[0] + depths[1] + 2); | |
156 | } | |
157 | ||
e5f84f82 SR |
158 | static inline struct fw_node *fw_node(struct list_head *l) |
159 | { | |
160 | return list_entry(l, struct fw_node, link); | |
161 | } | |
83db801c | 162 | |
656b7afd | 163 | /* |
3038e353 KH |
164 | * This function builds the tree representation of the topology given |
165 | * by the self IDs from the latest bus reset. During the construction | |
166 | * of the tree, the function checks that the self IDs are valid and | |
af901ca1 | 167 | * internally consistent. On success this function returns the |
3038e353 KH |
168 | * fw_node corresponding to the local card otherwise NULL. |
169 | */ | |
473d28c7 KH |
170 | static struct fw_node *build_tree(struct fw_card *card, |
171 | u32 *sid, int self_id_count) | |
3038e353 | 172 | { |
93e4fd45 | 173 | struct fw_node *node, *child, *local_node, *irm_node; |
3038e353 | 174 | struct list_head stack, *h; |
473d28c7 | 175 | u32 *next_sid, *end, q; |
3038e353 | 176 | int i, port_count, child_port_count, phy_id, parent_count, stack_depth; |
24d40125 SR |
177 | int gap_count; |
178 | bool beta_repeaters_present; | |
3038e353 KH |
179 | |
180 | local_node = NULL; | |
181 | node = NULL; | |
182 | INIT_LIST_HEAD(&stack); | |
183 | stack_depth = 0; | |
473d28c7 | 184 | end = sid + self_id_count; |
3038e353 | 185 | phy_id = 0; |
93e4fd45 | 186 | irm_node = NULL; |
a77754a7 | 187 | gap_count = SELF_ID_GAP_COUNT(*sid); |
24d40125 | 188 | beta_repeaters_present = false; |
3038e353 KH |
189 | |
190 | while (sid < end) { | |
191 | next_sid = count_ports(sid, &port_count, &child_port_count); | |
192 | ||
193 | if (next_sid == NULL) { | |
26b4950d | 194 | fw_err(card, "inconsistent extended self IDs\n"); |
3038e353 KH |
195 | return NULL; |
196 | } | |
197 | ||
198 | q = *sid; | |
a77754a7 | 199 | if (phy_id != SELF_ID_PHY_ID(q)) { |
26b4950d SR |
200 | fw_err(card, "PHY ID mismatch in self ID: %d != %d\n", |
201 | phy_id, SELF_ID_PHY_ID(q)); | |
3038e353 KH |
202 | return NULL; |
203 | } | |
204 | ||
205 | if (child_port_count > stack_depth) { | |
26b4950d | 206 | fw_err(card, "topology stack underflow\n"); |
3038e353 KH |
207 | return NULL; |
208 | } | |
209 | ||
c781c06d KH |
210 | /* |
211 | * Seek back from the top of our stack to find the | |
212 | * start of the child nodes for this node. | |
213 | */ | |
3038e353 KH |
214 | for (i = 0, h = &stack; i < child_port_count; i++) |
215 | h = h->prev; | |
c1b91ce4 YD |
216 | /* |
217 | * When the stack is empty, this yields an invalid value, | |
218 | * but that pointer will never be dereferenced. | |
219 | */ | |
3038e353 KH |
220 | child = fw_node(h); |
221 | ||
222 | node = fw_node_create(q, port_count, card->color); | |
223 | if (node == NULL) { | |
26b4950d | 224 | fw_err(card, "out of memory while building topology\n"); |
3038e353 KH |
225 | return NULL; |
226 | } | |
227 | ||
228 | if (phy_id == (card->node_id & 0x3f)) | |
229 | local_node = node; | |
230 | ||
a77754a7 | 231 | if (SELF_ID_CONTENDER(q)) |
93e4fd45 | 232 | irm_node = node; |
3038e353 KH |
233 | |
234 | parent_count = 0; | |
235 | ||
236 | for (i = 0; i < port_count; i++) { | |
237 | switch (get_port_type(sid, i)) { | |
238 | case SELFID_PORT_PARENT: | |
c781c06d KH |
239 | /* |
240 | * Who's your daddy? We dont know the | |
3038e353 KH |
241 | * parent node at this time, so we |
242 | * temporarily abuse node->color for | |
243 | * remembering the entry in the | |
244 | * node->ports array where the parent | |
245 | * node should be. Later, when we | |
246 | * handle the parent node, we fix up | |
247 | * the reference. | |
248 | */ | |
249 | parent_count++; | |
250 | node->color = i; | |
251 | break; | |
252 | ||
253 | case SELFID_PORT_CHILD: | |
dae1a3aa | 254 | node->ports[i] = child; |
c781c06d KH |
255 | /* |
256 | * Fix up parent reference for this | |
257 | * child node. | |
258 | */ | |
dae1a3aa | 259 | child->ports[child->color] = node; |
3038e353 KH |
260 | child->color = card->color; |
261 | child = fw_node(child->link.next); | |
262 | break; | |
263 | } | |
264 | } | |
265 | ||
c781c06d KH |
266 | /* |
267 | * Check that the node reports exactly one parent | |
3038e353 | 268 | * port, except for the root, which of course should |
c781c06d KH |
269 | * have no parents. |
270 | */ | |
3038e353 KH |
271 | if ((next_sid == end && parent_count != 0) || |
272 | (next_sid < end && parent_count != 1)) { | |
26b4950d SR |
273 | fw_err(card, "parent port inconsistency for node %d: " |
274 | "parent_count=%d\n", phy_id, parent_count); | |
3038e353 KH |
275 | return NULL; |
276 | } | |
277 | ||
278 | /* Pop the child nodes off the stack and push the new node. */ | |
279 | __list_del(h->prev, &stack); | |
280 | list_add_tail(&node->link, &stack); | |
281 | stack_depth += 1 - child_port_count; | |
282 | ||
24d40125 SR |
283 | if (node->phy_speed == SCODE_BETA && |
284 | parent_count + child_port_count > 1) | |
285 | beta_repeaters_present = true; | |
286 | ||
c781c06d | 287 | /* |
25b1c3d8 SR |
288 | * If PHYs report different gap counts, set an invalid count |
289 | * which will force a gap count reconfiguration and a reset. | |
c781c06d | 290 | */ |
a77754a7 | 291 | if (SELF_ID_GAP_COUNT(q) != gap_count) |
25b1c3d8 | 292 | gap_count = 0; |
83db801c KH |
293 | |
294 | update_hop_count(node); | |
295 | ||
3038e353 KH |
296 | sid = next_sid; |
297 | phy_id++; | |
298 | } | |
299 | ||
300 | card->root_node = node; | |
93e4fd45 | 301 | card->irm_node = irm_node; |
83db801c | 302 | card->gap_count = gap_count; |
24d40125 | 303 | card->beta_repeaters_present = beta_repeaters_present; |
3038e353 KH |
304 | |
305 | return local_node; | |
306 | } | |
307 | ||
a98e2719 KH |
308 | typedef void (*fw_node_callback_t)(struct fw_card * card, |
309 | struct fw_node * node, | |
310 | struct fw_node * parent); | |
3038e353 | 311 | |
53dca511 SR |
312 | static void for_each_fw_node(struct fw_card *card, struct fw_node *root, |
313 | fw_node_callback_t callback) | |
3038e353 KH |
314 | { |
315 | struct list_head list; | |
316 | struct fw_node *node, *next, *child, *parent; | |
317 | int i; | |
318 | ||
319 | INIT_LIST_HEAD(&list); | |
320 | ||
321 | fw_node_get(root); | |
322 | list_add_tail(&root->link, &list); | |
323 | parent = NULL; | |
324 | list_for_each_entry(node, &list, link) { | |
325 | node->color = card->color; | |
326 | ||
327 | for (i = 0; i < node->port_count; i++) { | |
dae1a3aa | 328 | child = node->ports[i]; |
3038e353 KH |
329 | if (!child) |
330 | continue; | |
331 | if (child->color == card->color) | |
332 | parent = child; | |
333 | else { | |
334 | fw_node_get(child); | |
335 | list_add_tail(&child->link, &list); | |
336 | } | |
337 | } | |
338 | ||
339 | callback(card, node, parent); | |
340 | } | |
341 | ||
342 | list_for_each_entry_safe(node, next, &list, link) | |
343 | fw_node_put(node); | |
344 | } | |
345 | ||
53dca511 SR |
346 | static void report_lost_node(struct fw_card *card, |
347 | struct fw_node *node, struct fw_node *parent) | |
3038e353 KH |
348 | { |
349 | fw_node_event(card, node, FW_NODE_DESTROYED); | |
350 | fw_node_put(node); | |
d6f95a3d SR |
351 | |
352 | /* Topology has changed - reset bus manager retry counter */ | |
353 | card->bm_retries = 0; | |
3038e353 KH |
354 | } |
355 | ||
53dca511 SR |
356 | static void report_found_node(struct fw_card *card, |
357 | struct fw_node *node, struct fw_node *parent) | |
3038e353 KH |
358 | { |
359 | int b_path = (node->phy_speed == SCODE_BETA); | |
360 | ||
361 | if (parent != NULL) { | |
748086eb SR |
362 | /* min() macro doesn't work here with gcc 3.4 */ |
363 | node->max_speed = parent->max_speed < node->phy_speed ? | |
364 | parent->max_speed : node->phy_speed; | |
3038e353 KH |
365 | node->b_path = parent->b_path && b_path; |
366 | } else { | |
367 | node->max_speed = node->phy_speed; | |
368 | node->b_path = b_path; | |
369 | } | |
370 | ||
371 | fw_node_event(card, node, FW_NODE_CREATED); | |
d6f95a3d SR |
372 | |
373 | /* Topology has changed - reset bus manager retry counter */ | |
374 | card->bm_retries = 0; | |
3038e353 KH |
375 | } |
376 | ||
377 | void fw_destroy_nodes(struct fw_card *card) | |
378 | { | |
379 | unsigned long flags; | |
380 | ||
381 | spin_lock_irqsave(&card->lock, flags); | |
382 | card->color++; | |
383 | if (card->local_node != NULL) | |
384 | for_each_fw_node(card, card->local_node, report_lost_node); | |
15803478 | 385 | card->local_node = NULL; |
3038e353 KH |
386 | spin_unlock_irqrestore(&card->lock, flags); |
387 | } | |
388 | ||
389 | static void move_tree(struct fw_node *node0, struct fw_node *node1, int port) | |
390 | { | |
391 | struct fw_node *tree; | |
392 | int i; | |
393 | ||
dae1a3aa SR |
394 | tree = node1->ports[port]; |
395 | node0->ports[port] = tree; | |
3038e353 | 396 | for (i = 0; i < tree->port_count; i++) { |
dae1a3aa SR |
397 | if (tree->ports[i] == node1) { |
398 | tree->ports[i] = node0; | |
3038e353 KH |
399 | break; |
400 | } | |
401 | } | |
402 | } | |
403 | ||
656b7afd SR |
404 | /* |
405 | * Compare the old topology tree for card with the new one specified by root. | |
406 | * Queue the nodes and mark them as either found, lost or updated. | |
407 | * Update the nodes in the card topology tree as we go. | |
3038e353 | 408 | */ |
53dca511 | 409 | static void update_tree(struct fw_card *card, struct fw_node *root) |
3038e353 KH |
410 | { |
411 | struct list_head list0, list1; | |
77e55719 | 412 | struct fw_node *node0, *node1, *next1; |
3038e353 KH |
413 | int i, event; |
414 | ||
415 | INIT_LIST_HEAD(&list0); | |
416 | list_add_tail(&card->local_node->link, &list0); | |
417 | INIT_LIST_HEAD(&list1); | |
418 | list_add_tail(&root->link, &list1); | |
419 | ||
420 | node0 = fw_node(list0.next); | |
421 | node1 = fw_node(list1.next); | |
3038e353 KH |
422 | |
423 | while (&node0->link != &list0) { | |
a2cdebe3 | 424 | WARN_ON(node0->port_count != node1->port_count); |
3038e353 | 425 | |
3038e353 KH |
426 | if (node0->link_on && !node1->link_on) |
427 | event = FW_NODE_LINK_OFF; | |
428 | else if (!node0->link_on && node1->link_on) | |
429 | event = FW_NODE_LINK_ON; | |
c9755e14 SR |
430 | else if (node1->initiated_reset && node1->link_on) |
431 | event = FW_NODE_INITIATED_RESET; | |
3038e353 KH |
432 | else |
433 | event = FW_NODE_UPDATED; | |
434 | ||
435 | node0->node_id = node1->node_id; | |
436 | node0->color = card->color; | |
437 | node0->link_on = node1->link_on; | |
438 | node0->initiated_reset = node1->initiated_reset; | |
83db801c | 439 | node0->max_hops = node1->max_hops; |
3038e353 KH |
440 | node1->color = card->color; |
441 | fw_node_event(card, node0, event); | |
442 | ||
443 | if (card->root_node == node1) | |
444 | card->root_node = node0; | |
445 | if (card->irm_node == node1) | |
446 | card->irm_node = node0; | |
447 | ||
448 | for (i = 0; i < node0->port_count; i++) { | |
dae1a3aa | 449 | if (node0->ports[i] && node1->ports[i]) { |
c781c06d KH |
450 | /* |
451 | * This port didn't change, queue the | |
3038e353 | 452 | * connected node for further |
c781c06d KH |
453 | * investigation. |
454 | */ | |
dae1a3aa | 455 | if (node0->ports[i]->color == card->color) |
3038e353 | 456 | continue; |
dae1a3aa SR |
457 | list_add_tail(&node0->ports[i]->link, &list0); |
458 | list_add_tail(&node1->ports[i]->link, &list1); | |
459 | } else if (node0->ports[i]) { | |
c781c06d KH |
460 | /* |
461 | * The nodes connected here were | |
3038e353 KH |
462 | * unplugged; unref the lost nodes and |
463 | * queue FW_NODE_LOST callbacks for | |
c781c06d KH |
464 | * them. |
465 | */ | |
3038e353 | 466 | |
dae1a3aa | 467 | for_each_fw_node(card, node0->ports[i], |
3038e353 | 468 | report_lost_node); |
dae1a3aa SR |
469 | node0->ports[i] = NULL; |
470 | } else if (node1->ports[i]) { | |
c781c06d KH |
471 | /* |
472 | * One or more node were connected to | |
3038e353 KH |
473 | * this port. Move the new nodes into |
474 | * the tree and queue FW_NODE_CREATED | |
c781c06d KH |
475 | * callbacks for them. |
476 | */ | |
3038e353 | 477 | move_tree(node0, node1, i); |
dae1a3aa | 478 | for_each_fw_node(card, node0->ports[i], |
3038e353 | 479 | report_found_node); |
3038e353 KH |
480 | } |
481 | } | |
482 | ||
483 | node0 = fw_node(node0->link.next); | |
77e55719 JF |
484 | next1 = fw_node(node1->link.next); |
485 | fw_node_put(node1); | |
486 | node1 = next1; | |
3038e353 KH |
487 | } |
488 | } | |
489 | ||
53dca511 SR |
490 | static void update_topology_map(struct fw_card *card, |
491 | u32 *self_ids, int self_id_count) | |
473d28c7 | 492 | { |
cb7c96da SR |
493 | int node_count = (card->root_node->node_id & 0x3f) + 1; |
494 | __be32 *map = card->topology_map; | |
495 | ||
496 | *map++ = cpu_to_be32((self_id_count + 2) << 16); | |
497 | *map++ = cpu_to_be32(be32_to_cpu(card->topology_map[1]) + 1); | |
498 | *map++ = cpu_to_be32((node_count << 16) | self_id_count); | |
499 | ||
500 | while (self_id_count--) | |
501 | *map++ = cpu_to_be32p(self_ids++); | |
473d28c7 | 502 | |
e175569c | 503 | fw_compute_block_crc(card->topology_map); |
473d28c7 KH |
504 | } |
505 | ||
53dca511 | 506 | void fw_core_handle_bus_reset(struct fw_card *card, int node_id, int generation, |
c8a94ded | 507 | int self_id_count, u32 *self_ids, bool bm_abdicate) |
3038e353 KH |
508 | { |
509 | struct fw_node *local_node; | |
510 | unsigned long flags; | |
3038e353 | 511 | |
a5c7f471 SR |
512 | /* |
513 | * If the selfID buffer is not the immediate successor of the | |
514 | * previously processed one, we cannot reliably compare the | |
515 | * old and new topologies. | |
516 | */ | |
8cd0bbbd | 517 | if (!is_next_generation(generation, card->generation) && |
a5c7f471 | 518 | card->local_node != NULL) { |
a5c7f471 SR |
519 | fw_destroy_nodes(card); |
520 | card->bm_retries = 0; | |
521 | } | |
522 | ||
3038e353 KH |
523 | spin_lock_irqsave(&card->lock, flags); |
524 | ||
db3c9cc1 | 525 | card->broadcast_channel_allocated = card->broadcast_channel_auto_allocated; |
3038e353 | 526 | card->node_id = node_id; |
b5d2a5e0 SR |
527 | /* |
528 | * Update node_id before generation to prevent anybody from using | |
529 | * a stale node_id together with a current generation. | |
530 | */ | |
531 | smp_wmb(); | |
3038e353 | 532 | card->generation = generation; |
e71084af | 533 | card->reset_jiffies = get_jiffies_64(); |
250b2b6d | 534 | card->bm_node_id = 0xffff; |
c8a94ded | 535 | card->bm_abdicate = bm_abdicate; |
0fa1986f | 536 | fw_schedule_bm_work(card, 0); |
3038e353 | 537 | |
473d28c7 KH |
538 | local_node = build_tree(card, self_ids, self_id_count); |
539 | ||
540 | update_topology_map(card, self_ids, self_id_count); | |
3038e353 KH |
541 | |
542 | card->color++; | |
543 | ||
544 | if (local_node == NULL) { | |
26b4950d | 545 | fw_err(card, "topology build failed\n"); |
3038e353 KH |
546 | /* FIXME: We need to issue a bus reset in this case. */ |
547 | } else if (card->local_node == NULL) { | |
548 | card->local_node = local_node; | |
549 | for_each_fw_node(card, local_node, report_found_node); | |
550 | } else { | |
83db801c | 551 | update_tree(card, local_node); |
3038e353 KH |
552 | } |
553 | ||
554 | spin_unlock_irqrestore(&card->lock, flags); | |
555 | } | |
3038e353 | 556 | EXPORT_SYMBOL(fw_core_handle_bus_reset); |