1 /*
2 * Node information (ConfigROM) collection and management.
3 *
4 * Copyright (C) 2000 Andreas E. Bombe
5 * 2001-2003 Ben Collins <bcollins@debian.net>
6 *
7 * This code is licensed under the GPL. See the file COPYING in the root
8 * directory of the kernel sources for details.
9 */
10
11 #include <linux/kernel.h>
12 #include <linux/config.h>
13 #include <linux/list.h>
14 #include <linux/slab.h>
15 #include <linux/smp_lock.h>
16 #include <linux/interrupt.h>
17 #include <linux/kmod.h>
18 #include <linux/completion.h>
19 #include <linux/delay.h>
20 #ifdef CONFIG_PROC_FS
21 #include <linux/proc_fs.h>
22 #endif
23
24 #include "ieee1394_types.h"
25 #include "ieee1394.h"
26 #include "nodemgr.h"
27 #include "hosts.h"
28 #include "ieee1394_transactions.h"
29 #include "highlevel.h"
30 #include "csr.h"
31 #include "nodemgr.h"
32
33
34
nodemgr_find_oui_name(int oui)35 static char *nodemgr_find_oui_name(int oui)
36 {
37 #ifdef CONFIG_IEEE1394_OUI_DB
38 extern struct oui_list_struct {
39 int oui;
40 char *name;
41 } oui_list[];
42 int i;
43
44 for (i = 0; oui_list[i].name; i++)
45 if (oui_list[i].oui == oui)
46 return oui_list[i].name;
47 #endif
48 return NULL;
49 }
50
51
52 /*
53 * Basically what we do here is start off retrieving the bus_info block.
54 * From there will fill in some info about the node, verify it is of IEEE
55 * 1394 type, and that the crc checks out ok. After that we start off with
56 * the root directory, and subdirectories. To do this, we retrieve the
57 * quadlet header for a directory, find out the length, and retrieve the
58 * complete directory entry (be it a leaf or a directory). We then process
59 * it and add the info to our structure for that particular node.
60 *
61 * We verify CRC's along the way for each directory/block/leaf. The entire
62 * node structure is generic, and simply stores the information in a way
63 * that's easy to parse by the protocol interface.
64 */
65
66 /* The nodemgr maintains a number of data structures: the node list,
67 * the driver list, unit directory list and the host info list. The
68 * first three lists are accessed from process context only: /proc
69 * readers, insmod and rmmod, and the nodemgr thread. Access to these
70 * lists are serialized by means of the nodemgr_serialize mutex, which
71 * must be taken before accessing the structures and released
72 * afterwards. The host info list is only accessed during insmod,
73 * rmmod and from interrupt and allways only for a short period of
74 * time, so a spinlock is used to protect this list.
75 */
76
77 static DECLARE_MUTEX(nodemgr_serialize);
78 static LIST_HEAD(node_list);
79 static LIST_HEAD(driver_list);
80 static LIST_HEAD(unit_directory_list);
81
82
83 struct host_info {
84 struct hpsb_host *host;
85 struct completion exited;
86 struct semaphore reset_sem;
87 int pid;
88 char daemon_name[15];
89 };
90
91 static struct hpsb_highlevel nodemgr_highlevel;
92
93 #ifdef CONFIG_PROC_FS
94
95 #define PUTF(fmt, args...) \
96 do { \
97 len += sprintf(page + len, fmt, ## args); \
98 pos = begin + len; \
99 if (pos < off) { \
100 len = 0; \
101 begin = pos; \
102 } \
103 if (pos > off + count) \
104 goto done_proc; \
105 } while (0)
106
107
raw1394_read_proc(char * page,char ** start,off_t off,int count,int * eof,void * data)108 static int raw1394_read_proc(char *page, char **start, off_t off,
109 int count, int *eof, void *data)
110 {
111 struct list_head *lh;
112 struct node_entry *ne;
113 off_t begin = 0, pos = 0;
114 int len = 0;
115
116 if (down_interruptible(&nodemgr_serialize))
117 return -EINTR;
118
119 list_for_each(lh, &node_list) {
120 struct list_head *l;
121 int ud_count = 0, lud_count = 0;
122
123 ne = list_entry(lh, struct node_entry, list);
124 if (!ne)
125 continue;
126
127 PUTF("Node[" NODE_BUS_FMT "] GUID[%016Lx]:\n",
128 NODE_BUS_ARGS(ne->host, ne->nodeid), (unsigned long long)ne->guid);
129
130 /* Generic Node information */
131 PUTF(" Vendor ID: `%s' [0x%06x]\n",
132 ne->vendor_name ?: "Unknown", ne->vendor_id);
133 PUTF(" Capabilities: 0x%06x\n", ne->capabilities);
134 PUTF(" Bus Options:\n");
135 PUTF(" IRMC(%d) CMC(%d) ISC(%d) BMC(%d) PMC(%d) GEN(%d)\n"
136 " LSPD(%d) MAX_REC(%d) CYC_CLK_ACC(%d)\n",
137 ne->busopt.irmc, ne->busopt.cmc, ne->busopt.isc, ne->busopt.bmc,
138 ne->busopt.pmc, ne->busopt.generation, ne->busopt.lnkspd,
139 ne->busopt.max_rec, ne->busopt.cyc_clk_acc);
140
141 /* If this is the host entry, output some info about it aswell */
142 if (ne->host != NULL && ne->host->node_id == ne->nodeid) {
143 PUTF(" Host Node Status:\n");
144 PUTF(" Host Driver : %s\n", ne->host->driver->name);
145 PUTF(" Nodes connected : %d\n", ne->host->node_count);
146 PUTF(" Nodes active : %d\n", ne->host->nodes_active);
147 PUTF(" SelfIDs received: %d\n", ne->host->selfid_count);
148 PUTF(" Irm ID : [" NODE_BUS_FMT "]\n",
149 NODE_BUS_ARGS(ne->host, ne->host->irm_id));
150 PUTF(" BusMgr ID : [" NODE_BUS_FMT "]\n",
151 NODE_BUS_ARGS(ne->host, ne->host->busmgr_id));
152 PUTF(" In Bus Reset : %s\n", ne->host->in_bus_reset ? "yes" : "no");
153 PUTF(" Root : %s\n", ne->host->is_root ? "yes" : "no");
154 PUTF(" Cycle Master : %s\n", ne->host->is_cycmst ? "yes" : "no");
155 PUTF(" IRM : %s\n", ne->host->is_irm ? "yes" : "no");
156 PUTF(" Bus Manager : %s\n", ne->host->is_busmgr ? "yes" : "no");
157 }
158
159 /* Now the unit directories */
160 list_for_each (l, &ne->unit_directories) {
161 struct unit_directory *ud = list_entry (l, struct unit_directory, node_list);
162 int printed = 0; // small hack
163
164 if (ud->parent == NULL)
165 PUTF(" Unit Directory %d:\n", lud_count++);
166 else
167 PUTF(" Logical Unit Directory %d:\n", ud_count++);
168 if (ud->flags & UNIT_DIRECTORY_VENDOR_ID) {
169 PUTF(" Vendor/Model ID: %s [%06x]",
170 ud->vendor_name ?: "Unknown", ud->vendor_id);
171 printed = 1;
172 }
173 if (ud->flags & UNIT_DIRECTORY_MODEL_ID) {
174 if (!printed)
175 PUTF(" Vendor/Model ID: %s [%06x]",
176 ne->vendor_name ?: "Unknown", ne->vendor_id);
177 PUTF(" / %s [%06x]", ud->model_name ?: "Unknown", ud->model_id);
178 printed = 1;
179 }
180 if (printed)
181 PUTF("\n");
182
183 if (ud->flags & UNIT_DIRECTORY_SPECIFIER_ID)
184 PUTF(" Software Specifier ID: %06x\n", ud->specifier_id);
185 if (ud->flags & UNIT_DIRECTORY_VERSION)
186 PUTF(" Software Version: %06x\n", ud->version);
187 if (ud->driver)
188 PUTF(" Driver: %s\n", ud->driver->name);
189 PUTF(" Length (in quads): %d\n", ud->length);
190 }
191
192 }
193
194 done_proc:
195 up(&nodemgr_serialize);
196
197 *start = page + (off - begin);
198 len -= (off - begin);
199 if (len > count)
200 len = count;
201 else {
202 *eof = 1;
203 if (len <= 0)
204 return 0;
205 }
206
207 return len;
208 }
209
210 #undef PUTF
211 #endif /* CONFIG_PROC_FS */
212
213 static void nodemgr_process_config_rom(struct node_entry *ne,
214 quadlet_t busoptions);
215
nodemgr_read_quadlet(struct hpsb_host * host,nodeid_t nodeid,unsigned int generation,octlet_t address,quadlet_t * quad)216 static int nodemgr_read_quadlet(struct hpsb_host *host,
217 nodeid_t nodeid, unsigned int generation,
218 octlet_t address, quadlet_t *quad)
219 {
220 int i;
221 int ret = 0;
222
223 for (i = 0; i < 3; i++) {
224 ret = hpsb_read(host, nodeid, generation, address, quad, 4);
225 if (!ret)
226 break;
227
228 set_current_state(TASK_INTERRUPTIBLE);
229 if (schedule_timeout (HZ/3))
230 return -1;
231 }
232 *quad = be32_to_cpu(*quad);
233
234 return ret;
235 }
236
nodemgr_size_text_leaf(struct hpsb_host * host,nodeid_t nodeid,unsigned int generation,octlet_t address)237 static int nodemgr_size_text_leaf(struct hpsb_host *host,
238 nodeid_t nodeid, unsigned int generation,
239 octlet_t address)
240 {
241 quadlet_t quad;
242 int size = 0;
243
244 if (nodemgr_read_quadlet(host, nodeid, generation, address, &quad))
245 return -1;
246
247 if (CONFIG_ROM_KEY(quad) == CONFIG_ROM_DESCRIPTOR_LEAF) {
248 /* This is the offset. */
249 address += 4 * CONFIG_ROM_VALUE(quad);
250 if (nodemgr_read_quadlet(host, nodeid, generation, address, &quad))
251 return -1;
252 /* Now we got the size of the text descriptor leaf. */
253 size = CONFIG_ROM_LEAF_LENGTH(quad);
254 }
255
256 return size;
257 }
258
nodemgr_read_text_leaf(struct node_entry * ne,octlet_t address,quadlet_t * quadp)259 static int nodemgr_read_text_leaf(struct node_entry *ne,
260 octlet_t address,
261 quadlet_t *quadp)
262 {
263 quadlet_t quad;
264 int i, size, ret;
265
266 if (nodemgr_read_quadlet(ne->host, ne->nodeid, ne->generation, address, &quad)
267 || CONFIG_ROM_KEY(quad) != CONFIG_ROM_DESCRIPTOR_LEAF)
268 return -1;
269
270 /* This is the offset. */
271 address += 4 * CONFIG_ROM_VALUE(quad);
272 if (nodemgr_read_quadlet(ne->host, ne->nodeid, ne->generation, address, &quad))
273 return -1;
274
275 /* Now we got the size of the text descriptor leaf. */
276 size = CONFIG_ROM_LEAF_LENGTH(quad) - 2;
277 if (size <= 0)
278 return -1;
279
280 address += 4;
281 for (i = 0; i < 2; i++, address += 4, quadp++) {
282 if (nodemgr_read_quadlet(ne->host, ne->nodeid, ne->generation, address, quadp))
283 return -1;
284 }
285
286 /* Now read the text string. */
287 ret = -ENXIO;
288 for (; size > 0; size--, address += 4, quadp++) {
289 for (i = 0; i < 3; i++) {
290 ret = hpsb_node_read(ne, address, quadp, 4);
291 if (ret != -EAGAIN)
292 break;
293 }
294 if (ret)
295 break;
296 }
297
298 return ret;
299 }
300
nodemgr_scan_root_directory(struct hpsb_host * host,nodeid_t nodeid,unsigned int generation)301 static struct node_entry *nodemgr_scan_root_directory
302 (struct hpsb_host *host, nodeid_t nodeid, unsigned int generation)
303 {
304 octlet_t address;
305 quadlet_t quad;
306 int length;
307 int code, size, total_size;
308 struct node_entry *ne;
309
310 address = CSR_REGISTER_BASE + CSR_CONFIG_ROM;
311
312 if (nodemgr_read_quadlet(host, nodeid, generation, address, &quad))
313 return NULL;
314
315 if (CONFIG_ROM_BUS_INFO_LENGTH(quad) == 1) /* minimal config rom */
316 return NULL;
317
318 address += 4 + CONFIG_ROM_BUS_INFO_LENGTH(quad) * 4;
319
320 if (nodemgr_read_quadlet(host, nodeid, generation, address, &quad))
321 return NULL;
322 length = CONFIG_ROM_ROOT_LENGTH(quad);
323 address += 4;
324
325 size = 0;
326 total_size = sizeof(struct node_entry);
327 for (; length > 0; length--, address += 4) {
328 if (nodemgr_read_quadlet(host, nodeid, generation, address, &quad))
329 return NULL;
330 code = CONFIG_ROM_KEY(quad);
331
332 if (code == CONFIG_ROM_VENDOR_ID && length > 0) {
333 /* Check if there is a text descriptor leaf
334 immediately after this. */
335 size = nodemgr_size_text_leaf(host, nodeid, generation,
336 address + 4);
337 if (size > 0) {
338 address += 4;
339 length--;
340 total_size += (size + 1) * sizeof (quadlet_t);
341 } else if (size < 0)
342 return NULL;
343 }
344 }
345 ne = kmalloc(total_size, GFP_KERNEL);
346
347 if (!ne)
348 return NULL;
349
350 memset(ne, 0, total_size);
351
352 if (size != 0) {
353 ne->vendor_name = (const char *) &(ne->quadlets[2]);
354 ne->quadlets[size] = 0;
355 } else {
356 ne->vendor_name = NULL;
357 }
358
359 return ne;
360 }
361
nodemgr_create_node(octlet_t guid,quadlet_t busoptions,struct host_info * hi,nodeid_t nodeid,unsigned int generation)362 static struct node_entry *nodemgr_create_node(octlet_t guid, quadlet_t busoptions,
363 struct host_info *hi,
364 nodeid_t nodeid, unsigned int generation)
365 {
366 struct hpsb_host *host = hi->host;
367 struct node_entry *ne;
368
369 ne = nodemgr_scan_root_directory (host, nodeid, generation);
370 if (!ne) return NULL;
371
372 INIT_LIST_HEAD(&ne->list);
373 INIT_LIST_HEAD(&ne->unit_directories);
374 ne->host = host;
375 ne->nodeid = nodeid;
376 ne->generation = generation;
377 ne->guid = guid;
378 ne->guid_vendor_id = (guid >> 40) & 0xffffff;
379 ne->guid_vendor_oui = nodemgr_find_oui_name(ne->guid_vendor_id);
380
381 list_add_tail(&ne->list, &node_list);
382
383 nodemgr_process_config_rom (ne, busoptions);
384
385 HPSB_DEBUG("%s added: ID:BUS[" NODE_BUS_FMT "] GUID[%016Lx]",
386 (host->node_id == nodeid) ? "Host" : "Node",
387 NODE_BUS_ARGS(host, nodeid), (unsigned long long)guid);
388
389 return ne;
390 }
391
find_entry_by_guid(u64 guid)392 static struct node_entry *find_entry_by_guid(u64 guid)
393 {
394 struct list_head *lh;
395 struct node_entry *ne;
396
397 list_for_each(lh, &node_list) {
398 ne = list_entry(lh, struct node_entry, list);
399 if (ne->guid == guid) return ne;
400 }
401
402 return NULL;
403 }
404
find_entry_by_nodeid(struct hpsb_host * host,nodeid_t nodeid)405 static struct node_entry *find_entry_by_nodeid(struct hpsb_host *host, nodeid_t nodeid)
406 {
407 struct list_head *lh;
408 struct node_entry *ne;
409
410 list_for_each(lh, &node_list) {
411 ne = list_entry(lh, struct node_entry, list);
412 if (ne->nodeid == nodeid && ne->host == host)
413 return ne;
414 }
415
416 return NULL;
417 }
418
nodemgr_scan_unit_directory(struct node_entry * ne,octlet_t address)419 static struct unit_directory *nodemgr_scan_unit_directory
420 (struct node_entry *ne, octlet_t address)
421 {
422 struct unit_directory *ud;
423 quadlet_t quad;
424 u8 flags, todo;
425 int length, size, total_size, count;
426 int vendor_name_size, model_name_size;
427
428 if (nodemgr_read_quadlet(ne->host, ne->nodeid, ne->generation, address, &quad))
429 return NULL;
430 length = CONFIG_ROM_DIRECTORY_LENGTH(quad) ;
431 address += 4;
432
433 size = 0;
434 total_size = sizeof (struct unit_directory);
435 flags = 0;
436 count = 0;
437 vendor_name_size = 0;
438 model_name_size = 0;
439 for (; length > 0; length--, address += 4) {
440 int code;
441 quadlet_t value;
442
443 if (nodemgr_read_quadlet(ne->host, ne->nodeid, ne->generation,
444 address, &quad))
445 return NULL;
446 code = CONFIG_ROM_KEY(quad);
447 value = CONFIG_ROM_VALUE(quad);
448
449 todo = 0;
450 switch (code) {
451 case CONFIG_ROM_VENDOR_ID:
452 todo = UNIT_DIRECTORY_VENDOR_TEXT;
453 break;
454
455 case CONFIG_ROM_MODEL_ID:
456 todo = UNIT_DIRECTORY_MODEL_TEXT;
457 break;
458
459 case CONFIG_ROM_SPECIFIER_ID:
460 case CONFIG_ROM_UNIT_SW_VERSION:
461 break;
462
463 case CONFIG_ROM_DESCRIPTOR_LEAF:
464 case CONFIG_ROM_DESCRIPTOR_DIRECTORY:
465 /* TODO: read strings... icons? */
466 break;
467
468 default:
469 /* Which types of quadlets do we want to
470 store? Only count immediate values and
471 CSR offsets for now. */
472 code &= CONFIG_ROM_KEY_TYPE_MASK;
473 if ((code & CONFIG_ROM_KEY_TYPE_LEAF) == 0)
474 count++;
475 break;
476 }
477
478 if (todo && length > 0) {
479 /* Check if there is a text descriptor leaf
480 immediately after this. */
481 size = nodemgr_size_text_leaf(ne->host,
482 ne->nodeid,
483 ne->generation,
484 address + 4);
485
486 if (todo == UNIT_DIRECTORY_VENDOR_TEXT)
487 vendor_name_size = size;
488 else
489 model_name_size = size;
490
491 if (size > 0) {
492 address += 4;
493 length--;
494 flags |= todo;
495 total_size += (size + 1) * sizeof (quadlet_t);
496 }
497 else if (size < 0)
498 return NULL;
499 }
500 }
501
502 total_size += count * sizeof (quadlet_t);
503 ud = kmalloc (total_size, GFP_KERNEL);
504
505 if (ud != NULL) {
506 memset (ud, 0, total_size);
507 ud->flags = flags;
508 ud->length = count;
509 ud->vendor_name_size = vendor_name_size;
510 ud->model_name_size = model_name_size;
511 }
512
513 return ud;
514 }
515
516
517 /* This implementation currently only scans the config rom and its
518 * immediate unit directories looking for software_id and
519 * software_version entries, in order to get driver autoloading working. */
nodemgr_process_unit_directory(struct node_entry * ne,octlet_t address,struct unit_directory * parent)520 static struct unit_directory * nodemgr_process_unit_directory
521 (struct node_entry *ne, octlet_t address, struct unit_directory *parent)
522 {
523 struct unit_directory *ud;
524 quadlet_t quad;
525 quadlet_t *infop;
526 int length;
527 struct unit_directory *ud_temp = NULL;
528
529 if (!(ud = nodemgr_scan_unit_directory(ne, address)))
530 goto unit_directory_error;
531
532 ud->ne = ne;
533 ud->address = address;
534
535 if (parent) {
536 ud->flags |= UNIT_DIRECTORY_LUN_DIRECTORY;
537 ud->parent = parent;
538 }
539
540 if (nodemgr_read_quadlet(ne->host, ne->nodeid, ne->generation,
541 address, &quad))
542 goto unit_directory_error;
543 length = CONFIG_ROM_DIRECTORY_LENGTH(quad) ;
544 address += 4;
545
546 infop = (quadlet_t *) ud->quadlets;
547 for (; length > 0; length--, address += 4) {
548 int code;
549 quadlet_t value;
550 quadlet_t *quadp;
551
552 if (nodemgr_read_quadlet(ne->host, ne->nodeid, ne->generation,
553 address, &quad))
554 goto unit_directory_error;
555 code = CONFIG_ROM_KEY(quad) ;
556 value = CONFIG_ROM_VALUE(quad);
557
558 switch (code) {
559 case CONFIG_ROM_VENDOR_ID:
560 ud->vendor_id = value;
561 ud->flags |= UNIT_DIRECTORY_VENDOR_ID;
562
563 if (ud->vendor_id)
564 ud->vendor_oui = nodemgr_find_oui_name(ud->vendor_id);
565
566 if ((ud->flags & UNIT_DIRECTORY_VENDOR_TEXT) != 0) {
567 length--;
568 address += 4;
569 quadp = &(ud->quadlets[ud->length]);
570 if (nodemgr_read_text_leaf(ne, address, quadp) == 0
571 && quadp[0] == 0 && quadp[1] == 0) {
572 /* We only support minimal
573 ASCII and English. */
574 quadp[ud->vendor_name_size] = 0;
575 ud->vendor_name
576 = (const char *) &(quadp[2]);
577 }
578 }
579 break;
580
581 case CONFIG_ROM_MODEL_ID:
582 ud->model_id = value;
583 ud->flags |= UNIT_DIRECTORY_MODEL_ID;
584 if ((ud->flags & UNIT_DIRECTORY_MODEL_TEXT) != 0) {
585 length--;
586 address += 4;
587 quadp = &(ud->quadlets[ud->length + ud->vendor_name_size + 1]);
588 if (nodemgr_read_text_leaf(ne, address, quadp) == 0
589 && quadp[0] == 0 && quadp[1] == 0) {
590 /* We only support minimal
591 ASCII and English. */
592 quadp[ud->model_name_size] = 0;
593 ud->model_name
594 = (const char *) &(quadp[2]);
595 }
596 }
597 break;
598
599 case CONFIG_ROM_SPECIFIER_ID:
600 ud->specifier_id = value;
601 ud->flags |= UNIT_DIRECTORY_SPECIFIER_ID;
602 break;
603
604 case CONFIG_ROM_UNIT_SW_VERSION:
605 ud->version = value;
606 ud->flags |= UNIT_DIRECTORY_VERSION;
607 break;
608
609 case CONFIG_ROM_DESCRIPTOR_LEAF:
610 case CONFIG_ROM_DESCRIPTOR_DIRECTORY:
611 /* TODO: read strings... icons? */
612 break;
613
614 case CONFIG_ROM_LOGICAL_UNIT_DIRECTORY:
615 ud->flags |= UNIT_DIRECTORY_HAS_LUN_DIRECTORY;
616 ud_temp = nodemgr_process_unit_directory(ne, address + value * 4, ud);
617
618 if (ud_temp == NULL)
619 break;
620
621 /* inherit unspecified values */
622 if ((ud->flags & UNIT_DIRECTORY_VENDOR_ID) &&
623 !(ud_temp->flags & UNIT_DIRECTORY_VENDOR_ID))
624 {
625 ud_temp->flags |= UNIT_DIRECTORY_VENDOR_ID;
626 ud_temp->vendor_id = ud->vendor_id;
627 }
628 if ((ud->flags & UNIT_DIRECTORY_MODEL_ID) &&
629 !(ud_temp->flags & UNIT_DIRECTORY_MODEL_ID))
630 {
631 ud_temp->flags |= UNIT_DIRECTORY_MODEL_ID;
632 ud_temp->model_id = ud->model_id;
633 }
634 if ((ud->flags & UNIT_DIRECTORY_SPECIFIER_ID) &&
635 !(ud_temp->flags & UNIT_DIRECTORY_SPECIFIER_ID))
636 {
637 ud_temp->flags |= UNIT_DIRECTORY_SPECIFIER_ID;
638 ud_temp->specifier_id = ud->specifier_id;
639 }
640 if ((ud->flags & UNIT_DIRECTORY_VERSION) &&
641 !(ud_temp->flags & UNIT_DIRECTORY_VERSION))
642 {
643 ud_temp->flags |= UNIT_DIRECTORY_VERSION;
644 ud_temp->version = ud->version;
645 }
646
647 break;
648
649 default:
650 /* Which types of quadlets do we want to
651 store? Only count immediate values and
652 CSR offsets for now. */
653 code &= CONFIG_ROM_KEY_TYPE_MASK;
654 if ((code & CONFIG_ROM_KEY_TYPE_LEAF) == 0)
655 *infop++ = quad;
656 break;
657 }
658 }
659
660 list_add_tail(&ud->node_list, &ne->unit_directories);
661 list_add_tail(&ud->driver_list, &unit_directory_list);
662
663 return ud;
664
665 unit_directory_error:
666 if (ud != NULL)
667 kfree(ud);
668 return NULL;
669 }
670
671
nodemgr_process_root_directory(struct node_entry * ne)672 static void nodemgr_process_root_directory(struct node_entry *ne)
673 {
674 octlet_t address;
675 quadlet_t quad;
676 int length;
677
678 address = CSR_REGISTER_BASE + CSR_CONFIG_ROM;
679
680 if (nodemgr_read_quadlet(ne->host, ne->nodeid, ne->generation,
681 address, &quad))
682 return;
683 address += 4 + CONFIG_ROM_BUS_INFO_LENGTH(quad) * 4;
684
685 if (nodemgr_read_quadlet(ne->host, ne->nodeid, ne->generation,
686 address, &quad))
687 return;
688 length = CONFIG_ROM_ROOT_LENGTH(quad);
689 address += 4;
690
691 for (; length > 0; length--, address += 4) {
692 int code, value;
693
694 if (nodemgr_read_quadlet(ne->host, ne->nodeid, ne->generation,
695 address, &quad))
696 return;
697 code = CONFIG_ROM_KEY(quad);
698 value = CONFIG_ROM_VALUE(quad);
699
700 switch (code) {
701 case CONFIG_ROM_VENDOR_ID:
702 ne->vendor_id = value;
703
704 if (ne->vendor_id)
705 ne->vendor_oui = nodemgr_find_oui_name(ne->vendor_id);
706
707 /* Now check if there is a vendor name text
708 string. */
709 if (ne->vendor_name != NULL) {
710 length--;
711 address += 4;
712 if (nodemgr_read_text_leaf(ne, address, ne->quadlets) != 0
713 || ne->quadlets[0] != 0 || ne->quadlets[1] != 0)
714 /* We only support minimal
715 ASCII and English. */
716 ne->vendor_name = NULL;
717 }
718 break;
719
720 case CONFIG_ROM_NODE_CAPABILITES:
721 ne->capabilities = value;
722 break;
723
724 case CONFIG_ROM_UNIT_DIRECTORY:
725 nodemgr_process_unit_directory(ne, address + value * 4, NULL);
726 break;
727
728 case CONFIG_ROM_DESCRIPTOR_LEAF:
729 case CONFIG_ROM_DESCRIPTOR_DIRECTORY:
730 /* TODO: read strings... icons? */
731 break;
732 }
733 }
734 }
735
736 #ifdef CONFIG_HOTPLUG
737
nodemgr_call_policy(char * verb,struct unit_directory * ud)738 static void nodemgr_call_policy(char *verb, struct unit_directory *ud)
739 {
740 char *argv [3], **envp, *buf, *scratch;
741 int i = 0, value;
742
743 if (!hotplug_path [0])
744 return;
745 if (!current->fs->root)
746 return;
747 if (!(envp = (char **) kmalloc(20 * sizeof (char *), GFP_KERNEL))) {
748 HPSB_DEBUG ("ENOMEM");
749 return;
750 }
751 if (!(buf = kmalloc(256, GFP_KERNEL))) {
752 kfree(envp);
753 HPSB_DEBUG("ENOMEM2");
754 return;
755 }
756
757 /* only one standardized param to hotplug command: type */
758 argv[0] = hotplug_path;
759 argv[1] = "ieee1394";
760 argv[2] = 0;
761
762 /* minimal command environment */
763 envp[i++] = "HOME=/";
764 envp[i++] = "PATH=/sbin:/bin:/usr/sbin:/usr/bin";
765
766 #ifdef CONFIG_IEEE1394_VERBOSEDEBUG
767 /* hint that policy agent should enter no-stdout debug mode */
768 envp[i++] = "DEBUG=kernel";
769 #endif
770 /* extensible set of named bus-specific parameters,
771 * supporting multiple driver selection algorithms.
772 */
773 scratch = buf;
774
775 envp[i++] = scratch;
776 scratch += sprintf(scratch, "ACTION=%s", verb) + 1;
777 envp[i++] = scratch;
778 scratch += sprintf(scratch, "VENDOR_ID=%06x", ud->vendor_id) + 1;
779 envp[i++] = scratch;
780 scratch += sprintf(scratch, "GUID=%016Lx", (long long unsigned)ud->ne->guid) + 1;
781 envp[i++] = scratch;
782 scratch += sprintf(scratch, "SPECIFIER_ID=%06x", ud->specifier_id) + 1;
783 envp[i++] = scratch;
784 scratch += sprintf(scratch, "VERSION=%06x", ud->version) + 1;
785 envp[i++] = 0;
786
787 /* NOTE: user mode daemons can call the agents too */
788 HPSB_VERBOSE("NodeMgr: %s %s %016Lx", argv[0], verb, (long long unsigned)ud->ne->guid);
789
790 value = call_usermodehelper(argv[0], argv, envp);
791 kfree(buf);
792 kfree(envp);
793 if (value != 0)
794 HPSB_DEBUG("NodeMgr: hotplug policy returned %d", value);
795 }
796
797 #else
798
799 static inline void
nodemgr_call_policy(char * verb,struct unit_directory * ud)800 nodemgr_call_policy(char *verb, struct unit_directory *ud)
801 {
802 HPSB_VERBOSE("NodeMgr: nodemgr_call_policy(): hotplug not enabled");
803 return;
804 }
805
806 #endif /* CONFIG_HOTPLUG */
807
nodemgr_claim_unit_directory(struct unit_directory * ud,struct hpsb_protocol_driver * driver)808 static void nodemgr_claim_unit_directory(struct unit_directory *ud,
809 struct hpsb_protocol_driver *driver)
810 {
811 ud->driver = driver;
812 list_move_tail(&ud->driver_list, &driver->unit_directories);
813 }
814
nodemgr_release_unit_directory(struct unit_directory * ud)815 static void nodemgr_release_unit_directory(struct unit_directory *ud)
816 {
817 ud->driver = NULL;
818 list_move_tail(&ud->driver_list, &unit_directory_list);
819 }
820
hpsb_release_unit_directory(struct unit_directory * ud)821 void hpsb_release_unit_directory(struct unit_directory *ud)
822 {
823 down(&nodemgr_serialize);
824 nodemgr_release_unit_directory(ud);
825 up(&nodemgr_serialize);
826 }
827
nodemgr_free_unit_directories(struct node_entry * ne)828 static void nodemgr_free_unit_directories(struct node_entry *ne)
829 {
830 struct list_head *lh, *next;
831 struct unit_directory *ud;
832
833 list_for_each_safe(lh, next, &ne->unit_directories) {
834 ud = list_entry(lh, struct unit_directory, node_list);
835
836 if (ud->driver && ud->driver->disconnect)
837 ud->driver->disconnect(ud);
838
839 nodemgr_release_unit_directory(ud);
840 nodemgr_call_policy("remove", ud);
841
842 list_del(&ud->driver_list);
843 list_del(&ud->node_list);
844
845 kfree(ud);
846 }
847 }
848
849 static struct ieee1394_device_id *
nodemgr_match_driver(struct hpsb_protocol_driver * driver,struct unit_directory * ud)850 nodemgr_match_driver(struct hpsb_protocol_driver *driver,
851 struct unit_directory *ud)
852 {
853 struct ieee1394_device_id *id;
854
855 for (id = driver->id_table; id->match_flags != 0; id++) {
856 if ((id->match_flags & IEEE1394_MATCH_VENDOR_ID) &&
857 id->vendor_id != ud->vendor_id)
858 continue;
859
860 if ((id->match_flags & IEEE1394_MATCH_MODEL_ID) &&
861 id->model_id != ud->model_id)
862 continue;
863
864 if ((id->match_flags & IEEE1394_MATCH_SPECIFIER_ID) &&
865 id->specifier_id != ud->specifier_id)
866 continue;
867
868 /* software version does a bitwise comparison instead of equality */
869 if ((id->match_flags & IEEE1394_MATCH_VERSION) &&
870 !(id->version & ud->version))
871 continue;
872
873 return id;
874 }
875
876 return NULL;
877 }
878
879 static struct hpsb_protocol_driver *
nodemgr_find_driver(struct unit_directory * ud)880 nodemgr_find_driver(struct unit_directory *ud)
881 {
882 struct list_head *l;
883 struct hpsb_protocol_driver *match, *driver;
884 struct ieee1394_device_id *device_id;
885
886 match = NULL;
887 list_for_each(l, &driver_list) {
888 driver = list_entry(l, struct hpsb_protocol_driver, list);
889 device_id = nodemgr_match_driver(driver, ud);
890
891 if (device_id != NULL) {
892 match = driver;
893 break;
894 }
895 }
896
897 return match;
898 }
899
nodemgr_bind_drivers(struct node_entry * ne)900 static void nodemgr_bind_drivers (struct node_entry *ne)
901 {
902 struct list_head *lh;
903 struct hpsb_protocol_driver *driver;
904 struct unit_directory *ud;
905
906 list_for_each(lh, &ne->unit_directories) {
907 ud = list_entry(lh, struct unit_directory, node_list);
908 driver = nodemgr_find_driver(ud);
909 if (driver && (!driver->probe || driver->probe(ud) == 0))
910 nodemgr_claim_unit_directory(ud, driver);
911 nodemgr_call_policy("add", ud);
912 }
913 }
914
915
hpsb_register_protocol(struct hpsb_protocol_driver * driver)916 int hpsb_register_protocol(struct hpsb_protocol_driver *driver)
917 {
918 struct unit_directory *ud;
919 struct list_head *lh, *next;
920
921 if (down_interruptible(&nodemgr_serialize))
922 return -EINTR;
923
924 list_add_tail(&driver->list, &driver_list);
925
926 INIT_LIST_HEAD(&driver->unit_directories);
927
928 list_for_each_safe (lh, next, &unit_directory_list) {
929 ud = list_entry(lh, struct unit_directory, driver_list);
930
931 if (nodemgr_match_driver(driver, ud) &&
932 (!driver->probe || driver->probe(ud) == 0))
933 nodemgr_claim_unit_directory(ud, driver);
934 }
935
936 up(&nodemgr_serialize);
937
938 /*
939 * Right now registration always succeeds, but maybe we should
940 * detect clashes in protocols handled by other drivers.
941 * DRD> No because multiple drivers are needed to handle certain devices.
942 * For example, a DV camera is an IEC 61883 device (dv1394) and AV/C (raw1394).
943 * This will become less an issue with libiec61883 using raw1394.
944 *
945 * BenC: But can we handle this with an ALLOW_SHARED flag for a
946 * protocol? When we get an SBP-3 driver, it will be nice if they were
947 * mutually exclusive, since SBP-3 can handle SBP-2 protocol.
948 *
949 * Not to mention that we currently do not seem to support multiple
950 * drivers claiming the same unitdirectory. If we implement both of
951 * those, then we'll need to keep probing when a driver claims a
952 * unitdirectory, but is sharable.
953 */
954
955 return 0;
956 }
957
hpsb_unregister_protocol(struct hpsb_protocol_driver * driver)958 void hpsb_unregister_protocol(struct hpsb_protocol_driver *driver)
959 {
960 struct list_head *lh, *next;
961 struct unit_directory *ud;
962
963 down(&nodemgr_serialize);
964
965 list_del(&driver->list);
966
967 list_for_each_safe (lh, next, &driver->unit_directories) {
968 ud = list_entry(lh, struct unit_directory, driver_list);
969
970 if (ud->driver && ud->driver->disconnect)
971 ud->driver->disconnect(ud);
972
973 nodemgr_release_unit_directory(ud);
974 }
975
976 up(&nodemgr_serialize);
977 }
978
nodemgr_process_config_rom(struct node_entry * ne,quadlet_t busoptions)979 static void nodemgr_process_config_rom(struct node_entry *ne,
980 quadlet_t busoptions)
981 {
982 ne->busopt.irmc = (busoptions >> 31) & 1;
983 ne->busopt.cmc = (busoptions >> 30) & 1;
984 ne->busopt.isc = (busoptions >> 29) & 1;
985 ne->busopt.bmc = (busoptions >> 28) & 1;
986 ne->busopt.pmc = (busoptions >> 27) & 1;
987 ne->busopt.cyc_clk_acc = (busoptions >> 16) & 0xff;
988 ne->busopt.max_rec = 1 << (((busoptions >> 12) & 0xf) + 1);
989 ne->busopt.generation = (busoptions >> 4) & 0xf;
990 ne->busopt.lnkspd = busoptions & 0x7;
991
992 HPSB_VERBOSE("NodeMgr: raw=0x%08x irmc=%d cmc=%d isc=%d bmc=%d pmc=%d "
993 "cyc_clk_acc=%d max_rec=%d gen=%d lspd=%d",
994 busoptions, ne->busopt.irmc, ne->busopt.cmc,
995 ne->busopt.isc, ne->busopt.bmc, ne->busopt.pmc,
996 ne->busopt.cyc_clk_acc, ne->busopt.max_rec,
997 ne->busopt.generation, ne->busopt.lnkspd);
998
999 /*
1000 * When the config rom changes we disconnect all drivers and
1001 * free the cached unit directories and reread the whole
1002 * thing. If this was a new device, the call to
1003 * nodemgr_disconnect_drivers is a no-op and all is well.
1004 */
1005 nodemgr_free_unit_directories(ne);
1006 nodemgr_process_root_directory(ne);
1007 nodemgr_bind_drivers(ne);
1008 }
1009
1010 /*
1011 * This function updates nodes that were present on the bus before the
1012 * reset and still are after the reset. The nodeid and the config rom
1013 * may have changed, and the drivers managing this device must be
1014 * informed that this device just went through a bus reset, to allow
1015 * the to take whatever actions required.
1016 */
nodemgr_update_node(struct node_entry * ne,quadlet_t busoptions,struct host_info * hi,nodeid_t nodeid,unsigned int generation)1017 static void nodemgr_update_node(struct node_entry *ne, quadlet_t busoptions,
1018 struct host_info *hi, nodeid_t nodeid,
1019 unsigned int generation)
1020 {
1021 struct list_head *lh;
1022 struct unit_directory *ud;
1023
1024 if (ne->nodeid != nodeid) {
1025 HPSB_DEBUG("Node changed: " NODE_BUS_FMT " -> " NODE_BUS_FMT,
1026 NODE_BUS_ARGS(ne->host, ne->nodeid),
1027 NODE_BUS_ARGS(ne->host, nodeid));
1028 ne->nodeid = nodeid;
1029 }
1030
1031 ne->generation = generation;
1032
1033 if (ne->busopt.generation != ((busoptions >> 4) & 0xf))
1034 nodemgr_process_config_rom (ne, busoptions);
1035
1036 list_for_each (lh, &ne->unit_directories) {
1037 ud = list_entry (lh, struct unit_directory, node_list);
1038 if (ud->driver && ud->driver->update != NULL)
1039 ud->driver->update(ud);
1040 }
1041 }
1042
read_businfo_block(struct hpsb_host * host,nodeid_t nodeid,unsigned int generation,quadlet_t * buffer,int buffer_length)1043 static int read_businfo_block(struct hpsb_host *host, nodeid_t nodeid, unsigned int generation,
1044 quadlet_t *buffer, int buffer_length)
1045 {
1046 octlet_t addr = CSR_REGISTER_BASE + CSR_CONFIG_ROM;
1047 unsigned header_size;
1048 int i;
1049
1050 /* IEEE P1212 says that devices should support 64byte block
1051 * reads, aligned on 64byte boundaries. That doesn't seem to
1052 * work though, and we are forced to doing quadlet sized
1053 * reads. */
1054
1055 HPSB_VERBOSE("Initiating ConfigROM request for node " NODE_BUS_FMT,
1056 NODE_BUS_ARGS(host, nodeid));
1057
1058 /*
1059 * Must retry a few times if config rom read returns zero (how long?). Will
1060 * not normally occur, but we should do the right thing. For example, with
1061 * some sbp2 devices, the bridge chipset cannot return valid config rom reads
1062 * immediately after power-on, since they need to detect the type of
1063 * device attached (disk or CD-ROM).
1064 */
1065 for (i = 0; i < 4; i++) {
1066 if (nodemgr_read_quadlet(host, nodeid, generation,
1067 addr, &buffer[0]) < 0) {
1068 HPSB_ERR("ConfigROM quadlet transaction error for node "
1069 NODE_BUS_FMT, NODE_BUS_ARGS(host, nodeid));
1070 return -1;
1071 }
1072 if (buffer[0])
1073 break;
1074
1075 set_current_state(TASK_INTERRUPTIBLE);
1076 if (schedule_timeout (HZ/4))
1077 return -1;
1078 }
1079
1080 header_size = buffer[0] >> 24;
1081 addr += 4;
1082
1083 if (header_size == 1) {
1084 HPSB_INFO("Node " NODE_BUS_FMT " has a minimal ROM. "
1085 "Vendor is %08x",
1086 NODE_BUS_ARGS(host, nodeid), buffer[0] & 0x00ffffff);
1087 return -1;
1088 }
1089
1090 if (header_size < 4) {
1091 HPSB_INFO("Node " NODE_BUS_FMT " has non-standard ROM "
1092 "format (%d quads), cannot parse",
1093 NODE_BUS_ARGS(host, nodeid), header_size);
1094 return -1;
1095 }
1096
1097 for (i = 1; i < buffer_length; i++, addr += 4) {
1098 if (nodemgr_read_quadlet(host, nodeid, generation,
1099 addr, &buffer[i]) < 0) {
1100 HPSB_ERR("ConfigROM quadlet transaction "
1101 "error for node " NODE_BUS_FMT,
1102 NODE_BUS_ARGS(host, nodeid));
1103 return -1;
1104 }
1105 }
1106
1107 return 0;
1108 }
1109
nodemgr_remove_node(struct node_entry * ne)1110 static void nodemgr_remove_node(struct node_entry *ne)
1111 {
1112 HPSB_DEBUG("Node removed: ID:BUS[" NODE_BUS_FMT "] GUID[%016Lx]",
1113 NODE_BUS_ARGS(ne->host, ne->nodeid), (unsigned long long)ne->guid);
1114
1115 nodemgr_free_unit_directories(ne);
1116 list_del(&ne->list);
1117 kfree(ne);
1118
1119 return;
1120 }
1121
1122 /* This is where we probe the nodes for their information and provided
1123 * features. */
nodemgr_node_probe_one(struct host_info * hi,nodeid_t nodeid,int generation)1124 static void nodemgr_node_probe_one(struct host_info *hi,
1125 nodeid_t nodeid, int generation)
1126 {
1127 struct hpsb_host *host = hi->host;
1128 struct node_entry *ne;
1129 quadlet_t buffer[5];
1130 octlet_t guid;
1131
1132 /* We need to detect when the ConfigROM's generation has changed,
1133 * so we only update the node's info when it needs to be. */
1134
1135 if (read_businfo_block (host, nodeid, generation,
1136 buffer, sizeof(buffer) >> 2))
1137 return;
1138
1139 if (buffer[1] != IEEE1394_BUSID_MAGIC) {
1140 /* This isn't a 1394 device, but we let it slide. There
1141 * was a report of a device with broken firmware which
1142 * reported '2394' instead of '1394', which is obviously a
1143 * mistake. One would hope that a non-1394 device never
1144 * gets connected to Firewire bus. If someone does, we
1145 * shouldn't be held responsible, so we'll allow it with a
1146 * warning. */
1147 HPSB_WARN("Node " NODE_BUS_FMT " has invalid busID magic [0x%08x]",
1148 NODE_BUS_ARGS(host, nodeid), buffer[1]);
1149 }
1150
1151 guid = ((u64)buffer[3] << 32) | buffer[4];
1152 ne = find_entry_by_guid(guid);
1153
1154 if (!ne)
1155 nodemgr_create_node(guid, buffer[2], hi, nodeid, generation);
1156 else
1157 nodemgr_update_node(ne, buffer[2], hi, nodeid, generation);
1158
1159 return;
1160 }
1161
nodemgr_node_probe_cleanup(struct hpsb_host * host,unsigned int generation)1162 static void nodemgr_node_probe_cleanup(struct hpsb_host *host, unsigned int generation)
1163 {
1164 struct list_head *lh, *next;
1165 struct node_entry *ne;
1166
1167 /* Now check to see if we have any nodes that aren't referenced
1168 * any longer. */
1169 list_for_each_safe(lh, next, &node_list) {
1170 ne = list_entry(lh, struct node_entry, list);
1171
1172 /* Only checking this host */
1173 if (ne->host != host)
1174 continue;
1175
1176 /* If the generation didn't get updated, then either the
1177 * node was removed, or it failed the above probe. Either
1178 * way, we remove references to it, since they are
1179 * invalid. */
1180 if (ne->generation != generation)
1181 nodemgr_remove_node(ne);
1182 }
1183
1184 return;
1185 }
1186
nodemgr_node_probe(struct host_info * hi,int generation)1187 static void nodemgr_node_probe(struct host_info *hi, int generation)
1188 {
1189 int count;
1190 struct hpsb_host *host = hi->host;
1191 struct selfid *sid = (struct selfid *)host->topology_map;
1192 nodeid_t nodeid = LOCAL_BUS;
1193
1194 /* Scan each node on the bus */
1195 for (count = host->selfid_count; count; count--, sid++) {
1196 if (sid->extended)
1197 continue;
1198
1199 if (!sid->link_active) {
1200 nodeid++;
1201 continue;
1202 }
1203 nodemgr_node_probe_one(hi, nodeid++, generation);
1204 }
1205
1206 /* If we had a bus reset while we were scanning the bus, it is
1207 * possible that we did not probe all nodes. In that case, we
1208 * skip the clean up for now, since we could remove nodes that
1209 * were still on the bus. The bus reset increased hi->reset_sem,
1210 * so there's a bus scan pending which will do the clean up
1211 * eventually. */
1212 if (generation == get_hpsb_generation(host))
1213 nodemgr_node_probe_cleanup(host, generation);
1214
1215 return;
1216 }
1217
1218 /* Because we are a 1394a-2000 compliant IRM, we need to inform all the other
1219 * nodes of the broadcast channel. (Really we're only setting the validity
1220 * bit). Other IRM responsibilities go in here as well. */
nodemgr_do_irm_duties(struct hpsb_host * host)1221 static void nodemgr_do_irm_duties(struct hpsb_host *host)
1222 {
1223 quadlet_t bc;
1224
1225 if (!host->is_irm)
1226 return;
1227
1228 host->csr.broadcast_channel |= 0x40000000; /* set validity bit */
1229
1230 bc = cpu_to_be32(host->csr.broadcast_channel);
1231
1232 hpsb_write(host, LOCAL_BUS | ALL_NODES, get_hpsb_generation(host),
1233 (CSR_REGISTER_BASE | CSR_BROADCAST_CHANNEL),
1234 &bc, sizeof(quadlet_t));
1235
1236 /* If there is no bus manager then we should set the root node's
1237 * force_root bit to promote bus stability per the 1394
1238 * spec. (8.4.2.6) */
1239 if (host->busmgr_id == 0xffff && host->node_count > 1)
1240 {
1241 u16 root_node = host->node_count - 1;
1242 struct node_entry *ne = find_entry_by_nodeid(host, root_node | LOCAL_BUS);
1243
1244 if (ne && ne->busopt.cmc)
1245 hpsb_send_phy_config(host, root_node, -1);
1246 else {
1247 HPSB_DEBUG("The root node is not cycle master capable; "
1248 "selecting a new root node and resetting...");
1249 hpsb_send_phy_config(host, NODEID_TO_NODE(host->node_id), -1);
1250 hpsb_reset_bus(host, LONG_RESET_FORCE_ROOT);
1251 }
1252 }
1253 }
1254
1255 /* We need to ensure that if we are not the IRM, that the IRM node is capable of
1256 * everything we can do, otherwise issue a bus reset and try to become the IRM
1257 * ourselves. */
nodemgr_check_irm_capability(struct hpsb_host * host,int cycles)1258 static int nodemgr_check_irm_capability(struct hpsb_host *host, int cycles)
1259 {
1260 quadlet_t bc;
1261 int status;
1262
1263 if (host->is_irm)
1264 return 1;
1265
1266 status = hpsb_read(host, LOCAL_BUS | (host->irm_id),
1267 get_hpsb_generation(host),
1268 (CSR_REGISTER_BASE | CSR_BROADCAST_CHANNEL),
1269 &bc, sizeof(quadlet_t));
1270
1271 if (status < 0 || !(be32_to_cpu(bc) & 0x80000000)) {
1272 /* The current irm node does not have a valid BROADCAST_CHANNEL
1273 * register and we do, so reset the bus with force_root set */
1274 HPSB_DEBUG("Current remote IRM is not 1394a-2000 compliant, resetting...");
1275
1276 if (cycles >= 5) {
1277 /* Oh screw it! Just leave the bus as it is */
1278 HPSB_DEBUG("Stopping reset loop for IRM sanity");
1279 return 1;
1280 }
1281
1282 hpsb_send_phy_config(host, NODEID_TO_NODE(host->node_id), -1);
1283 hpsb_reset_bus(host, LONG_RESET_FORCE_ROOT);
1284
1285 return 0;
1286 }
1287
1288 return 1;
1289 }
1290
nodemgr_host_thread(void * __hi)1291 static int nodemgr_host_thread(void *__hi)
1292 {
1293 struct host_info *hi = (struct host_info *)__hi;
1294 struct hpsb_host *host = hi->host;
1295 int reset_cycles = 0;
1296
1297 /* No userlevel access needed */
1298 daemonize();
1299
1300 strcpy(current->comm, hi->daemon_name);
1301
1302 /* Sit and wait for a signal to probe the nodes on the bus. This
1303 * happens when we get a bus reset. */
1304 while (!down_interruptible(&hi->reset_sem) &&
1305 !down_interruptible(&nodemgr_serialize)) {
1306 unsigned int generation = 0;
1307 int i;
1308
1309 /* Pause for 1/4 second in 1/16 second intervals,
1310 * to make sure things settle down. */
1311 for (i = 0; i < 4 ; i++) {
1312 set_current_state(TASK_INTERRUPTIBLE);
1313 if (schedule_timeout(HZ/16)) {
1314 up(&nodemgr_serialize);
1315 goto caught_signal;
1316 }
1317
1318 /* Now get the generation in which the node ID's we collect
1319 * are valid. During the bus scan we will use this generation
1320 * for the read transactions, so that if another reset occurs
1321 * during the scan the transactions will fail instead of
1322 * returning bogus data. */
1323 generation = get_hpsb_generation(host);
1324
1325 /* If we get a reset before we are done waiting, then
1326 * start the the waiting over again */
1327 while (!down_trylock(&hi->reset_sem))
1328 i = 0;
1329 }
1330
1331 if (!nodemgr_check_irm_capability(host, reset_cycles++)) {
1332 /* Do nothing, we are resetting */
1333 up(&nodemgr_serialize);
1334 continue;
1335 }
1336
1337 reset_cycles = 0;
1338
1339 nodemgr_node_probe(hi, generation);
1340 nodemgr_do_irm_duties(host);
1341
1342 up(&nodemgr_serialize);
1343 }
1344
1345 caught_signal:
1346 HPSB_VERBOSE("NodeMgr: Exiting thread");
1347
1348 complete_and_exit(&hi->exited, 0);
1349 }
1350
hpsb_guid_get_entry(u64 guid)1351 struct node_entry *hpsb_guid_get_entry(u64 guid)
1352 {
1353 struct node_entry *ne;
1354
1355 down(&nodemgr_serialize);
1356 ne = find_entry_by_guid(guid);
1357 up(&nodemgr_serialize);
1358
1359 return ne;
1360 }
1361
hpsb_nodeid_get_entry(struct hpsb_host * host,nodeid_t nodeid)1362 struct node_entry *hpsb_nodeid_get_entry(struct hpsb_host *host, nodeid_t nodeid)
1363 {
1364 struct node_entry *ne;
1365
1366 down(&nodemgr_serialize);
1367 ne = find_entry_by_nodeid(host, nodeid);
1368 up(&nodemgr_serialize);
1369
1370 return ne;
1371 }
1372
1373 /* The following four convenience functions use a struct node_entry
1374 * for addressing a node on the bus. They are intended for use by any
1375 * process context, not just the nodemgr thread, so we need to be a
1376 * little careful when reading out the node ID and generation. The
1377 * thing that can go wrong is that we get the node ID, then a bus
1378 * reset occurs, and then we read the generation. The node ID is
1379 * possibly invalid, but the generation is current, and we end up
1380 * sending a packet to a the wrong node.
1381 *
1382 * The solution is to make sure we read the generation first, so that
1383 * if a reset occurs in the process, we end up with a stale generation
1384 * and the transactions will fail instead of silently using wrong node
1385 * ID's.
1386 */
1387
hpsb_node_fill_packet(struct node_entry * ne,struct hpsb_packet * pkt)1388 void hpsb_node_fill_packet(struct node_entry *ne, struct hpsb_packet *pkt)
1389 {
1390 pkt->host = ne->host;
1391 pkt->generation = ne->generation;
1392 barrier();
1393 pkt->node_id = ne->nodeid;
1394 }
1395
hpsb_node_read(struct node_entry * ne,u64 addr,quadlet_t * buffer,size_t length)1396 int hpsb_node_read(struct node_entry *ne, u64 addr,
1397 quadlet_t *buffer, size_t length)
1398 {
1399 unsigned int generation = ne->generation;
1400
1401 barrier();
1402 return hpsb_read(ne->host, ne->nodeid, generation,
1403 addr, buffer, length);
1404 }
1405
hpsb_node_write(struct node_entry * ne,u64 addr,quadlet_t * buffer,size_t length)1406 int hpsb_node_write(struct node_entry *ne, u64 addr,
1407 quadlet_t *buffer, size_t length)
1408 {
1409 unsigned int generation = ne->generation;
1410
1411 barrier();
1412 return hpsb_write(ne->host, ne->nodeid, generation,
1413 addr, buffer, length);
1414 }
1415
hpsb_node_lock(struct node_entry * ne,u64 addr,int extcode,quadlet_t * data,quadlet_t arg)1416 int hpsb_node_lock(struct node_entry *ne, u64 addr,
1417 int extcode, quadlet_t *data, quadlet_t arg)
1418 {
1419 unsigned int generation = ne->generation;
1420
1421 barrier();
1422 return hpsb_lock(ne->host, ne->nodeid, generation,
1423 addr, extcode, data, arg);
1424 }
1425
nodemgr_add_host(struct hpsb_host * host)1426 static void nodemgr_add_host(struct hpsb_host *host)
1427 {
1428 struct host_info *hi;
1429
1430 hi = hpsb_create_hostinfo(&nodemgr_highlevel, host, sizeof(*hi));
1431
1432 if (!hi) {
1433 HPSB_ERR ("NodeMgr: out of memory in add host");
1434 return;
1435 }
1436
1437 hi->host = host;
1438 init_completion(&hi->exited);
1439 sema_init(&hi->reset_sem, 0);
1440
1441 sprintf(hi->daemon_name, "knodemgrd_%d", host->id);
1442
1443 hi->pid = kernel_thread(nodemgr_host_thread, hi,
1444 CLONE_FS | CLONE_FILES | CLONE_SIGHAND);
1445
1446 if (hi->pid < 0) {
1447 HPSB_ERR ("NodeMgr: failed to start %s thread for %s",
1448 hi->daemon_name, host->driver->name);
1449 hpsb_destroy_hostinfo(&nodemgr_highlevel, host);
1450 return;
1451 }
1452
1453 return;
1454 }
1455
nodemgr_host_reset(struct hpsb_host * host)1456 static void nodemgr_host_reset(struct hpsb_host *host)
1457 {
1458 struct host_info *hi = hpsb_get_hostinfo(&nodemgr_highlevel, host);
1459
1460 if (hi != NULL) {
1461 HPSB_VERBOSE("NodeMgr: Processing host reset for %s", hi->daemon_name);
1462 up(&hi->reset_sem);
1463 } else
1464 HPSB_ERR ("NodeMgr: could not process reset of unused host");
1465
1466 return;
1467 }
1468
nodemgr_remove_host(struct hpsb_host * host)1469 static void nodemgr_remove_host(struct hpsb_host *host)
1470 {
1471 struct list_head *lh, *next;
1472 struct node_entry *ne;
1473 struct host_info *hi = hpsb_get_hostinfo(&nodemgr_highlevel, host);
1474
1475 if (hi) {
1476 if (hi->pid >= 0) {
1477 kill_proc(hi->pid, SIGTERM, 1);
1478 wait_for_completion(&hi->exited);
1479 }
1480 } else
1481 HPSB_ERR("NodeMgr: host %s does not exist, cannot remove",
1482 host->driver->name);
1483
1484 down(&nodemgr_serialize);
1485
1486 /* Even if we fail the host_info part, remove all the node
1487 * entries. */
1488 list_for_each_safe(lh, next, &node_list) {
1489 ne = list_entry(lh, struct node_entry, list);
1490
1491 if (ne->host == host)
1492 nodemgr_remove_node(ne);
1493 }
1494
1495 up(&nodemgr_serialize);
1496
1497 return;
1498 }
1499
1500 static struct hpsb_highlevel nodemgr_highlevel = {
1501 .name = "Node manager",
1502 .add_host = nodemgr_add_host,
1503 .host_reset = nodemgr_host_reset,
1504 .remove_host = nodemgr_remove_host,
1505 };
1506
1507 #define PROC_ENTRY "devices"
1508
init_ieee1394_nodemgr(void)1509 void init_ieee1394_nodemgr(void)
1510 {
1511 #ifdef CONFIG_PROC_FS
1512 if (!create_proc_read_entry(PROC_ENTRY, 0444, ieee1394_procfs_entry, raw1394_read_proc, NULL))
1513 HPSB_ERR("Can't create devices procfs entry");
1514 #endif
1515 hpsb_register_highlevel(&nodemgr_highlevel);
1516 }
1517
cleanup_ieee1394_nodemgr(void)1518 void cleanup_ieee1394_nodemgr(void)
1519 {
1520 hpsb_unregister_highlevel(&nodemgr_highlevel);
1521 #ifdef CONFIG_PROC_FS
1522 remove_proc_entry(PROC_ENTRY, ieee1394_procfs_entry);
1523 #endif
1524 }
1525