2 * Node information (ConfigROM) collection and management.
4 * Copyright (C) 2000 Andreas E. Bombe
5 * 2001-2003 Ben Collins <bcollins@debian.net>
7 * This code is licensed under the GPL. See the file COPYING in the root
8 * directory of the kernel sources for details.
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 #include <linux/pci.h>
21 #include <linux/moduleparam.h>
22 #include <asm/atomic.h>
24 #include "ieee1394_types.h"
26 #include "ieee1394_core.h"
28 #include "ieee1394_transactions.h"
29 #include "highlevel.h"
33 static int ignore_drivers
= 0;
34 module_param(ignore_drivers
, int, 0444);
35 MODULE_PARM_DESC(ignore_drivers
, "Disable automatic probing for drivers.");
37 struct nodemgr_csr_info
{
38 struct hpsb_host
*host
;
40 unsigned int generation
;
44 static char *nodemgr_find_oui_name(int oui
)
46 #ifdef CONFIG_IEEE1394_OUI_DB
47 extern struct oui_list_struct
{
53 for (i
= 0; oui_list
[i
].name
; i
++)
54 if (oui_list
[i
].oui
== oui
)
55 return oui_list
[i
].name
;
61 static int nodemgr_bus_read(struct csr1212_csr
*csr
, u64 addr
, u16 length
,
62 void *buffer
, void *__ci
)
64 struct nodemgr_csr_info
*ci
= (struct nodemgr_csr_info
*)__ci
;
67 for (i
= 0; i
< 3; i
++) {
68 ret
= hpsb_read(ci
->host
, ci
->nodeid
, ci
->generation
, addr
,
73 if (msleep_interruptible(334))
80 static int nodemgr_get_max_rom(quadlet_t
*bus_info_data
, void *__ci
)
82 return (CSR1212_BE32_TO_CPU(bus_info_data
[2]) >> 8) & 0x3;
85 static struct csr1212_bus_ops nodemgr_csr_ops
= {
86 .bus_read
= nodemgr_bus_read
,
87 .get_max_rom
= nodemgr_get_max_rom
92 * Basically what we do here is start off retrieving the bus_info block.
93 * From there will fill in some info about the node, verify it is of IEEE
94 * 1394 type, and that the crc checks out ok. After that we start off with
95 * the root directory, and subdirectories. To do this, we retrieve the
96 * quadlet header for a directory, find out the length, and retrieve the
97 * complete directory entry (be it a leaf or a directory). We then process
98 * it and add the info to our structure for that particular node.
100 * We verify CRC's along the way for each directory/block/leaf. The entire
101 * node structure is generic, and simply stores the information in a way
102 * that's easy to parse by the protocol interface.
106 * The nodemgr relies heavily on the Driver Model for device callbacks and
107 * driver/device mappings. The old nodemgr used to handle all this itself,
108 * but now we are much simpler because of the LDM.
111 static DECLARE_MUTEX(nodemgr_serialize
);
114 struct hpsb_host
*host
;
115 struct list_head list
;
116 struct completion exited
;
117 struct semaphore reset_sem
;
119 char daemon_name
[15];
123 static int nodemgr_bus_match(struct device
* dev
, struct device_driver
* drv
);
124 static int nodemgr_hotplug(struct class_device
*cdev
, char **envp
, int num_envp
,
125 char *buffer
, int buffer_size
);
126 static void nodemgr_resume_ne(struct node_entry
*ne
);
127 static void nodemgr_remove_ne(struct node_entry
*ne
);
128 static struct node_entry
*find_entry_by_guid(u64 guid
);
130 struct bus_type ieee1394_bus_type
= {
132 .match
= nodemgr_bus_match
,
135 static void host_cls_release(struct class_device
*class_dev
)
137 put_device(&container_of((class_dev
), struct hpsb_host
, class_dev
)->device
);
140 struct class hpsb_host_class
= {
141 .name
= "ieee1394_host",
142 .release
= host_cls_release
,
145 static void ne_cls_release(struct class_device
*class_dev
)
147 put_device(&container_of((class_dev
), struct node_entry
, class_dev
)->device
);
150 static struct class nodemgr_ne_class
= {
151 .name
= "ieee1394_node",
152 .release
= ne_cls_release
,
155 static void ud_cls_release(struct class_device
*class_dev
)
157 put_device(&container_of((class_dev
), struct unit_directory
, class_dev
)->device
);
160 /* The name here is only so that unit directory hotplug works with old
161 * style hotplug, which only ever did unit directories anyway. */
162 static struct class nodemgr_ud_class
= {
164 .release
= ud_cls_release
,
165 .hotplug
= nodemgr_hotplug
,
168 static struct hpsb_highlevel nodemgr_highlevel
;
171 static void nodemgr_release_ud(struct device
*dev
)
173 struct unit_directory
*ud
= container_of(dev
, struct unit_directory
, device
);
175 if (ud
->vendor_name_kv
)
176 csr1212_release_keyval(ud
->vendor_name_kv
);
177 if (ud
->model_name_kv
)
178 csr1212_release_keyval(ud
->model_name_kv
);
183 static void nodemgr_release_ne(struct device
*dev
)
185 struct node_entry
*ne
= container_of(dev
, struct node_entry
, device
);
187 if (ne
->vendor_name_kv
)
188 csr1212_release_keyval(ne
->vendor_name_kv
);
194 static void nodemgr_release_host(struct device
*dev
)
196 struct hpsb_host
*host
= container_of(dev
, struct hpsb_host
, device
);
198 csr1212_destroy_csr(host
->csr
.rom
);
203 static int nodemgr_ud_platform_data
;
205 static struct device nodemgr_dev_template_ud
= {
206 .bus
= &ieee1394_bus_type
,
207 .release
= nodemgr_release_ud
,
208 .platform_data
= &nodemgr_ud_platform_data
,
211 static struct device nodemgr_dev_template_ne
= {
212 .bus
= &ieee1394_bus_type
,
213 .release
= nodemgr_release_ne
,
216 struct device nodemgr_dev_template_host
= {
217 .bus
= &ieee1394_bus_type
,
218 .release
= nodemgr_release_host
,
222 #define fw_attr(class, class_type, field, type, format_string) \
223 static ssize_t fw_show_##class##_##field (struct device *dev, char *buf)\
226 class = container_of(dev, class_type, device); \
227 return sprintf(buf, format_string, (type)class->field); \
229 static struct device_attribute dev_attr_##class##_##field = { \
230 .attr = {.name = __stringify(field), .mode = S_IRUGO }, \
231 .show = fw_show_##class##_##field, \
234 #define fw_attr_td(class, class_type, td_kv) \
235 static ssize_t fw_show_##class##_##td_kv (struct device *dev, char *buf)\
238 class_type *class = container_of(dev, class_type, device); \
239 len = (class->td_kv->value.leaf.len - 2) * sizeof(quadlet_t); \
241 CSR1212_TEXTUAL_DESCRIPTOR_LEAF_DATA(class->td_kv), \
243 while ((buf + len - 1) == '\0') \
249 static struct device_attribute dev_attr_##class##_##td_kv = { \
250 .attr = {.name = __stringify(td_kv), .mode = S_IRUGO }, \
251 .show = fw_show_##class##_##td_kv, \
255 #define fw_drv_attr(field, type, format_string) \
256 static ssize_t fw_drv_show_##field (struct device_driver *drv, char *buf) \
258 struct hpsb_protocol_driver *driver; \
259 driver = container_of(drv, struct hpsb_protocol_driver, driver); \
260 return sprintf(buf, format_string, (type)driver->field);\
262 static struct driver_attribute driver_attr_drv_##field = { \
263 .attr = {.name = __stringify(field), .mode = S_IRUGO }, \
264 .show = fw_drv_show_##field, \
268 static ssize_t
fw_show_ne_bus_options(struct device
*dev
, char *buf
)
270 struct node_entry
*ne
= container_of(dev
, struct node_entry
, device
);
272 return sprintf(buf
, "IRMC(%d) CMC(%d) ISC(%d) BMC(%d) PMC(%d) GEN(%d) "
273 "LSPD(%d) MAX_REC(%d) MAX_ROM(%d) CYC_CLK_ACC(%d)\n",
275 ne
->busopt
.cmc
, ne
->busopt
.isc
, ne
->busopt
.bmc
,
276 ne
->busopt
.pmc
, ne
->busopt
.generation
, ne
->busopt
.lnkspd
,
279 ne
->busopt
.cyc_clk_acc
);
281 static DEVICE_ATTR(bus_options
,S_IRUGO
,fw_show_ne_bus_options
,NULL
);
284 static ssize_t
fw_show_ne_tlabels_free(struct device
*dev
, char *buf
)
286 struct node_entry
*ne
= container_of(dev
, struct node_entry
, device
);
287 return sprintf(buf
, "%d\n", atomic_read(&ne
->tpool
->count
.count
) + 1);
289 static DEVICE_ATTR(tlabels_free
,S_IRUGO
,fw_show_ne_tlabels_free
,NULL
);
292 static ssize_t
fw_show_ne_tlabels_allocations(struct device
*dev
, char *buf
)
294 struct node_entry
*ne
= container_of(dev
, struct node_entry
, device
);
295 return sprintf(buf
, "%u\n", ne
->tpool
->allocations
);
297 static DEVICE_ATTR(tlabels_allocations
,S_IRUGO
,fw_show_ne_tlabels_allocations
,NULL
);
300 static ssize_t
fw_show_ne_tlabels_mask(struct device
*dev
, char *buf
)
302 struct node_entry
*ne
= container_of(dev
, struct node_entry
, device
);
303 #if (BITS_PER_LONG <= 32)
304 return sprintf(buf
, "0x%08lx%08lx\n", ne
->tpool
->pool
[0], ne
->tpool
->pool
[1]);
306 return sprintf(buf
, "0x%016lx\n", ne
->tpool
->pool
[0]);
309 static DEVICE_ATTR(tlabels_mask
, S_IRUGO
, fw_show_ne_tlabels_mask
, NULL
);
312 static ssize_t
fw_set_ignore_driver(struct device
*dev
, const char *buf
, size_t count
)
314 struct unit_directory
*ud
= container_of(dev
, struct unit_directory
, device
);
315 int state
= simple_strtoul(buf
, NULL
, 10);
318 down_write(&dev
->bus
->subsys
.rwsem
);
319 device_release_driver(dev
);
320 ud
->ignore_driver
= 1;
321 up_write(&dev
->bus
->subsys
.rwsem
);
323 ud
->ignore_driver
= 0;
327 static ssize_t
fw_get_ignore_driver(struct device
*dev
, char *buf
)
329 struct unit_directory
*ud
= container_of(dev
, struct unit_directory
, device
);
331 return sprintf(buf
, "%d\n", ud
->ignore_driver
);
333 static DEVICE_ATTR(ignore_driver
, S_IWUSR
| S_IRUGO
, fw_get_ignore_driver
, fw_set_ignore_driver
);
336 static ssize_t
fw_set_destroy_node(struct bus_type
*bus
, const char *buf
, size_t count
)
338 struct node_entry
*ne
;
339 u64 guid
= (u64
)simple_strtoull(buf
, NULL
, 16);
341 ne
= find_entry_by_guid(guid
);
343 if (ne
== NULL
|| !ne
->in_limbo
)
346 nodemgr_remove_ne(ne
);
350 static ssize_t
fw_get_destroy_node(struct bus_type
*bus
, char *buf
)
352 return sprintf(buf
, "You can destroy in_limbo nodes by writing their GUID to this file\n");
354 static BUS_ATTR(destroy_node
, S_IWUSR
| S_IRUGO
, fw_get_destroy_node
, fw_set_destroy_node
);
356 static int nodemgr_rescan_bus_thread(void *__unused
)
358 /* No userlevel access needed */
359 daemonize("kfwrescan");
361 bus_rescan_devices(&ieee1394_bus_type
);
366 static ssize_t
fw_set_rescan(struct bus_type
*bus
, const char *buf
, size_t count
)
368 int state
= simple_strtoul(buf
, NULL
, 10);
370 /* Don't wait for this, or care about errors. Root could do
371 * something stupid and spawn this a lot of times, but that's
374 kernel_thread(nodemgr_rescan_bus_thread
, NULL
, CLONE_KERNEL
);
378 static ssize_t
fw_get_rescan(struct bus_type
*bus
, char *buf
)
380 return sprintf(buf
, "You can force a rescan of the bus for "
381 "drivers by writing a 1 to this file\n");
383 static BUS_ATTR(rescan
, S_IWUSR
| S_IRUGO
, fw_get_rescan
, fw_set_rescan
);
386 static ssize_t
fw_set_ignore_drivers(struct bus_type
*bus
, const char *buf
, size_t count
)
388 int state
= simple_strtoul(buf
, NULL
, 10);
397 static ssize_t
fw_get_ignore_drivers(struct bus_type
*bus
, char *buf
)
399 return sprintf(buf
, "%d\n", ignore_drivers
);
401 static BUS_ATTR(ignore_drivers
, S_IWUSR
| S_IRUGO
, fw_get_ignore_drivers
, fw_set_ignore_drivers
);
404 struct bus_attribute
*const fw_bus_attrs
[] = {
405 &bus_attr_destroy_node
,
407 &bus_attr_ignore_drivers
,
412 fw_attr(ne
, struct node_entry
, capabilities
, unsigned int, "0x%06x\n")
413 fw_attr(ne
, struct node_entry
, nodeid
, unsigned int, "0x%04x\n")
415 fw_attr(ne
, struct node_entry
, vendor_id
, unsigned int, "0x%06x\n")
416 fw_attr_td(ne
, struct node_entry
, vendor_name_kv
)
417 fw_attr(ne
, struct node_entry
, vendor_oui
, const char *, "%s\n")
419 fw_attr(ne
, struct node_entry
, guid
, unsigned long long, "0x%016Lx\n")
420 fw_attr(ne
, struct node_entry
, guid_vendor_id
, unsigned int, "0x%06x\n")
421 fw_attr(ne
, struct node_entry
, guid_vendor_oui
, const char *, "%s\n")
422 fw_attr(ne
, struct node_entry
, in_limbo
, int, "%d\n");
424 static struct device_attribute
*const fw_ne_attrs
[] = {
426 &dev_attr_ne_guid_vendor_id
,
427 &dev_attr_ne_capabilities
,
428 &dev_attr_ne_vendor_id
,
430 &dev_attr_bus_options
,
431 &dev_attr_tlabels_free
,
432 &dev_attr_tlabels_allocations
,
433 &dev_attr_tlabels_mask
,
438 fw_attr(ud
, struct unit_directory
, address
, unsigned long long, "0x%016Lx\n")
439 fw_attr(ud
, struct unit_directory
, length
, int, "%d\n")
440 /* These are all dependent on the value being provided */
441 fw_attr(ud
, struct unit_directory
, vendor_id
, unsigned int, "0x%06x\n")
442 fw_attr(ud
, struct unit_directory
, model_id
, unsigned int, "0x%06x\n")
443 fw_attr(ud
, struct unit_directory
, specifier_id
, unsigned int, "0x%06x\n")
444 fw_attr(ud
, struct unit_directory
, version
, unsigned int, "0x%06x\n")
445 fw_attr_td(ud
, struct unit_directory
, vendor_name_kv
)
446 fw_attr(ud
, struct unit_directory
, vendor_oui
, const char *, "%s\n")
447 fw_attr_td(ud
, struct unit_directory
, model_name_kv
)
449 static struct device_attribute
*const fw_ud_attrs
[] = {
450 &dev_attr_ud_address
,
452 &dev_attr_ignore_driver
,
456 fw_attr(host
, struct hpsb_host
, node_count
, int, "%d\n")
457 fw_attr(host
, struct hpsb_host
, selfid_count
, int, "%d\n")
458 fw_attr(host
, struct hpsb_host
, nodes_active
, int, "%d\n")
459 fw_attr(host
, struct hpsb_host
, in_bus_reset
, int, "%d\n")
460 fw_attr(host
, struct hpsb_host
, is_root
, int, "%d\n")
461 fw_attr(host
, struct hpsb_host
, is_cycmst
, int, "%d\n")
462 fw_attr(host
, struct hpsb_host
, is_irm
, int, "%d\n")
463 fw_attr(host
, struct hpsb_host
, is_busmgr
, int, "%d\n")
465 static struct device_attribute
*const fw_host_attrs
[] = {
466 &dev_attr_host_node_count
,
467 &dev_attr_host_selfid_count
,
468 &dev_attr_host_nodes_active
,
469 &dev_attr_host_in_bus_reset
,
470 &dev_attr_host_is_root
,
471 &dev_attr_host_is_cycmst
,
472 &dev_attr_host_is_irm
,
473 &dev_attr_host_is_busmgr
,
477 static ssize_t
fw_show_drv_device_ids(struct device_driver
*drv
, char *buf
)
479 struct hpsb_protocol_driver
*driver
;
480 struct ieee1394_device_id
*id
;
484 driver
= container_of(drv
, struct hpsb_protocol_driver
, driver
);
486 for (id
= driver
->id_table
; id
->match_flags
!= 0; id
++) {
489 if (id
->match_flags
& IEEE1394_MATCH_VENDOR_ID
) {
490 length
+= sprintf(scratch
, "vendor_id=0x%06x", id
->vendor_id
);
491 scratch
= buf
+ length
;
495 if (id
->match_flags
& IEEE1394_MATCH_MODEL_ID
) {
496 length
+= sprintf(scratch
, "%smodel_id=0x%06x",
497 need_coma
++ ? "," : "",
499 scratch
= buf
+ length
;
502 if (id
->match_flags
& IEEE1394_MATCH_SPECIFIER_ID
) {
503 length
+= sprintf(scratch
, "%sspecifier_id=0x%06x",
504 need_coma
++ ? "," : "",
506 scratch
= buf
+ length
;
509 if (id
->match_flags
& IEEE1394_MATCH_VERSION
) {
510 length
+= sprintf(scratch
, "%sversion=0x%06x",
511 need_coma
++ ? "," : "",
513 scratch
= buf
+ length
;
524 static DRIVER_ATTR(device_ids
,S_IRUGO
,fw_show_drv_device_ids
,NULL
);
527 fw_drv_attr(name
, const char *, "%s\n")
529 static struct driver_attribute
*const fw_drv_attrs
[] = {
530 &driver_attr_drv_name
,
531 &driver_attr_device_ids
,
535 static void nodemgr_create_drv_files(struct hpsb_protocol_driver
*driver
)
537 struct device_driver
*drv
= &driver
->driver
;
540 for (i
= 0; i
< ARRAY_SIZE(fw_drv_attrs
); i
++)
541 driver_create_file(drv
, fw_drv_attrs
[i
]);
545 static void nodemgr_remove_drv_files(struct hpsb_protocol_driver
*driver
)
547 struct device_driver
*drv
= &driver
->driver
;
550 for (i
= 0; i
< ARRAY_SIZE(fw_drv_attrs
); i
++)
551 driver_remove_file(drv
, fw_drv_attrs
[i
]);
555 static void nodemgr_create_ne_dev_files(struct node_entry
*ne
)
557 struct device
*dev
= &ne
->device
;
560 for (i
= 0; i
< ARRAY_SIZE(fw_ne_attrs
); i
++)
561 device_create_file(dev
, fw_ne_attrs
[i
]);
565 static void nodemgr_create_host_dev_files(struct hpsb_host
*host
)
567 struct device
*dev
= &host
->device
;
570 for (i
= 0; i
< ARRAY_SIZE(fw_host_attrs
); i
++)
571 device_create_file(dev
, fw_host_attrs
[i
]);
575 static struct node_entry
*find_entry_by_nodeid(struct hpsb_host
*host
, nodeid_t nodeid
);
577 static void nodemgr_update_host_dev_links(struct hpsb_host
*host
)
579 struct device
*dev
= &host
->device
;
580 struct node_entry
*ne
;
582 sysfs_remove_link(&dev
->kobj
, "irm_id");
583 sysfs_remove_link(&dev
->kobj
, "busmgr_id");
584 sysfs_remove_link(&dev
->kobj
, "host_id");
586 if ((ne
= find_entry_by_nodeid(host
, host
->irm_id
)))
587 sysfs_create_link(&dev
->kobj
, &ne
->device
.kobj
, "irm_id");
588 if ((ne
= find_entry_by_nodeid(host
, host
->busmgr_id
)))
589 sysfs_create_link(&dev
->kobj
, &ne
->device
.kobj
, "busmgr_id");
590 if ((ne
= find_entry_by_nodeid(host
, host
->node_id
)))
591 sysfs_create_link(&dev
->kobj
, &ne
->device
.kobj
, "host_id");
594 static void nodemgr_create_ud_dev_files(struct unit_directory
*ud
)
596 struct device
*dev
= &ud
->device
;
599 for (i
= 0; i
< ARRAY_SIZE(fw_ud_attrs
); i
++)
600 device_create_file(dev
, fw_ud_attrs
[i
]);
602 if (ud
->flags
& UNIT_DIRECTORY_SPECIFIER_ID
)
603 device_create_file(dev
, &dev_attr_ud_specifier_id
);
605 if (ud
->flags
& UNIT_DIRECTORY_VERSION
)
606 device_create_file(dev
, &dev_attr_ud_version
);
608 if (ud
->flags
& UNIT_DIRECTORY_VENDOR_ID
) {
609 device_create_file(dev
, &dev_attr_ud_vendor_id
);
610 if (ud
->vendor_name_kv
)
611 device_create_file(dev
, &dev_attr_ud_vendor_name_kv
);
614 if (ud
->flags
& UNIT_DIRECTORY_MODEL_ID
) {
615 device_create_file(dev
, &dev_attr_ud_model_id
);
616 if (ud
->model_name_kv
)
617 device_create_file(dev
, &dev_attr_ud_model_name_kv
);
622 static int nodemgr_bus_match(struct device
* dev
, struct device_driver
* drv
)
624 struct hpsb_protocol_driver
*driver
;
625 struct unit_directory
*ud
;
626 struct ieee1394_device_id
*id
;
628 /* We only match unit directories */
629 if (dev
->platform_data
!= &nodemgr_ud_platform_data
)
632 ud
= container_of(dev
, struct unit_directory
, device
);
633 driver
= container_of(drv
, struct hpsb_protocol_driver
, driver
);
635 if (ud
->ne
->in_limbo
|| ud
->ignore_driver
)
638 for (id
= driver
->id_table
; id
->match_flags
!= 0; id
++) {
639 if ((id
->match_flags
& IEEE1394_MATCH_VENDOR_ID
) &&
640 id
->vendor_id
!= ud
->vendor_id
)
643 if ((id
->match_flags
& IEEE1394_MATCH_MODEL_ID
) &&
644 id
->model_id
!= ud
->model_id
)
647 if ((id
->match_flags
& IEEE1394_MATCH_SPECIFIER_ID
) &&
648 id
->specifier_id
!= ud
->specifier_id
)
651 if ((id
->match_flags
& IEEE1394_MATCH_VERSION
) &&
652 id
->version
!= ud
->version
)
662 static void nodemgr_remove_uds(struct node_entry
*ne
)
664 struct class_device
*cdev
, *next
;
665 struct unit_directory
*ud
;
667 list_for_each_entry_safe(cdev
, next
, &nodemgr_ud_class
.children
, node
) {
668 ud
= container_of(cdev
, struct unit_directory
, class_dev
);
673 class_device_unregister(&ud
->class_dev
);
674 device_unregister(&ud
->device
);
679 static void nodemgr_remove_ne(struct node_entry
*ne
)
681 struct device
*dev
= &ne
->device
;
683 dev
= get_device(&ne
->device
);
687 HPSB_DEBUG("Node removed: ID:BUS[" NODE_BUS_FMT
"] GUID[%016Lx]",
688 NODE_BUS_ARGS(ne
->host
, ne
->nodeid
), (unsigned long long)ne
->guid
);
690 nodemgr_remove_uds(ne
);
692 class_device_unregister(&ne
->class_dev
);
693 device_unregister(dev
);
699 static void nodemgr_remove_host_dev(struct device
*dev
)
701 struct device
*ne_dev
, *next
;
703 list_for_each_entry_safe(ne_dev
, next
, &dev
->children
, node
)
704 nodemgr_remove_ne(container_of(ne_dev
, struct node_entry
, device
));
706 sysfs_remove_link(&dev
->kobj
, "irm_id");
707 sysfs_remove_link(&dev
->kobj
, "busmgr_id");
708 sysfs_remove_link(&dev
->kobj
, "host_id");
712 static void nodemgr_update_bus_options(struct node_entry
*ne
)
714 #ifdef CONFIG_IEEE1394_VERBOSEDEBUG
715 static const u16 mr
[] = { 4, 64, 1024, 0};
717 quadlet_t busoptions
= be32_to_cpu(ne
->csr
->bus_info_data
[2]);
719 ne
->busopt
.irmc
= (busoptions
>> 31) & 1;
720 ne
->busopt
.cmc
= (busoptions
>> 30) & 1;
721 ne
->busopt
.isc
= (busoptions
>> 29) & 1;
722 ne
->busopt
.bmc
= (busoptions
>> 28) & 1;
723 ne
->busopt
.pmc
= (busoptions
>> 27) & 1;
724 ne
->busopt
.cyc_clk_acc
= (busoptions
>> 16) & 0xff;
725 ne
->busopt
.max_rec
= 1 << (((busoptions
>> 12) & 0xf) + 1);
726 ne
->busopt
.max_rom
= (busoptions
>> 8) & 0x3;
727 ne
->busopt
.generation
= (busoptions
>> 4) & 0xf;
728 ne
->busopt
.lnkspd
= busoptions
& 0x7;
730 HPSB_VERBOSE("NodeMgr: raw=0x%08x irmc=%d cmc=%d isc=%d bmc=%d pmc=%d "
731 "cyc_clk_acc=%d max_rec=%d max_rom=%d gen=%d lspd=%d",
732 busoptions
, ne
->busopt
.irmc
, ne
->busopt
.cmc
,
733 ne
->busopt
.isc
, ne
->busopt
.bmc
, ne
->busopt
.pmc
,
734 ne
->busopt
.cyc_clk_acc
, ne
->busopt
.max_rec
,
735 mr
[ne
->busopt
.max_rom
],
736 ne
->busopt
.generation
, ne
->busopt
.lnkspd
);
740 static struct node_entry
*nodemgr_create_node(octlet_t guid
, struct csr1212_csr
*csr
,
741 struct host_info
*hi
, nodeid_t nodeid
,
742 unsigned int generation
)
744 struct hpsb_host
*host
= hi
->host
;
745 struct node_entry
*ne
;
747 ne
= kmalloc(sizeof(struct node_entry
), GFP_KERNEL
);
748 if (!ne
) return NULL
;
750 memset(ne
, 0, sizeof(struct node_entry
));
752 ne
->tpool
= &host
->tpool
[nodeid
& NODE_MASK
];
756 ne
->generation
= generation
;
760 ne
->guid_vendor_id
= (guid
>> 40) & 0xffffff;
761 ne
->guid_vendor_oui
= nodemgr_find_oui_name(ne
->guid_vendor_id
);
764 memcpy(&ne
->device
, &nodemgr_dev_template_ne
,
766 ne
->device
.parent
= &host
->device
;
767 snprintf(ne
->device
.bus_id
, BUS_ID_SIZE
, "%016Lx",
768 (unsigned long long)(ne
->guid
));
770 ne
->class_dev
.dev
= &ne
->device
;
771 ne
->class_dev
.class = &nodemgr_ne_class
;
772 snprintf(ne
->class_dev
.class_id
, BUS_ID_SIZE
, "%016Lx",
773 (unsigned long long)(ne
->guid
));
775 device_register(&ne
->device
);
776 class_device_register(&ne
->class_dev
);
777 get_device(&ne
->device
);
779 if (ne
->guid_vendor_oui
)
780 device_create_file(&ne
->device
, &dev_attr_ne_guid_vendor_oui
);
781 nodemgr_create_ne_dev_files(ne
);
783 nodemgr_update_bus_options(ne
);
785 HPSB_DEBUG("%s added: ID:BUS[" NODE_BUS_FMT
"] GUID[%016Lx]",
786 (host
->node_id
== nodeid
) ? "Host" : "Node",
787 NODE_BUS_ARGS(host
, nodeid
), (unsigned long long)guid
);
793 static struct node_entry
*find_entry_by_guid(u64 guid
)
795 struct class *class = &nodemgr_ne_class
;
796 struct class_device
*cdev
;
797 struct node_entry
*ne
, *ret_ne
= NULL
;
799 down_read(&class->subsys
.rwsem
);
800 list_for_each_entry(cdev
, &class->children
, node
) {
801 ne
= container_of(cdev
, struct node_entry
, class_dev
);
803 if (ne
->guid
== guid
) {
808 up_read(&class->subsys
.rwsem
);
814 static struct node_entry
*find_entry_by_nodeid(struct hpsb_host
*host
, nodeid_t nodeid
)
816 struct class *class = &nodemgr_ne_class
;
817 struct class_device
*cdev
;
818 struct node_entry
*ne
, *ret_ne
= NULL
;
820 down_read(&class->subsys
.rwsem
);
821 list_for_each_entry(cdev
, &class->children
, node
) {
822 ne
= container_of(cdev
, struct node_entry
, class_dev
);
824 if (ne
->host
== host
&& ne
->nodeid
== nodeid
) {
829 up_read(&class->subsys
.rwsem
);
835 static void nodemgr_register_device(struct node_entry
*ne
,
836 struct unit_directory
*ud
, struct device
*parent
)
838 memcpy(&ud
->device
, &nodemgr_dev_template_ud
,
841 ud
->device
.parent
= parent
;
843 snprintf(ud
->device
.bus_id
, BUS_ID_SIZE
, "%s-%u",
844 ne
->device
.bus_id
, ud
->id
);
846 ud
->class_dev
.dev
= &ud
->device
;
847 ud
->class_dev
.class = &nodemgr_ud_class
;
848 snprintf(ud
->class_dev
.class_id
, BUS_ID_SIZE
, "%s-%u",
849 ne
->device
.bus_id
, ud
->id
);
851 device_register(&ud
->device
);
852 class_device_register(&ud
->class_dev
);
853 get_device(&ud
->device
);
856 device_create_file(&ud
->device
, &dev_attr_ud_vendor_oui
);
857 nodemgr_create_ud_dev_files(ud
);
861 /* This implementation currently only scans the config rom and its
862 * immediate unit directories looking for software_id and
863 * software_version entries, in order to get driver autoloading working. */
864 static struct unit_directory
*nodemgr_process_unit_directory
865 (struct host_info
*hi
, struct node_entry
*ne
, struct csr1212_keyval
*ud_kv
,
866 unsigned int *id
, struct unit_directory
*parent
)
868 struct unit_directory
*ud
;
869 struct unit_directory
*ud_child
= NULL
;
870 struct csr1212_dentry
*dentry
;
871 struct csr1212_keyval
*kv
;
874 ud
= kmalloc(sizeof(struct unit_directory
), GFP_KERNEL
);
876 goto unit_directory_error
;
878 memset (ud
, 0, sizeof(struct unit_directory
));
881 ud
->ignore_driver
= ignore_drivers
;
882 ud
->address
= ud_kv
->offset
+ CSR1212_CONFIG_ROM_SPACE_BASE
;
886 csr1212_for_each_dir_entry(ne
->csr
, kv
, ud_kv
, dentry
) {
887 switch (kv
->key
.id
) {
888 case CSR1212_KV_ID_VENDOR
:
889 if (kv
->key
.type
== CSR1212_KV_TYPE_IMMEDIATE
) {
890 ud
->vendor_id
= kv
->value
.immediate
;
891 ud
->flags
|= UNIT_DIRECTORY_VENDOR_ID
;
894 ud
->vendor_oui
= nodemgr_find_oui_name(ud
->vendor_id
);
898 case CSR1212_KV_ID_MODEL
:
899 ud
->model_id
= kv
->value
.immediate
;
900 ud
->flags
|= UNIT_DIRECTORY_MODEL_ID
;
903 case CSR1212_KV_ID_SPECIFIER_ID
:
904 ud
->specifier_id
= kv
->value
.immediate
;
905 ud
->flags
|= UNIT_DIRECTORY_SPECIFIER_ID
;
908 case CSR1212_KV_ID_VERSION
:
909 ud
->version
= kv
->value
.immediate
;
910 ud
->flags
|= UNIT_DIRECTORY_VERSION
;
913 case CSR1212_KV_ID_DESCRIPTOR
:
914 if (kv
->key
.type
== CSR1212_KV_TYPE_LEAF
&&
915 CSR1212_DESCRIPTOR_LEAF_TYPE(kv
) == 0 &&
916 CSR1212_DESCRIPTOR_LEAF_SPECIFIER_ID(kv
) == 0 &&
917 CSR1212_TEXTUAL_DESCRIPTOR_LEAF_WIDTH(kv
) == 0 &&
918 CSR1212_TEXTUAL_DESCRIPTOR_LEAF_CHAR_SET(kv
) == 0 &&
919 CSR1212_TEXTUAL_DESCRIPTOR_LEAF_LANGUAGE(kv
) == 0) {
920 switch (last_key_id
) {
921 case CSR1212_KV_ID_VENDOR
:
922 ud
->vendor_name_kv
= kv
;
923 csr1212_keep_keyval(kv
);
926 case CSR1212_KV_ID_MODEL
:
927 ud
->model_name_kv
= kv
;
928 csr1212_keep_keyval(kv
);
932 } /* else if (kv->key.type == CSR1212_KV_TYPE_DIRECTORY) ... */
935 case CSR1212_KV_ID_DEPENDENT_INFO
:
936 /* Logical Unit Number */
937 if (kv
->key
.type
== CSR1212_KV_TYPE_IMMEDIATE
) {
938 if (ud
->flags
& UNIT_DIRECTORY_HAS_LUN
) {
939 ud_child
= kmalloc(sizeof(struct unit_directory
), GFP_KERNEL
);
941 goto unit_directory_error
;
942 memcpy(ud_child
, ud
, sizeof(struct unit_directory
));
943 nodemgr_register_device(ne
, ud_child
, &ne
->device
);
948 ud
->lun
= kv
->value
.immediate
;
949 ud
->flags
|= UNIT_DIRECTORY_HAS_LUN
;
951 /* Logical Unit Directory */
952 } else if (kv
->key
.type
== CSR1212_KV_TYPE_DIRECTORY
) {
953 /* This should really be done in SBP2 as this is
954 * doing SBP2 specific parsing.
957 /* first register the parent unit */
958 ud
->flags
|= UNIT_DIRECTORY_HAS_LUN_DIRECTORY
;
959 if (ud
->device
.bus
!= &ieee1394_bus_type
)
960 nodemgr_register_device(ne
, ud
, &ne
->device
);
962 /* process the child unit */
963 ud_child
= nodemgr_process_unit_directory(hi
, ne
, kv
, id
, ud
);
965 if (ud_child
== NULL
)
968 /* inherit unspecified values so hotplug picks it up */
969 if ((ud
->flags
& UNIT_DIRECTORY_MODEL_ID
) &&
970 !(ud_child
->flags
& UNIT_DIRECTORY_MODEL_ID
))
972 ud_child
->flags
|= UNIT_DIRECTORY_MODEL_ID
;
973 ud_child
->model_id
= ud
->model_id
;
975 if ((ud
->flags
& UNIT_DIRECTORY_SPECIFIER_ID
) &&
976 !(ud_child
->flags
& UNIT_DIRECTORY_SPECIFIER_ID
))
978 ud_child
->flags
|= UNIT_DIRECTORY_SPECIFIER_ID
;
979 ud_child
->specifier_id
= ud
->specifier_id
;
981 if ((ud
->flags
& UNIT_DIRECTORY_VERSION
) &&
982 !(ud_child
->flags
& UNIT_DIRECTORY_VERSION
))
984 ud_child
->flags
|= UNIT_DIRECTORY_VERSION
;
985 ud_child
->version
= ud
->version
;
988 /* register the child unit */
989 ud_child
->flags
|= UNIT_DIRECTORY_LUN_DIRECTORY
;
990 nodemgr_register_device(ne
, ud_child
, &ud
->device
);
998 last_key_id
= kv
->key
.id
;
1001 /* do not process child units here and only if not already registered */
1002 if (!parent
&& ud
->device
.bus
!= &ieee1394_bus_type
)
1003 nodemgr_register_device(ne
, ud
, &ne
->device
);
1007 unit_directory_error
:
1014 static void nodemgr_process_root_directory(struct host_info
*hi
, struct node_entry
*ne
)
1016 unsigned int ud_id
= 0;
1017 struct csr1212_dentry
*dentry
;
1018 struct csr1212_keyval
*kv
;
1021 ne
->needs_probe
= 0;
1023 csr1212_for_each_dir_entry(ne
->csr
, kv
, ne
->csr
->root_kv
, dentry
) {
1024 switch (kv
->key
.id
) {
1025 case CSR1212_KV_ID_VENDOR
:
1026 ne
->vendor_id
= kv
->value
.immediate
;
1029 ne
->vendor_oui
= nodemgr_find_oui_name(ne
->vendor_id
);
1032 case CSR1212_KV_ID_NODE_CAPABILITIES
:
1033 ne
->capabilities
= kv
->value
.immediate
;
1036 case CSR1212_KV_ID_UNIT
:
1037 nodemgr_process_unit_directory(hi
, ne
, kv
, &ud_id
, NULL
);
1040 case CSR1212_KV_ID_DESCRIPTOR
:
1041 if (last_key_id
== CSR1212_KV_ID_VENDOR
) {
1042 if (kv
->key
.type
== CSR1212_KV_TYPE_LEAF
&&
1043 CSR1212_DESCRIPTOR_LEAF_TYPE(kv
) == 0 &&
1044 CSR1212_DESCRIPTOR_LEAF_SPECIFIER_ID(kv
) == 0 &&
1045 CSR1212_TEXTUAL_DESCRIPTOR_LEAF_WIDTH(kv
) == 0 &&
1046 CSR1212_TEXTUAL_DESCRIPTOR_LEAF_CHAR_SET(kv
) == 0 &&
1047 CSR1212_TEXTUAL_DESCRIPTOR_LEAF_LANGUAGE(kv
) == 0) {
1048 ne
->vendor_name_kv
= kv
;
1049 csr1212_keep_keyval(kv
);
1054 last_key_id
= kv
->key
.id
;
1058 device_create_file(&ne
->device
, &dev_attr_ne_vendor_oui
);
1059 if (ne
->vendor_name_kv
)
1060 device_create_file(&ne
->device
, &dev_attr_ne_vendor_name_kv
);
1063 #ifdef CONFIG_HOTPLUG
1065 static int nodemgr_hotplug(struct class_device
*cdev
, char **envp
, int num_envp
,
1066 char *buffer
, int buffer_size
)
1068 struct unit_directory
*ud
;
1075 ud
= container_of(cdev
, struct unit_directory
, class_dev
);
1077 if (ud
->ne
->in_limbo
|| ud
->ignore_driver
)
1080 #define PUT_ENVP(fmt,val) \
1083 envp[i++] = buffer; \
1084 printed = snprintf(buffer, buffer_size - length, \
1086 if ((buffer_size - (length+printed) <= 0) || (i >= num_envp)) \
1088 length += printed+1; \
1089 buffer += printed+1; \
1092 PUT_ENVP("VENDOR_ID=%06x", ud
->vendor_id
);
1093 PUT_ENVP("MODEL_ID=%06x", ud
->model_id
);
1094 PUT_ENVP("GUID=%016Lx", (unsigned long long)ud
->ne
->guid
);
1095 PUT_ENVP("SPECIFIER_ID=%06x", ud
->specifier_id
);
1096 PUT_ENVP("VERSION=%06x", ud
->version
);
1107 static int nodemgr_hotplug(struct class_device
*cdev
, char **envp
, int num_envp
,
1108 char *buffer
, int buffer_size
)
1113 #endif /* CONFIG_HOTPLUG */
1116 int hpsb_register_protocol(struct hpsb_protocol_driver
*driver
)
1120 /* This will cause a probe for devices */
1121 ret
= driver_register(&driver
->driver
);
1123 nodemgr_create_drv_files(driver
);
1128 void hpsb_unregister_protocol(struct hpsb_protocol_driver
*driver
)
1130 nodemgr_remove_drv_files(driver
);
1131 /* This will subsequently disconnect all devices that our driver
1132 * is attached to. */
1133 driver_unregister(&driver
->driver
);
1138 * This function updates nodes that were present on the bus before the
1139 * reset and still are after the reset. The nodeid and the config rom
1140 * may have changed, and the drivers managing this device must be
1141 * informed that this device just went through a bus reset, to allow
1142 * the to take whatever actions required.
1144 static void nodemgr_update_node(struct node_entry
*ne
, struct csr1212_csr
*csr
,
1145 struct host_info
*hi
, nodeid_t nodeid
,
1146 unsigned int generation
)
1148 if (ne
->nodeid
!= nodeid
) {
1149 HPSB_DEBUG("Node changed: " NODE_BUS_FMT
" -> " NODE_BUS_FMT
,
1150 NODE_BUS_ARGS(ne
->host
, ne
->nodeid
),
1151 NODE_BUS_ARGS(ne
->host
, nodeid
));
1152 ne
->nodeid
= nodeid
;
1155 if (ne
->busopt
.generation
!= ((be32_to_cpu(csr
->bus_info_data
[2]) >> 4) & 0xf)) {
1156 kfree(ne
->csr
->private);
1157 csr1212_destroy_csr(ne
->csr
);
1160 /* If the node's configrom generation has changed, we
1161 * unregister all the unit directories. */
1162 nodemgr_remove_uds(ne
);
1164 nodemgr_update_bus_options(ne
);
1166 /* Mark the node as new, so it gets re-probed */
1167 ne
->needs_probe
= 1;
1169 /* old cache is valid, so update its generation */
1170 struct nodemgr_csr_info
*ci
= ne
->csr
->private;
1171 ci
->generation
= generation
;
1172 /* free the partially filled now unneeded new cache */
1173 kfree(csr
->private);
1174 csr1212_destroy_csr(csr
);
1178 nodemgr_resume_ne(ne
);
1180 /* Mark the node current */
1181 ne
->generation
= generation
;
1186 static void nodemgr_node_scan_one(struct host_info
*hi
,
1187 nodeid_t nodeid
, int generation
)
1189 struct hpsb_host
*host
= hi
->host
;
1190 struct node_entry
*ne
;
1192 struct csr1212_csr
*csr
;
1193 struct nodemgr_csr_info
*ci
;
1195 ci
= kmalloc(sizeof(struct nodemgr_csr_info
), GFP_KERNEL
);
1200 ci
->nodeid
= nodeid
;
1201 ci
->generation
= generation
;
1203 /* We need to detect when the ConfigROM's generation has changed,
1204 * so we only update the node's info when it needs to be. */
1206 csr
= csr1212_create_csr(&nodemgr_csr_ops
, 5 * sizeof(quadlet_t
), ci
);
1207 if (!csr
|| csr1212_parse_csr(csr
) != CSR1212_SUCCESS
) {
1208 HPSB_ERR("Error parsing configrom for node " NODE_BUS_FMT
,
1209 NODE_BUS_ARGS(host
, nodeid
));
1211 csr1212_destroy_csr(csr
);
1216 if (csr
->bus_info_data
[1] != IEEE1394_BUSID_MAGIC
) {
1217 /* This isn't a 1394 device, but we let it slide. There
1218 * was a report of a device with broken firmware which
1219 * reported '2394' instead of '1394', which is obviously a
1220 * mistake. One would hope that a non-1394 device never
1221 * gets connected to Firewire bus. If someone does, we
1222 * shouldn't be held responsible, so we'll allow it with a
1224 HPSB_WARN("Node " NODE_BUS_FMT
" has invalid busID magic [0x%08x]",
1225 NODE_BUS_ARGS(host
, nodeid
), csr
->bus_info_data
[1]);
1228 guid
= ((u64
)be32_to_cpu(csr
->bus_info_data
[3]) << 32) | be32_to_cpu(csr
->bus_info_data
[4]);
1229 ne
= find_entry_by_guid(guid
);
1231 if (ne
&& ne
->host
!= host
&& ne
->in_limbo
) {
1232 /* Must have moved this device from one host to another */
1233 nodemgr_remove_ne(ne
);
1238 nodemgr_create_node(guid
, csr
, hi
, nodeid
, generation
);
1240 nodemgr_update_node(ne
, csr
, hi
, nodeid
, generation
);
1246 static void nodemgr_node_scan(struct host_info
*hi
, int generation
)
1249 struct hpsb_host
*host
= hi
->host
;
1250 struct selfid
*sid
= (struct selfid
*)host
->topology_map
;
1251 nodeid_t nodeid
= LOCAL_BUS
;
1253 /* Scan each node on the bus */
1254 for (count
= host
->selfid_count
; count
; count
--, sid
++) {
1258 if (!sid
->link_active
) {
1262 nodemgr_node_scan_one(hi
, nodeid
++, generation
);
1267 static void nodemgr_suspend_ne(struct node_entry
*ne
)
1269 struct class_device
*cdev
;
1270 struct unit_directory
*ud
;
1272 HPSB_DEBUG("Node suspended: ID:BUS[" NODE_BUS_FMT
"] GUID[%016Lx]",
1273 NODE_BUS_ARGS(ne
->host
, ne
->nodeid
), (unsigned long long)ne
->guid
);
1276 device_create_file(&ne
->device
, &dev_attr_ne_in_limbo
);
1278 down_write(&ne
->device
.bus
->subsys
.rwsem
);
1279 list_for_each_entry(cdev
, &nodemgr_ud_class
.children
, node
) {
1280 ud
= container_of(cdev
, struct unit_directory
, class_dev
);
1285 if (ud
->device
.driver
&&
1286 (!ud
->device
.driver
->suspend
||
1287 ud
->device
.driver
->suspend(&ud
->device
, PMSG_SUSPEND
, 0)))
1288 device_release_driver(&ud
->device
);
1290 up_write(&ne
->device
.bus
->subsys
.rwsem
);
1294 static void nodemgr_resume_ne(struct node_entry
*ne
)
1296 struct class_device
*cdev
;
1297 struct unit_directory
*ud
;
1300 device_remove_file(&ne
->device
, &dev_attr_ne_in_limbo
);
1302 down_read(&ne
->device
.bus
->subsys
.rwsem
);
1303 list_for_each_entry(cdev
, &nodemgr_ud_class
.children
, node
) {
1304 ud
= container_of(cdev
, struct unit_directory
, class_dev
);
1309 if (ud
->device
.driver
&& ud
->device
.driver
->resume
)
1310 ud
->device
.driver
->resume(&ud
->device
, 0);
1312 up_read(&ne
->device
.bus
->subsys
.rwsem
);
1314 HPSB_DEBUG("Node resumed: ID:BUS[" NODE_BUS_FMT
"] GUID[%016Lx]",
1315 NODE_BUS_ARGS(ne
->host
, ne
->nodeid
), (unsigned long long)ne
->guid
);
1319 static void nodemgr_update_pdrv(struct node_entry
*ne
)
1321 struct unit_directory
*ud
;
1322 struct hpsb_protocol_driver
*pdrv
;
1323 struct class *class = &nodemgr_ud_class
;
1324 struct class_device
*cdev
;
1326 down_read(&class->subsys
.rwsem
);
1327 list_for_each_entry(cdev
, &class->children
, node
) {
1328 ud
= container_of(cdev
, struct unit_directory
, class_dev
);
1329 if (ud
->ne
!= ne
|| !ud
->device
.driver
)
1332 pdrv
= container_of(ud
->device
.driver
, struct hpsb_protocol_driver
, driver
);
1334 if (pdrv
->update
&& pdrv
->update(ud
)) {
1335 down_write(&ud
->device
.bus
->subsys
.rwsem
);
1336 device_release_driver(&ud
->device
);
1337 up_write(&ud
->device
.bus
->subsys
.rwsem
);
1340 up_read(&class->subsys
.rwsem
);
1344 static void nodemgr_probe_ne(struct host_info
*hi
, struct node_entry
*ne
, int generation
)
1348 if (ne
->host
!= hi
->host
|| ne
->in_limbo
)
1351 dev
= get_device(&ne
->device
);
1355 /* If "needs_probe", then this is either a new or changed node we
1356 * rescan totally. If the generation matches for an existing node
1357 * (one that existed prior to the bus reset) we send update calls
1358 * down to the drivers. Otherwise, this is a dead node and we
1360 if (ne
->needs_probe
)
1361 nodemgr_process_root_directory(hi
, ne
);
1362 else if (ne
->generation
== generation
)
1363 nodemgr_update_pdrv(ne
);
1365 nodemgr_suspend_ne(ne
);
1371 static void nodemgr_node_probe(struct host_info
*hi
, int generation
)
1373 struct hpsb_host
*host
= hi
->host
;
1374 struct class *class = &nodemgr_ne_class
;
1375 struct class_device
*cdev
;
1377 /* Do some processing of the nodes we've probed. This pulls them
1378 * into the sysfs layer if needed, and can result in processing of
1379 * unit-directories, or just updating the node and it's
1380 * unit-directories. */
1381 down_read(&class->subsys
.rwsem
);
1382 list_for_each_entry(cdev
, &class->children
, node
)
1383 nodemgr_probe_ne(hi
, container_of(cdev
, struct node_entry
, class_dev
), generation
);
1384 up_read(&class->subsys
.rwsem
);
1387 /* If we had a bus reset while we were scanning the bus, it is
1388 * possible that we did not probe all nodes. In that case, we
1389 * skip the clean up for now, since we could remove nodes that
1390 * were still on the bus. The bus reset increased hi->reset_sem,
1391 * so there's a bus scan pending which will do the clean up
1394 * Now let's tell the bus to rescan our devices. This may seem
1395 * like overhead, but the driver-model core will only scan a
1396 * device for a driver when either the device is added, or when a
1397 * new driver is added. A bus reset is a good reason to rescan
1398 * devices that were there before. For example, an sbp2 device
1399 * may become available for login, if the host that held it was
1402 if (generation
== get_hpsb_generation(host
))
1403 bus_rescan_devices(&ieee1394_bus_type
);
1408 /* Because we are a 1394a-2000 compliant IRM, we need to inform all the other
1409 * nodes of the broadcast channel. (Really we're only setting the validity
1410 * bit). Other IRM responsibilities go in here as well. */
1411 static int nodemgr_do_irm_duties(struct hpsb_host
*host
, int cycles
)
1415 /* if irm_id == -1 then there is no IRM on this bus */
1416 if (!host
->is_irm
|| host
->irm_id
== (nodeid_t
)-1)
1419 host
->csr
.broadcast_channel
|= 0x40000000; /* set validity bit */
1421 bc
= cpu_to_be32(host
->csr
.broadcast_channel
);
1423 hpsb_write(host
, LOCAL_BUS
| ALL_NODES
, get_hpsb_generation(host
),
1424 (CSR_REGISTER_BASE
| CSR_BROADCAST_CHANNEL
),
1425 &bc
, sizeof(quadlet_t
));
1427 /* If there is no bus manager then we should set the root node's
1428 * force_root bit to promote bus stability per the 1394
1429 * spec. (8.4.2.6) */
1430 if (host
->busmgr_id
== 0xffff && host
->node_count
> 1)
1432 u16 root_node
= host
->node_count
- 1;
1433 struct node_entry
*ne
= find_entry_by_nodeid(host
, root_node
| LOCAL_BUS
);
1435 if (ne
&& ne
->busopt
.cmc
)
1436 hpsb_send_phy_config(host
, root_node
, -1);
1438 HPSB_DEBUG("The root node is not cycle master capable; "
1439 "selecting a new root node and resetting...");
1442 /* Oh screw it! Just leave the bus as it is */
1443 HPSB_DEBUG("Stopping reset loop for IRM sanity");
1447 hpsb_send_phy_config(host
, NODEID_TO_NODE(host
->node_id
), -1);
1448 hpsb_reset_bus(host
, LONG_RESET_FORCE_ROOT
);
1457 /* We need to ensure that if we are not the IRM, that the IRM node is capable of
1458 * everything we can do, otherwise issue a bus reset and try to become the IRM
1460 static int nodemgr_check_irm_capability(struct hpsb_host
*host
, int cycles
)
1465 if (hpsb_disable_irm
|| host
->is_irm
)
1468 status
= hpsb_read(host
, LOCAL_BUS
| (host
->irm_id
),
1469 get_hpsb_generation(host
),
1470 (CSR_REGISTER_BASE
| CSR_BROADCAST_CHANNEL
),
1471 &bc
, sizeof(quadlet_t
));
1473 if (status
< 0 || !(be32_to_cpu(bc
) & 0x80000000)) {
1474 /* The current irm node does not have a valid BROADCAST_CHANNEL
1475 * register and we do, so reset the bus with force_root set */
1476 HPSB_DEBUG("Current remote IRM is not 1394a-2000 compliant, resetting...");
1479 /* Oh screw it! Just leave the bus as it is */
1480 HPSB_DEBUG("Stopping reset loop for IRM sanity");
1484 hpsb_send_phy_config(host
, NODEID_TO_NODE(host
->node_id
), -1);
1485 hpsb_reset_bus(host
, LONG_RESET_FORCE_ROOT
);
1493 static int nodemgr_host_thread(void *__hi
)
1495 struct host_info
*hi
= (struct host_info
*)__hi
;
1496 struct hpsb_host
*host
= hi
->host
;
1497 int reset_cycles
= 0;
1499 /* No userlevel access needed */
1500 daemonize(hi
->daemon_name
);
1502 /* Setup our device-model entries */
1503 nodemgr_create_host_dev_files(host
);
1505 /* Sit and wait for a signal to probe the nodes on the bus. This
1506 * happens when we get a bus reset. */
1508 unsigned int generation
= 0;
1511 if (down_interruptible(&hi
->reset_sem
) ||
1512 down_interruptible(&nodemgr_serialize
)) {
1513 if (try_to_freeze(PF_FREEZE
))
1515 printk("NodeMgr: received unexpected signal?!\n" );
1520 up(&nodemgr_serialize
);
1524 /* Pause for 1/4 second in 1/16 second intervals,
1525 * to make sure things settle down. */
1526 for (i
= 0; i
< 4 ; i
++) {
1527 set_current_state(TASK_INTERRUPTIBLE
);
1528 if (msleep_interruptible(63)) {
1529 up(&nodemgr_serialize
);
1533 /* Now get the generation in which the node ID's we collect
1534 * are valid. During the bus scan we will use this generation
1535 * for the read transactions, so that if another reset occurs
1536 * during the scan the transactions will fail instead of
1537 * returning bogus data. */
1538 generation
= get_hpsb_generation(host
);
1540 /* If we get a reset before we are done waiting, then
1541 * start the the waiting over again */
1542 while (!down_trylock(&hi
->reset_sem
))
1545 /* Check the kill_me again */
1547 up(&nodemgr_serialize
);
1552 if (!nodemgr_check_irm_capability(host
, reset_cycles
)) {
1554 up(&nodemgr_serialize
);
1558 /* Scan our nodes to get the bus options and create node
1559 * entries. This does not do the sysfs stuff, since that
1560 * would trigger hotplug callbacks and such, which is a
1561 * bad idea at this point. */
1562 nodemgr_node_scan(hi
, generation
);
1563 if (!nodemgr_do_irm_duties(host
, reset_cycles
)) {
1565 up(&nodemgr_serialize
);
1571 /* This actually does the full probe, with sysfs
1573 nodemgr_node_probe(hi
, generation
);
1575 /* Update some of our sysfs symlinks */
1576 nodemgr_update_host_dev_links(host
);
1578 up(&nodemgr_serialize
);
1582 HPSB_VERBOSE("NodeMgr: Exiting thread");
1584 complete_and_exit(&hi
->exited
, 0);
1587 int nodemgr_for_each_host(void *__data
, int (*cb
)(struct hpsb_host
*, void *))
1589 struct class *class = &hpsb_host_class
;
1590 struct class_device
*cdev
;
1591 struct hpsb_host
*host
;
1594 down_read(&class->subsys
.rwsem
);
1595 list_for_each_entry(cdev
, &class->children
, node
) {
1596 host
= container_of(cdev
, struct hpsb_host
, class_dev
);
1598 if ((error
= cb(host
, __data
)))
1601 up_read(&class->subsys
.rwsem
);
1606 /* The following four convenience functions use a struct node_entry
1607 * for addressing a node on the bus. They are intended for use by any
1608 * process context, not just the nodemgr thread, so we need to be a
1609 * little careful when reading out the node ID and generation. The
1610 * thing that can go wrong is that we get the node ID, then a bus
1611 * reset occurs, and then we read the generation. The node ID is
1612 * possibly invalid, but the generation is current, and we end up
1613 * sending a packet to a the wrong node.
1615 * The solution is to make sure we read the generation first, so that
1616 * if a reset occurs in the process, we end up with a stale generation
1617 * and the transactions will fail instead of silently using wrong node
1621 void hpsb_node_fill_packet(struct node_entry
*ne
, struct hpsb_packet
*pkt
)
1623 pkt
->host
= ne
->host
;
1624 pkt
->generation
= ne
->generation
;
1626 pkt
->node_id
= ne
->nodeid
;
1629 int hpsb_node_write(struct node_entry
*ne
, u64 addr
,
1630 quadlet_t
*buffer
, size_t length
)
1632 unsigned int generation
= ne
->generation
;
1635 return hpsb_write(ne
->host
, ne
->nodeid
, generation
,
1636 addr
, buffer
, length
);
1639 static void nodemgr_add_host(struct hpsb_host
*host
)
1641 struct host_info
*hi
;
1643 hi
= hpsb_create_hostinfo(&nodemgr_highlevel
, host
, sizeof(*hi
));
1646 HPSB_ERR ("NodeMgr: out of memory in add host");
1651 init_completion(&hi
->exited
);
1652 sema_init(&hi
->reset_sem
, 0);
1654 sprintf(hi
->daemon_name
, "knodemgrd_%d", host
->id
);
1656 hi
->pid
= kernel_thread(nodemgr_host_thread
, hi
, CLONE_KERNEL
);
1659 HPSB_ERR ("NodeMgr: failed to start %s thread for %s",
1660 hi
->daemon_name
, host
->driver
->name
);
1661 hpsb_destroy_hostinfo(&nodemgr_highlevel
, host
);
1668 static void nodemgr_host_reset(struct hpsb_host
*host
)
1670 struct host_info
*hi
= hpsb_get_hostinfo(&nodemgr_highlevel
, host
);
1673 HPSB_VERBOSE("NodeMgr: Processing host reset for %s", hi
->daemon_name
);
1676 HPSB_ERR ("NodeMgr: could not process reset of unused host");
1681 static void nodemgr_remove_host(struct hpsb_host
*host
)
1683 struct host_info
*hi
= hpsb_get_hostinfo(&nodemgr_highlevel
, host
);
1690 wait_for_completion(&hi
->exited
);
1691 nodemgr_remove_host_dev(&host
->device
);
1694 HPSB_ERR("NodeMgr: host %s does not exist, cannot remove",
1695 host
->driver
->name
);
1700 static struct hpsb_highlevel nodemgr_highlevel
= {
1701 .name
= "Node manager",
1702 .add_host
= nodemgr_add_host
,
1703 .host_reset
= nodemgr_host_reset
,
1704 .remove_host
= nodemgr_remove_host
,
1707 int init_ieee1394_nodemgr(void)
1711 ret
= class_register(&nodemgr_ne_class
);
1715 ret
= class_register(&nodemgr_ud_class
);
1717 class_unregister(&nodemgr_ne_class
);
1721 hpsb_register_highlevel(&nodemgr_highlevel
);
1726 void cleanup_ieee1394_nodemgr(void)
1728 hpsb_unregister_highlevel(&nodemgr_highlevel
);
1730 class_unregister(&nodemgr_ud_class
);
1731 class_unregister(&nodemgr_ne_class
);