2005-04-16 18:20:36 -04:00
|
|
|
/*
|
|
|
|
* Node information (ConfigROM) collection and management.
|
|
|
|
*
|
|
|
|
* Copyright (C) 2000 Andreas E. Bombe
|
|
|
|
* 2001-2003 Ben Collins <bcollins@debian.net>
|
|
|
|
*
|
|
|
|
* This code is licensed under the GPL. See the file COPYING in the root
|
|
|
|
* directory of the kernel sources for details.
|
|
|
|
*/
|
|
|
|
|
2006-06-25 08:46:44 -04:00
|
|
|
#include <linux/bitmap.h>
|
2005-04-16 18:20:36 -04:00
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/list.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/delay.h>
|
2006-07-03 12:02:35 -04:00
|
|
|
#include <linux/kthread.h>
|
2006-11-22 15:09:42 -05:00
|
|
|
#include <linux/module.h>
|
2005-04-16 18:20:36 -04:00
|
|
|
#include <linux/moduleparam.h>
|
2007-04-09 20:39:07 -04:00
|
|
|
#include <linux/mutex.h>
|
2006-12-06 23:34:23 -05:00
|
|
|
#include <linux/freezer.h>
|
2005-04-16 18:20:36 -04:00
|
|
|
#include <asm/atomic.h>
|
2007-06-17 17:47:45 -04:00
|
|
|
#include <asm/semaphore.h>
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2006-07-03 12:02:29 -04:00
|
|
|
#include "csr.h"
|
|
|
|
#include "highlevel.h"
|
|
|
|
#include "hosts.h"
|
2005-04-16 18:20:36 -04:00
|
|
|
#include "ieee1394.h"
|
|
|
|
#include "ieee1394_core.h"
|
2006-07-03 12:02:29 -04:00
|
|
|
#include "ieee1394_hotplug.h"
|
|
|
|
#include "ieee1394_types.h"
|
2005-04-16 18:20:36 -04:00
|
|
|
#include "ieee1394_transactions.h"
|
|
|
|
#include "nodemgr.h"
|
|
|
|
|
2005-07-09 20:01:23 -04:00
|
|
|
static int ignore_drivers;
|
2006-07-03 12:02:35 -04:00
|
|
|
module_param(ignore_drivers, int, S_IRUGO | S_IWUSR);
|
2005-04-16 18:20:36 -04:00
|
|
|
MODULE_PARM_DESC(ignore_drivers, "Disable automatic probing for drivers.");
|
|
|
|
|
|
|
|
struct nodemgr_csr_info {
|
|
|
|
struct hpsb_host *host;
|
|
|
|
nodeid_t nodeid;
|
|
|
|
unsigned int generation;
|
2006-06-12 18:12:37 -04:00
|
|
|
unsigned int speed_unverified:1;
|
2005-04-16 18:20:36 -04:00
|
|
|
};
|
|
|
|
|
|
|
|
|
2006-06-12 18:12:37 -04:00
|
|
|
/*
|
|
|
|
* Correct the speed map entry. This is necessary
|
|
|
|
* - for nodes with link speed < phy speed,
|
|
|
|
* - for 1394b nodes with negotiated phy port speed < IEEE1394_SPEED_MAX.
|
|
|
|
* A possible speed is determined by trial and error, using quadlet reads.
|
|
|
|
*/
|
|
|
|
static int nodemgr_check_speed(struct nodemgr_csr_info *ci, u64 addr,
|
|
|
|
quadlet_t *buffer)
|
|
|
|
{
|
|
|
|
quadlet_t q;
|
|
|
|
u8 i, *speed, old_speed, good_speed;
|
2006-10-20 19:23:56 -04:00
|
|
|
int error;
|
2006-06-12 18:12:37 -04:00
|
|
|
|
2006-07-02 18:58:01 -04:00
|
|
|
speed = &(ci->host->speed[NODEID_TO_NODE(ci->nodeid)]);
|
2006-06-12 18:12:37 -04:00
|
|
|
old_speed = *speed;
|
|
|
|
good_speed = IEEE1394_SPEED_MAX + 1;
|
|
|
|
|
|
|
|
/* Try every speed from S100 to old_speed.
|
|
|
|
* If we did it the other way around, a too low speed could be caught
|
|
|
|
* if the retry succeeded for some other reason, e.g. because the link
|
|
|
|
* just finished its initialization. */
|
|
|
|
for (i = IEEE1394_SPEED_100; i <= old_speed; i++) {
|
|
|
|
*speed = i;
|
2006-10-20 19:23:56 -04:00
|
|
|
error = hpsb_read(ci->host, ci->nodeid, ci->generation, addr,
|
|
|
|
&q, sizeof(quadlet_t));
|
|
|
|
if (error)
|
2006-06-12 18:12:37 -04:00
|
|
|
break;
|
|
|
|
*buffer = q;
|
|
|
|
good_speed = i;
|
|
|
|
}
|
|
|
|
if (good_speed <= IEEE1394_SPEED_MAX) {
|
|
|
|
HPSB_DEBUG("Speed probe of node " NODE_BUS_FMT " yields %s",
|
|
|
|
NODE_BUS_ARGS(ci->host, ci->nodeid),
|
|
|
|
hpsb_speedto_str[good_speed]);
|
|
|
|
*speed = good_speed;
|
|
|
|
ci->speed_unverified = 0;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
*speed = old_speed;
|
2006-10-20 19:23:56 -04:00
|
|
|
return error;
|
2006-06-12 18:12:37 -04:00
|
|
|
}
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
static int nodemgr_bus_read(struct csr1212_csr *csr, u64 addr, u16 length,
|
2006-11-22 15:28:19 -05:00
|
|
|
void *buffer, void *__ci)
|
2005-04-16 18:20:36 -04:00
|
|
|
{
|
|
|
|
struct nodemgr_csr_info *ci = (struct nodemgr_csr_info*)__ci;
|
2006-10-20 19:23:56 -04:00
|
|
|
int i, error;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2005-09-30 14:59:09 -04:00
|
|
|
for (i = 1; ; i++) {
|
2006-10-20 19:23:56 -04:00
|
|
|
error = hpsb_read(ci->host, ci->nodeid, ci->generation, addr,
|
|
|
|
buffer, length);
|
|
|
|
if (!error) {
|
2006-06-12 18:12:37 -04:00
|
|
|
ci->speed_unverified = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/* Give up after 3rd failure. */
|
|
|
|
if (i == 3)
|
2005-04-16 18:20:36 -04:00
|
|
|
break;
|
|
|
|
|
2006-06-12 18:12:37 -04:00
|
|
|
/* The ieee1394_core guessed the node's speed capability from
|
|
|
|
* the self ID. Check whether a lower speed works. */
|
|
|
|
if (ci->speed_unverified && length == sizeof(quadlet_t)) {
|
2006-10-20 19:23:56 -04:00
|
|
|
error = nodemgr_check_speed(ci, addr, buffer);
|
|
|
|
if (!error)
|
2006-06-12 18:12:37 -04:00
|
|
|
break;
|
|
|
|
}
|
2005-04-16 18:20:36 -04:00
|
|
|
if (msleep_interruptible(334))
|
|
|
|
return -EINTR;
|
|
|
|
}
|
2006-10-20 19:23:56 -04:00
|
|
|
return error;
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
static int nodemgr_get_max_rom(quadlet_t *bus_info_data, void *__ci)
|
|
|
|
{
|
2007-03-11 17:49:05 -04:00
|
|
|
return (be32_to_cpu(bus_info_data[2]) >> 8) & 0x3;
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
static struct csr1212_bus_ops nodemgr_csr_ops = {
|
|
|
|
.bus_read = nodemgr_bus_read,
|
|
|
|
.get_max_rom = nodemgr_get_max_rom
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Basically what we do here is start off retrieving the bus_info block.
|
|
|
|
* From there will fill in some info about the node, verify it is of IEEE
|
|
|
|
* 1394 type, and that the crc checks out ok. After that we start off with
|
|
|
|
* the root directory, and subdirectories. To do this, we retrieve the
|
|
|
|
* quadlet header for a directory, find out the length, and retrieve the
|
|
|
|
* complete directory entry (be it a leaf or a directory). We then process
|
|
|
|
* it and add the info to our structure for that particular node.
|
|
|
|
*
|
|
|
|
* We verify CRC's along the way for each directory/block/leaf. The entire
|
|
|
|
* node structure is generic, and simply stores the information in a way
|
|
|
|
* that's easy to parse by the protocol interface.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The nodemgr relies heavily on the Driver Model for device callbacks and
|
|
|
|
* driver/device mappings. The old nodemgr used to handle all this itself,
|
|
|
|
* but now we are much simpler because of the LDM.
|
|
|
|
*/
|
|
|
|
|
|
|
|
struct host_info {
|
|
|
|
struct hpsb_host *host;
|
|
|
|
struct list_head list;
|
2006-07-03 12:02:35 -04:00
|
|
|
struct task_struct *thread;
|
2005-04-16 18:20:36 -04:00
|
|
|
};
|
|
|
|
|
|
|
|
static int nodemgr_bus_match(struct device * dev, struct device_driver * drv);
|
2007-08-14 09:15:12 -04:00
|
|
|
static int nodemgr_uevent(struct device *dev, struct kobj_uevent_env *env);
|
2005-04-16 18:20:36 -04:00
|
|
|
static void nodemgr_resume_ne(struct node_entry *ne);
|
|
|
|
static void nodemgr_remove_ne(struct node_entry *ne);
|
|
|
|
static struct node_entry *find_entry_by_guid(u64 guid);
|
|
|
|
|
|
|
|
struct bus_type ieee1394_bus_type = {
|
|
|
|
.name = "ieee1394",
|
|
|
|
.match = nodemgr_bus_match,
|
|
|
|
};
|
|
|
|
|
2007-05-25 05:50:53 -04:00
|
|
|
static void host_cls_release(struct device *dev)
|
2005-04-16 18:20:36 -04:00
|
|
|
{
|
2007-05-25 05:50:53 -04:00
|
|
|
put_device(&container_of((dev), struct hpsb_host, host_dev)->device);
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
struct class hpsb_host_class = {
|
|
|
|
.name = "ieee1394_host",
|
2007-05-25 05:50:53 -04:00
|
|
|
.dev_release = host_cls_release,
|
2005-04-16 18:20:36 -04:00
|
|
|
};
|
|
|
|
|
2007-05-25 05:50:53 -04:00
|
|
|
static void ne_cls_release(struct device *dev)
|
2005-04-16 18:20:36 -04:00
|
|
|
{
|
2007-05-25 05:50:53 -04:00
|
|
|
put_device(&container_of((dev), struct node_entry, node_dev)->device);
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
static struct class nodemgr_ne_class = {
|
|
|
|
.name = "ieee1394_node",
|
2007-05-25 05:50:53 -04:00
|
|
|
.dev_release = ne_cls_release,
|
2005-04-16 18:20:36 -04:00
|
|
|
};
|
|
|
|
|
2007-05-25 05:50:53 -04:00
|
|
|
static void ud_cls_release(struct device *dev)
|
2005-04-16 18:20:36 -04:00
|
|
|
{
|
2007-05-25 05:50:53 -04:00
|
|
|
put_device(&container_of((dev), struct unit_directory, unit_dev)->device);
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
/* The name here is only so that unit directory hotplug works with old
|
2007-05-25 05:50:53 -04:00
|
|
|
* style hotplug, which only ever did unit directories anyway.
|
|
|
|
*/
|
2005-04-16 18:20:36 -04:00
|
|
|
static struct class nodemgr_ud_class = {
|
|
|
|
.name = "ieee1394",
|
2007-05-25 05:50:53 -04:00
|
|
|
.dev_release = ud_cls_release,
|
|
|
|
.dev_uevent = nodemgr_uevent,
|
2005-04-16 18:20:36 -04:00
|
|
|
};
|
|
|
|
|
|
|
|
static struct hpsb_highlevel nodemgr_highlevel;
|
|
|
|
|
|
|
|
|
|
|
|
static void nodemgr_release_ud(struct device *dev)
|
|
|
|
{
|
|
|
|
struct unit_directory *ud = container_of(dev, struct unit_directory, device);
|
|
|
|
|
|
|
|
if (ud->vendor_name_kv)
|
|
|
|
csr1212_release_keyval(ud->vendor_name_kv);
|
|
|
|
if (ud->model_name_kv)
|
|
|
|
csr1212_release_keyval(ud->model_name_kv);
|
|
|
|
|
|
|
|
kfree(ud);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void nodemgr_release_ne(struct device *dev)
|
|
|
|
{
|
|
|
|
struct node_entry *ne = container_of(dev, struct node_entry, device);
|
|
|
|
|
|
|
|
if (ne->vendor_name_kv)
|
|
|
|
csr1212_release_keyval(ne->vendor_name_kv);
|
|
|
|
|
|
|
|
kfree(ne);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void nodemgr_release_host(struct device *dev)
|
|
|
|
{
|
|
|
|
struct hpsb_host *host = container_of(dev, struct hpsb_host, device);
|
|
|
|
|
|
|
|
csr1212_destroy_csr(host->csr.rom);
|
|
|
|
|
|
|
|
kfree(host);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int nodemgr_ud_platform_data;
|
|
|
|
|
|
|
|
static struct device nodemgr_dev_template_ud = {
|
|
|
|
.bus = &ieee1394_bus_type,
|
|
|
|
.release = nodemgr_release_ud,
|
|
|
|
.platform_data = &nodemgr_ud_platform_data,
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct device nodemgr_dev_template_ne = {
|
|
|
|
.bus = &ieee1394_bus_type,
|
|
|
|
.release = nodemgr_release_ne,
|
|
|
|
};
|
|
|
|
|
2006-11-22 15:09:42 -05:00
|
|
|
/* This dummy driver prevents the host devices from being scanned. We have no
|
|
|
|
* useful drivers for them yet, and there would be a deadlock possible if the
|
|
|
|
* driver core scans the host device while the host's low-level driver (i.e.
|
|
|
|
* the host's parent device) is being removed. */
|
|
|
|
static struct device_driver nodemgr_mid_layer_driver = {
|
|
|
|
.bus = &ieee1394_bus_type,
|
|
|
|
.name = "nodemgr",
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
};
|
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
struct device nodemgr_dev_template_host = {
|
|
|
|
.bus = &ieee1394_bus_type,
|
|
|
|
.release = nodemgr_release_host,
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
#define fw_attr(class, class_type, field, type, format_string) \
|
2005-05-17 06:42:58 -04:00
|
|
|
static ssize_t fw_show_##class##_##field (struct device *dev, struct device_attribute *attr, char *buf)\
|
2005-04-16 18:20:36 -04:00
|
|
|
{ \
|
|
|
|
class_type *class; \
|
|
|
|
class = container_of(dev, class_type, device); \
|
|
|
|
return sprintf(buf, format_string, (type)class->field); \
|
|
|
|
} \
|
|
|
|
static struct device_attribute dev_attr_##class##_##field = { \
|
|
|
|
.attr = {.name = __stringify(field), .mode = S_IRUGO }, \
|
|
|
|
.show = fw_show_##class##_##field, \
|
|
|
|
};
|
|
|
|
|
|
|
|
#define fw_attr_td(class, class_type, td_kv) \
|
2005-05-17 06:42:58 -04:00
|
|
|
static ssize_t fw_show_##class##_##td_kv (struct device *dev, struct device_attribute *attr, char *buf)\
|
2005-04-16 18:20:36 -04:00
|
|
|
{ \
|
|
|
|
int len; \
|
|
|
|
class_type *class = container_of(dev, class_type, device); \
|
|
|
|
len = (class->td_kv->value.leaf.len - 2) * sizeof(quadlet_t); \
|
|
|
|
memcpy(buf, \
|
|
|
|
CSR1212_TEXTUAL_DESCRIPTOR_LEAF_DATA(class->td_kv), \
|
|
|
|
len); \
|
2007-07-15 15:59:51 -04:00
|
|
|
while (buf[len - 1] == '\0') \
|
2005-04-16 18:20:36 -04:00
|
|
|
len--; \
|
|
|
|
buf[len++] = '\n'; \
|
|
|
|
buf[len] = '\0'; \
|
|
|
|
return len; \
|
|
|
|
} \
|
|
|
|
static struct device_attribute dev_attr_##class##_##td_kv = { \
|
|
|
|
.attr = {.name = __stringify(td_kv), .mode = S_IRUGO }, \
|
|
|
|
.show = fw_show_##class##_##td_kv, \
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
#define fw_drv_attr(field, type, format_string) \
|
|
|
|
static ssize_t fw_drv_show_##field (struct device_driver *drv, char *buf) \
|
|
|
|
{ \
|
|
|
|
struct hpsb_protocol_driver *driver; \
|
|
|
|
driver = container_of(drv, struct hpsb_protocol_driver, driver); \
|
|
|
|
return sprintf(buf, format_string, (type)driver->field);\
|
|
|
|
} \
|
|
|
|
static struct driver_attribute driver_attr_drv_##field = { \
|
2006-11-22 15:28:19 -05:00
|
|
|
.attr = {.name = __stringify(field), .mode = S_IRUGO }, \
|
|
|
|
.show = fw_drv_show_##field, \
|
2005-04-16 18:20:36 -04:00
|
|
|
};
|
|
|
|
|
|
|
|
|
2005-05-17 06:42:58 -04:00
|
|
|
static ssize_t fw_show_ne_bus_options(struct device *dev, struct device_attribute *attr, char *buf)
|
2005-04-16 18:20:36 -04:00
|
|
|
{
|
|
|
|
struct node_entry *ne = container_of(dev, struct node_entry, device);
|
|
|
|
|
|
|
|
return sprintf(buf, "IRMC(%d) CMC(%d) ISC(%d) BMC(%d) PMC(%d) GEN(%d) "
|
|
|
|
"LSPD(%d) MAX_REC(%d) MAX_ROM(%d) CYC_CLK_ACC(%d)\n",
|
|
|
|
ne->busopt.irmc,
|
|
|
|
ne->busopt.cmc, ne->busopt.isc, ne->busopt.bmc,
|
|
|
|
ne->busopt.pmc, ne->busopt.generation, ne->busopt.lnkspd,
|
|
|
|
ne->busopt.max_rec,
|
|
|
|
ne->busopt.max_rom,
|
|
|
|
ne->busopt.cyc_clk_acc);
|
|
|
|
}
|
|
|
|
static DEVICE_ATTR(bus_options,S_IRUGO,fw_show_ne_bus_options,NULL);
|
|
|
|
|
|
|
|
|
ieee1394: shrink tlabel pools, remove tpool semaphores
This patch reduces the size of struct hpsb_host and also removes
semaphores from ieee1394_transactions.c. On i386, struct hpsb_host
shrinks from 10656 bytes to 6688 bytes. This is accomplished by
- using a single wait_queue for hpsb_get_tlabel instead of many
instances of semaphores,
- using a single lock to serialize access to all tlabel pools (the
protected code regions are small, i.e. lock contention very low),
- omitting the sysfs attribute tlabels_allocations.
Drawback: In the rare case that a process needs to sleep because all
transaction labels for the node are temporarily exhausted, it is also
woken up if a tlabel for a different node became free, checks for an
available tlabel, and is put to sleep again. The check is not costly
and the situation occurs extremely rarely. (Tlabels are typically
only exhausted if there was no context switch to the khpsbpkt thread
which recycles tlables.) Therefore the benefit of reduced tpool size
outweighs this drawback.
The sysfs attributes tlabels_free and tlabels_mask are not compiled
anymore unless CONFIG_IEEE1394_VERBOSEDEBUG is set.
The by far biggest member of struct hpsb_host, the struct csr_control
csr (5272 bytes on i386), is now placed at the end of struct hpsb_host.
Note, hpsb_get_tlabel calls the macro wait_event_interruptible with a
condition argument which has a side effect (allocation of a tlabel and
manipulation of the packet). This side effect happens only if the
condition is true. The patch relies on wait_event_interruptible not
evaluating the condition again after it became true.
Signed-off-by: Stefan Richter <stefanr@s5r6.in-berlin.de>
2006-07-02 08:17:00 -04:00
|
|
|
#ifdef HPSB_DEBUG_TLABELS
|
|
|
|
static ssize_t fw_show_ne_tlabels_free(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
2005-04-16 18:20:36 -04:00
|
|
|
{
|
|
|
|
struct node_entry *ne = container_of(dev, struct node_entry, device);
|
ieee1394: shrink tlabel pools, remove tpool semaphores
This patch reduces the size of struct hpsb_host and also removes
semaphores from ieee1394_transactions.c. On i386, struct hpsb_host
shrinks from 10656 bytes to 6688 bytes. This is accomplished by
- using a single wait_queue for hpsb_get_tlabel instead of many
instances of semaphores,
- using a single lock to serialize access to all tlabel pools (the
protected code regions are small, i.e. lock contention very low),
- omitting the sysfs attribute tlabels_allocations.
Drawback: In the rare case that a process needs to sleep because all
transaction labels for the node are temporarily exhausted, it is also
woken up if a tlabel for a different node became free, checks for an
available tlabel, and is put to sleep again. The check is not costly
and the situation occurs extremely rarely. (Tlabels are typically
only exhausted if there was no context switch to the khpsbpkt thread
which recycles tlables.) Therefore the benefit of reduced tpool size
outweighs this drawback.
The sysfs attributes tlabels_free and tlabels_mask are not compiled
anymore unless CONFIG_IEEE1394_VERBOSEDEBUG is set.
The by far biggest member of struct hpsb_host, the struct csr_control
csr (5272 bytes on i386), is now placed at the end of struct hpsb_host.
Note, hpsb_get_tlabel calls the macro wait_event_interruptible with a
condition argument which has a side effect (allocation of a tlabel and
manipulation of the packet). This side effect happens only if the
condition is true. The patch relies on wait_event_interruptible not
evaluating the condition again after it became true.
Signed-off-by: Stefan Richter <stefanr@s5r6.in-berlin.de>
2006-07-02 08:17:00 -04:00
|
|
|
unsigned long flags;
|
|
|
|
unsigned long *tp = ne->host->tl_pool[NODEID_TO_NODE(ne->nodeid)].map;
|
|
|
|
int tf;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
ieee1394: shrink tlabel pools, remove tpool semaphores
This patch reduces the size of struct hpsb_host and also removes
semaphores from ieee1394_transactions.c. On i386, struct hpsb_host
shrinks from 10656 bytes to 6688 bytes. This is accomplished by
- using a single wait_queue for hpsb_get_tlabel instead of many
instances of semaphores,
- using a single lock to serialize access to all tlabel pools (the
protected code regions are small, i.e. lock contention very low),
- omitting the sysfs attribute tlabels_allocations.
Drawback: In the rare case that a process needs to sleep because all
transaction labels for the node are temporarily exhausted, it is also
woken up if a tlabel for a different node became free, checks for an
available tlabel, and is put to sleep again. The check is not costly
and the situation occurs extremely rarely. (Tlabels are typically
only exhausted if there was no context switch to the khpsbpkt thread
which recycles tlables.) Therefore the benefit of reduced tpool size
outweighs this drawback.
The sysfs attributes tlabels_free and tlabels_mask are not compiled
anymore unless CONFIG_IEEE1394_VERBOSEDEBUG is set.
The by far biggest member of struct hpsb_host, the struct csr_control
csr (5272 bytes on i386), is now placed at the end of struct hpsb_host.
Note, hpsb_get_tlabel calls the macro wait_event_interruptible with a
condition argument which has a side effect (allocation of a tlabel and
manipulation of the packet). This side effect happens only if the
condition is true. The patch relies on wait_event_interruptible not
evaluating the condition again after it became true.
Signed-off-by: Stefan Richter <stefanr@s5r6.in-berlin.de>
2006-07-02 08:17:00 -04:00
|
|
|
spin_lock_irqsave(&hpsb_tlabel_lock, flags);
|
|
|
|
tf = 64 - bitmap_weight(tp, 64);
|
|
|
|
spin_unlock_irqrestore(&hpsb_tlabel_lock, flags);
|
2005-04-16 18:20:36 -04:00
|
|
|
|
ieee1394: shrink tlabel pools, remove tpool semaphores
This patch reduces the size of struct hpsb_host and also removes
semaphores from ieee1394_transactions.c. On i386, struct hpsb_host
shrinks from 10656 bytes to 6688 bytes. This is accomplished by
- using a single wait_queue for hpsb_get_tlabel instead of many
instances of semaphores,
- using a single lock to serialize access to all tlabel pools (the
protected code regions are small, i.e. lock contention very low),
- omitting the sysfs attribute tlabels_allocations.
Drawback: In the rare case that a process needs to sleep because all
transaction labels for the node are temporarily exhausted, it is also
woken up if a tlabel for a different node became free, checks for an
available tlabel, and is put to sleep again. The check is not costly
and the situation occurs extremely rarely. (Tlabels are typically
only exhausted if there was no context switch to the khpsbpkt thread
which recycles tlables.) Therefore the benefit of reduced tpool size
outweighs this drawback.
The sysfs attributes tlabels_free and tlabels_mask are not compiled
anymore unless CONFIG_IEEE1394_VERBOSEDEBUG is set.
The by far biggest member of struct hpsb_host, the struct csr_control
csr (5272 bytes on i386), is now placed at the end of struct hpsb_host.
Note, hpsb_get_tlabel calls the macro wait_event_interruptible with a
condition argument which has a side effect (allocation of a tlabel and
manipulation of the packet). This side effect happens only if the
condition is true. The patch relies on wait_event_interruptible not
evaluating the condition again after it became true.
Signed-off-by: Stefan Richter <stefanr@s5r6.in-berlin.de>
2006-07-02 08:17:00 -04:00
|
|
|
return sprintf(buf, "%d\n", tf);
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
ieee1394: shrink tlabel pools, remove tpool semaphores
This patch reduces the size of struct hpsb_host and also removes
semaphores from ieee1394_transactions.c. On i386, struct hpsb_host
shrinks from 10656 bytes to 6688 bytes. This is accomplished by
- using a single wait_queue for hpsb_get_tlabel instead of many
instances of semaphores,
- using a single lock to serialize access to all tlabel pools (the
protected code regions are small, i.e. lock contention very low),
- omitting the sysfs attribute tlabels_allocations.
Drawback: In the rare case that a process needs to sleep because all
transaction labels for the node are temporarily exhausted, it is also
woken up if a tlabel for a different node became free, checks for an
available tlabel, and is put to sleep again. The check is not costly
and the situation occurs extremely rarely. (Tlabels are typically
only exhausted if there was no context switch to the khpsbpkt thread
which recycles tlables.) Therefore the benefit of reduced tpool size
outweighs this drawback.
The sysfs attributes tlabels_free and tlabels_mask are not compiled
anymore unless CONFIG_IEEE1394_VERBOSEDEBUG is set.
The by far biggest member of struct hpsb_host, the struct csr_control
csr (5272 bytes on i386), is now placed at the end of struct hpsb_host.
Note, hpsb_get_tlabel calls the macro wait_event_interruptible with a
condition argument which has a side effect (allocation of a tlabel and
manipulation of the packet). This side effect happens only if the
condition is true. The patch relies on wait_event_interruptible not
evaluating the condition again after it became true.
Signed-off-by: Stefan Richter <stefanr@s5r6.in-berlin.de>
2006-07-02 08:17:00 -04:00
|
|
|
static DEVICE_ATTR(tlabels_free,S_IRUGO,fw_show_ne_tlabels_free,NULL);
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
|
ieee1394: shrink tlabel pools, remove tpool semaphores
This patch reduces the size of struct hpsb_host and also removes
semaphores from ieee1394_transactions.c. On i386, struct hpsb_host
shrinks from 10656 bytes to 6688 bytes. This is accomplished by
- using a single wait_queue for hpsb_get_tlabel instead of many
instances of semaphores,
- using a single lock to serialize access to all tlabel pools (the
protected code regions are small, i.e. lock contention very low),
- omitting the sysfs attribute tlabels_allocations.
Drawback: In the rare case that a process needs to sleep because all
transaction labels for the node are temporarily exhausted, it is also
woken up if a tlabel for a different node became free, checks for an
available tlabel, and is put to sleep again. The check is not costly
and the situation occurs extremely rarely. (Tlabels are typically
only exhausted if there was no context switch to the khpsbpkt thread
which recycles tlables.) Therefore the benefit of reduced tpool size
outweighs this drawback.
The sysfs attributes tlabels_free and tlabels_mask are not compiled
anymore unless CONFIG_IEEE1394_VERBOSEDEBUG is set.
The by far biggest member of struct hpsb_host, the struct csr_control
csr (5272 bytes on i386), is now placed at the end of struct hpsb_host.
Note, hpsb_get_tlabel calls the macro wait_event_interruptible with a
condition argument which has a side effect (allocation of a tlabel and
manipulation of the packet). This side effect happens only if the
condition is true. The patch relies on wait_event_interruptible not
evaluating the condition again after it became true.
Signed-off-by: Stefan Richter <stefanr@s5r6.in-berlin.de>
2006-07-02 08:17:00 -04:00
|
|
|
static ssize_t fw_show_ne_tlabels_mask(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
2005-04-16 18:20:36 -04:00
|
|
|
{
|
|
|
|
struct node_entry *ne = container_of(dev, struct node_entry, device);
|
ieee1394: shrink tlabel pools, remove tpool semaphores
This patch reduces the size of struct hpsb_host and also removes
semaphores from ieee1394_transactions.c. On i386, struct hpsb_host
shrinks from 10656 bytes to 6688 bytes. This is accomplished by
- using a single wait_queue for hpsb_get_tlabel instead of many
instances of semaphores,
- using a single lock to serialize access to all tlabel pools (the
protected code regions are small, i.e. lock contention very low),
- omitting the sysfs attribute tlabels_allocations.
Drawback: In the rare case that a process needs to sleep because all
transaction labels for the node are temporarily exhausted, it is also
woken up if a tlabel for a different node became free, checks for an
available tlabel, and is put to sleep again. The check is not costly
and the situation occurs extremely rarely. (Tlabels are typically
only exhausted if there was no context switch to the khpsbpkt thread
which recycles tlables.) Therefore the benefit of reduced tpool size
outweighs this drawback.
The sysfs attributes tlabels_free and tlabels_mask are not compiled
anymore unless CONFIG_IEEE1394_VERBOSEDEBUG is set.
The by far biggest member of struct hpsb_host, the struct csr_control
csr (5272 bytes on i386), is now placed at the end of struct hpsb_host.
Note, hpsb_get_tlabel calls the macro wait_event_interruptible with a
condition argument which has a side effect (allocation of a tlabel and
manipulation of the packet). This side effect happens only if the
condition is true. The patch relies on wait_event_interruptible not
evaluating the condition again after it became true.
Signed-off-by: Stefan Richter <stefanr@s5r6.in-berlin.de>
2006-07-02 08:17:00 -04:00
|
|
|
unsigned long flags;
|
|
|
|
unsigned long *tp = ne->host->tl_pool[NODEID_TO_NODE(ne->nodeid)].map;
|
|
|
|
u64 tm;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&hpsb_tlabel_lock, flags);
|
2005-04-16 18:20:36 -04:00
|
|
|
#if (BITS_PER_LONG <= 32)
|
ieee1394: shrink tlabel pools, remove tpool semaphores
This patch reduces the size of struct hpsb_host and also removes
semaphores from ieee1394_transactions.c. On i386, struct hpsb_host
shrinks from 10656 bytes to 6688 bytes. This is accomplished by
- using a single wait_queue for hpsb_get_tlabel instead of many
instances of semaphores,
- using a single lock to serialize access to all tlabel pools (the
protected code regions are small, i.e. lock contention very low),
- omitting the sysfs attribute tlabels_allocations.
Drawback: In the rare case that a process needs to sleep because all
transaction labels for the node are temporarily exhausted, it is also
woken up if a tlabel for a different node became free, checks for an
available tlabel, and is put to sleep again. The check is not costly
and the situation occurs extremely rarely. (Tlabels are typically
only exhausted if there was no context switch to the khpsbpkt thread
which recycles tlables.) Therefore the benefit of reduced tpool size
outweighs this drawback.
The sysfs attributes tlabels_free and tlabels_mask are not compiled
anymore unless CONFIG_IEEE1394_VERBOSEDEBUG is set.
The by far biggest member of struct hpsb_host, the struct csr_control
csr (5272 bytes on i386), is now placed at the end of struct hpsb_host.
Note, hpsb_get_tlabel calls the macro wait_event_interruptible with a
condition argument which has a side effect (allocation of a tlabel and
manipulation of the packet). This side effect happens only if the
condition is true. The patch relies on wait_event_interruptible not
evaluating the condition again after it became true.
Signed-off-by: Stefan Richter <stefanr@s5r6.in-berlin.de>
2006-07-02 08:17:00 -04:00
|
|
|
tm = ((u64)tp[0] << 32) + tp[1];
|
2005-04-16 18:20:36 -04:00
|
|
|
#else
|
ieee1394: shrink tlabel pools, remove tpool semaphores
This patch reduces the size of struct hpsb_host and also removes
semaphores from ieee1394_transactions.c. On i386, struct hpsb_host
shrinks from 10656 bytes to 6688 bytes. This is accomplished by
- using a single wait_queue for hpsb_get_tlabel instead of many
instances of semaphores,
- using a single lock to serialize access to all tlabel pools (the
protected code regions are small, i.e. lock contention very low),
- omitting the sysfs attribute tlabels_allocations.
Drawback: In the rare case that a process needs to sleep because all
transaction labels for the node are temporarily exhausted, it is also
woken up if a tlabel for a different node became free, checks for an
available tlabel, and is put to sleep again. The check is not costly
and the situation occurs extremely rarely. (Tlabels are typically
only exhausted if there was no context switch to the khpsbpkt thread
which recycles tlables.) Therefore the benefit of reduced tpool size
outweighs this drawback.
The sysfs attributes tlabels_free and tlabels_mask are not compiled
anymore unless CONFIG_IEEE1394_VERBOSEDEBUG is set.
The by far biggest member of struct hpsb_host, the struct csr_control
csr (5272 bytes on i386), is now placed at the end of struct hpsb_host.
Note, hpsb_get_tlabel calls the macro wait_event_interruptible with a
condition argument which has a side effect (allocation of a tlabel and
manipulation of the packet). This side effect happens only if the
condition is true. The patch relies on wait_event_interruptible not
evaluating the condition again after it became true.
Signed-off-by: Stefan Richter <stefanr@s5r6.in-berlin.de>
2006-07-02 08:17:00 -04:00
|
|
|
tm = tp[0];
|
2005-04-16 18:20:36 -04:00
|
|
|
#endif
|
ieee1394: shrink tlabel pools, remove tpool semaphores
This patch reduces the size of struct hpsb_host and also removes
semaphores from ieee1394_transactions.c. On i386, struct hpsb_host
shrinks from 10656 bytes to 6688 bytes. This is accomplished by
- using a single wait_queue for hpsb_get_tlabel instead of many
instances of semaphores,
- using a single lock to serialize access to all tlabel pools (the
protected code regions are small, i.e. lock contention very low),
- omitting the sysfs attribute tlabels_allocations.
Drawback: In the rare case that a process needs to sleep because all
transaction labels for the node are temporarily exhausted, it is also
woken up if a tlabel for a different node became free, checks for an
available tlabel, and is put to sleep again. The check is not costly
and the situation occurs extremely rarely. (Tlabels are typically
only exhausted if there was no context switch to the khpsbpkt thread
which recycles tlables.) Therefore the benefit of reduced tpool size
outweighs this drawback.
The sysfs attributes tlabels_free and tlabels_mask are not compiled
anymore unless CONFIG_IEEE1394_VERBOSEDEBUG is set.
The by far biggest member of struct hpsb_host, the struct csr_control
csr (5272 bytes on i386), is now placed at the end of struct hpsb_host.
Note, hpsb_get_tlabel calls the macro wait_event_interruptible with a
condition argument which has a side effect (allocation of a tlabel and
manipulation of the packet). This side effect happens only if the
condition is true. The patch relies on wait_event_interruptible not
evaluating the condition again after it became true.
Signed-off-by: Stefan Richter <stefanr@s5r6.in-berlin.de>
2006-07-02 08:17:00 -04:00
|
|
|
spin_unlock_irqrestore(&hpsb_tlabel_lock, flags);
|
|
|
|
|
2006-10-24 00:44:36 -04:00
|
|
|
return sprintf(buf, "0x%016llx\n", (unsigned long long)tm);
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
static DEVICE_ATTR(tlabels_mask, S_IRUGO, fw_show_ne_tlabels_mask, NULL);
|
ieee1394: shrink tlabel pools, remove tpool semaphores
This patch reduces the size of struct hpsb_host and also removes
semaphores from ieee1394_transactions.c. On i386, struct hpsb_host
shrinks from 10656 bytes to 6688 bytes. This is accomplished by
- using a single wait_queue for hpsb_get_tlabel instead of many
instances of semaphores,
- using a single lock to serialize access to all tlabel pools (the
protected code regions are small, i.e. lock contention very low),
- omitting the sysfs attribute tlabels_allocations.
Drawback: In the rare case that a process needs to sleep because all
transaction labels for the node are temporarily exhausted, it is also
woken up if a tlabel for a different node became free, checks for an
available tlabel, and is put to sleep again. The check is not costly
and the situation occurs extremely rarely. (Tlabels are typically
only exhausted if there was no context switch to the khpsbpkt thread
which recycles tlables.) Therefore the benefit of reduced tpool size
outweighs this drawback.
The sysfs attributes tlabels_free and tlabels_mask are not compiled
anymore unless CONFIG_IEEE1394_VERBOSEDEBUG is set.
The by far biggest member of struct hpsb_host, the struct csr_control
csr (5272 bytes on i386), is now placed at the end of struct hpsb_host.
Note, hpsb_get_tlabel calls the macro wait_event_interruptible with a
condition argument which has a side effect (allocation of a tlabel and
manipulation of the packet). This side effect happens only if the
condition is true. The patch relies on wait_event_interruptible not
evaluating the condition again after it became true.
Signed-off-by: Stefan Richter <stefanr@s5r6.in-berlin.de>
2006-07-02 08:17:00 -04:00
|
|
|
#endif /* HPSB_DEBUG_TLABELS */
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
|
2005-05-17 06:42:58 -04:00
|
|
|
static ssize_t fw_set_ignore_driver(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
|
2005-04-16 18:20:36 -04:00
|
|
|
{
|
|
|
|
struct unit_directory *ud = container_of(dev, struct unit_directory, device);
|
|
|
|
int state = simple_strtoul(buf, NULL, 10);
|
|
|
|
|
|
|
|
if (state == 1) {
|
|
|
|
ud->ignore_driver = 1;
|
2006-10-22 10:16:27 -04:00
|
|
|
device_release_driver(dev);
|
|
|
|
} else if (state == 0)
|
2005-04-16 18:20:36 -04:00
|
|
|
ud->ignore_driver = 0;
|
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
2005-05-17 06:42:58 -04:00
|
|
|
static ssize_t fw_get_ignore_driver(struct device *dev, struct device_attribute *attr, char *buf)
|
2005-04-16 18:20:36 -04:00
|
|
|
{
|
|
|
|
struct unit_directory *ud = container_of(dev, struct unit_directory, device);
|
|
|
|
|
|
|
|
return sprintf(buf, "%d\n", ud->ignore_driver);
|
|
|
|
}
|
|
|
|
static DEVICE_ATTR(ignore_driver, S_IWUSR | S_IRUGO, fw_get_ignore_driver, fw_set_ignore_driver);
|
|
|
|
|
|
|
|
|
|
|
|
static ssize_t fw_set_destroy_node(struct bus_type *bus, const char *buf, size_t count)
|
|
|
|
{
|
|
|
|
struct node_entry *ne;
|
|
|
|
u64 guid = (u64)simple_strtoull(buf, NULL, 16);
|
|
|
|
|
|
|
|
ne = find_entry_by_guid(guid);
|
|
|
|
|
|
|
|
if (ne == NULL || !ne->in_limbo)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
nodemgr_remove_ne(ne);
|
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
static ssize_t fw_get_destroy_node(struct bus_type *bus, char *buf)
|
|
|
|
{
|
|
|
|
return sprintf(buf, "You can destroy in_limbo nodes by writing their GUID to this file\n");
|
|
|
|
}
|
|
|
|
static BUS_ATTR(destroy_node, S_IWUSR | S_IRUGO, fw_get_destroy_node, fw_set_destroy_node);
|
|
|
|
|
|
|
|
|
2006-10-10 15:19:21 -04:00
|
|
|
static ssize_t fw_set_rescan(struct bus_type *bus, const char *buf,
|
|
|
|
size_t count)
|
2005-04-16 18:20:36 -04:00
|
|
|
{
|
2006-10-10 15:19:21 -04:00
|
|
|
int error = 0;
|
|
|
|
|
2006-07-03 12:02:34 -04:00
|
|
|
if (simple_strtoul(buf, NULL, 10) == 1)
|
2006-10-10 15:19:21 -04:00
|
|
|
error = bus_rescan_devices(&ieee1394_bus_type);
|
|
|
|
return error ? error : count;
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
static ssize_t fw_get_rescan(struct bus_type *bus, char *buf)
|
|
|
|
{
|
|
|
|
return sprintf(buf, "You can force a rescan of the bus for "
|
|
|
|
"drivers by writing a 1 to this file\n");
|
|
|
|
}
|
|
|
|
static BUS_ATTR(rescan, S_IWUSR | S_IRUGO, fw_get_rescan, fw_set_rescan);
|
|
|
|
|
|
|
|
|
|
|
|
static ssize_t fw_set_ignore_drivers(struct bus_type *bus, const char *buf, size_t count)
|
|
|
|
{
|
|
|
|
int state = simple_strtoul(buf, NULL, 10);
|
|
|
|
|
|
|
|
if (state == 1)
|
|
|
|
ignore_drivers = 1;
|
2006-10-22 10:16:27 -04:00
|
|
|
else if (state == 0)
|
2005-04-16 18:20:36 -04:00
|
|
|
ignore_drivers = 0;
|
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
static ssize_t fw_get_ignore_drivers(struct bus_type *bus, char *buf)
|
|
|
|
{
|
|
|
|
return sprintf(buf, "%d\n", ignore_drivers);
|
|
|
|
}
|
|
|
|
static BUS_ATTR(ignore_drivers, S_IWUSR | S_IRUGO, fw_get_ignore_drivers, fw_set_ignore_drivers);
|
|
|
|
|
|
|
|
|
|
|
|
struct bus_attribute *const fw_bus_attrs[] = {
|
|
|
|
&bus_attr_destroy_node,
|
|
|
|
&bus_attr_rescan,
|
|
|
|
&bus_attr_ignore_drivers,
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
fw_attr(ne, struct node_entry, capabilities, unsigned int, "0x%06x\n")
|
|
|
|
fw_attr(ne, struct node_entry, nodeid, unsigned int, "0x%04x\n")
|
|
|
|
|
|
|
|
fw_attr(ne, struct node_entry, vendor_id, unsigned int, "0x%06x\n")
|
|
|
|
fw_attr_td(ne, struct node_entry, vendor_name_kv)
|
|
|
|
|
|
|
|
fw_attr(ne, struct node_entry, guid, unsigned long long, "0x%016Lx\n")
|
|
|
|
fw_attr(ne, struct node_entry, guid_vendor_id, unsigned int, "0x%06x\n")
|
|
|
|
fw_attr(ne, struct node_entry, in_limbo, int, "%d\n");
|
|
|
|
|
|
|
|
static struct device_attribute *const fw_ne_attrs[] = {
|
|
|
|
&dev_attr_ne_guid,
|
|
|
|
&dev_attr_ne_guid_vendor_id,
|
|
|
|
&dev_attr_ne_capabilities,
|
|
|
|
&dev_attr_ne_vendor_id,
|
|
|
|
&dev_attr_ne_nodeid,
|
|
|
|
&dev_attr_bus_options,
|
ieee1394: shrink tlabel pools, remove tpool semaphores
This patch reduces the size of struct hpsb_host and also removes
semaphores from ieee1394_transactions.c. On i386, struct hpsb_host
shrinks from 10656 bytes to 6688 bytes. This is accomplished by
- using a single wait_queue for hpsb_get_tlabel instead of many
instances of semaphores,
- using a single lock to serialize access to all tlabel pools (the
protected code regions are small, i.e. lock contention very low),
- omitting the sysfs attribute tlabels_allocations.
Drawback: In the rare case that a process needs to sleep because all
transaction labels for the node are temporarily exhausted, it is also
woken up if a tlabel for a different node became free, checks for an
available tlabel, and is put to sleep again. The check is not costly
and the situation occurs extremely rarely. (Tlabels are typically
only exhausted if there was no context switch to the khpsbpkt thread
which recycles tlables.) Therefore the benefit of reduced tpool size
outweighs this drawback.
The sysfs attributes tlabels_free and tlabels_mask are not compiled
anymore unless CONFIG_IEEE1394_VERBOSEDEBUG is set.
The by far biggest member of struct hpsb_host, the struct csr_control
csr (5272 bytes on i386), is now placed at the end of struct hpsb_host.
Note, hpsb_get_tlabel calls the macro wait_event_interruptible with a
condition argument which has a side effect (allocation of a tlabel and
manipulation of the packet). This side effect happens only if the
condition is true. The patch relies on wait_event_interruptible not
evaluating the condition again after it became true.
Signed-off-by: Stefan Richter <stefanr@s5r6.in-berlin.de>
2006-07-02 08:17:00 -04:00
|
|
|
#ifdef HPSB_DEBUG_TLABELS
|
2005-04-16 18:20:36 -04:00
|
|
|
&dev_attr_tlabels_free,
|
|
|
|
&dev_attr_tlabels_mask,
|
ieee1394: shrink tlabel pools, remove tpool semaphores
This patch reduces the size of struct hpsb_host and also removes
semaphores from ieee1394_transactions.c. On i386, struct hpsb_host
shrinks from 10656 bytes to 6688 bytes. This is accomplished by
- using a single wait_queue for hpsb_get_tlabel instead of many
instances of semaphores,
- using a single lock to serialize access to all tlabel pools (the
protected code regions are small, i.e. lock contention very low),
- omitting the sysfs attribute tlabels_allocations.
Drawback: In the rare case that a process needs to sleep because all
transaction labels for the node are temporarily exhausted, it is also
woken up if a tlabel for a different node became free, checks for an
available tlabel, and is put to sleep again. The check is not costly
and the situation occurs extremely rarely. (Tlabels are typically
only exhausted if there was no context switch to the khpsbpkt thread
which recycles tlables.) Therefore the benefit of reduced tpool size
outweighs this drawback.
The sysfs attributes tlabels_free and tlabels_mask are not compiled
anymore unless CONFIG_IEEE1394_VERBOSEDEBUG is set.
The by far biggest member of struct hpsb_host, the struct csr_control
csr (5272 bytes on i386), is now placed at the end of struct hpsb_host.
Note, hpsb_get_tlabel calls the macro wait_event_interruptible with a
condition argument which has a side effect (allocation of a tlabel and
manipulation of the packet). This side effect happens only if the
condition is true. The patch relies on wait_event_interruptible not
evaluating the condition again after it became true.
Signed-off-by: Stefan Richter <stefanr@s5r6.in-berlin.de>
2006-07-02 08:17:00 -04:00
|
|
|
#endif
|
2005-04-16 18:20:36 -04:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
fw_attr(ud, struct unit_directory, address, unsigned long long, "0x%016Lx\n")
|
|
|
|
fw_attr(ud, struct unit_directory, length, int, "%d\n")
|
|
|
|
/* These are all dependent on the value being provided */
|
|
|
|
fw_attr(ud, struct unit_directory, vendor_id, unsigned int, "0x%06x\n")
|
|
|
|
fw_attr(ud, struct unit_directory, model_id, unsigned int, "0x%06x\n")
|
|
|
|
fw_attr(ud, struct unit_directory, specifier_id, unsigned int, "0x%06x\n")
|
|
|
|
fw_attr(ud, struct unit_directory, version, unsigned int, "0x%06x\n")
|
|
|
|
fw_attr_td(ud, struct unit_directory, vendor_name_kv)
|
|
|
|
fw_attr_td(ud, struct unit_directory, model_name_kv)
|
|
|
|
|
|
|
|
static struct device_attribute *const fw_ud_attrs[] = {
|
|
|
|
&dev_attr_ud_address,
|
|
|
|
&dev_attr_ud_length,
|
|
|
|
&dev_attr_ignore_driver,
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
fw_attr(host, struct hpsb_host, node_count, int, "%d\n")
|
|
|
|
fw_attr(host, struct hpsb_host, selfid_count, int, "%d\n")
|
|
|
|
fw_attr(host, struct hpsb_host, nodes_active, int, "%d\n")
|
|
|
|
fw_attr(host, struct hpsb_host, in_bus_reset, int, "%d\n")
|
|
|
|
fw_attr(host, struct hpsb_host, is_root, int, "%d\n")
|
|
|
|
fw_attr(host, struct hpsb_host, is_cycmst, int, "%d\n")
|
|
|
|
fw_attr(host, struct hpsb_host, is_irm, int, "%d\n")
|
|
|
|
fw_attr(host, struct hpsb_host, is_busmgr, int, "%d\n")
|
|
|
|
|
|
|
|
static struct device_attribute *const fw_host_attrs[] = {
|
|
|
|
&dev_attr_host_node_count,
|
|
|
|
&dev_attr_host_selfid_count,
|
|
|
|
&dev_attr_host_nodes_active,
|
|
|
|
&dev_attr_host_in_bus_reset,
|
|
|
|
&dev_attr_host_is_root,
|
|
|
|
&dev_attr_host_is_cycmst,
|
|
|
|
&dev_attr_host_is_irm,
|
|
|
|
&dev_attr_host_is_busmgr,
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
static ssize_t fw_show_drv_device_ids(struct device_driver *drv, char *buf)
|
|
|
|
{
|
|
|
|
struct hpsb_protocol_driver *driver;
|
|
|
|
struct ieee1394_device_id *id;
|
|
|
|
int length = 0;
|
|
|
|
char *scratch = buf;
|
|
|
|
|
2006-11-22 15:28:19 -05:00
|
|
|
driver = container_of(drv, struct hpsb_protocol_driver, driver);
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
for (id = driver->id_table; id->match_flags != 0; id++) {
|
|
|
|
int need_coma = 0;
|
|
|
|
|
|
|
|
if (id->match_flags & IEEE1394_MATCH_VENDOR_ID) {
|
|
|
|
length += sprintf(scratch, "vendor_id=0x%06x", id->vendor_id);
|
|
|
|
scratch = buf + length;
|
|
|
|
need_coma++;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (id->match_flags & IEEE1394_MATCH_MODEL_ID) {
|
|
|
|
length += sprintf(scratch, "%smodel_id=0x%06x",
|
|
|
|
need_coma++ ? "," : "",
|
|
|
|
id->model_id);
|
|
|
|
scratch = buf + length;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (id->match_flags & IEEE1394_MATCH_SPECIFIER_ID) {
|
|
|
|
length += sprintf(scratch, "%sspecifier_id=0x%06x",
|
|
|
|
need_coma++ ? "," : "",
|
|
|
|
id->specifier_id);
|
|
|
|
scratch = buf + length;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (id->match_flags & IEEE1394_MATCH_VERSION) {
|
|
|
|
length += sprintf(scratch, "%sversion=0x%06x",
|
|
|
|
need_coma++ ? "," : "",
|
|
|
|
id->version);
|
|
|
|
scratch = buf + length;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (need_coma) {
|
|
|
|
*scratch++ = '\n';
|
|
|
|
length++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return length;
|
|
|
|
}
|
|
|
|
static DRIVER_ATTR(device_ids,S_IRUGO,fw_show_drv_device_ids,NULL);
|
|
|
|
|
|
|
|
|
|
|
|
fw_drv_attr(name, const char *, "%s\n")
|
|
|
|
|
|
|
|
static struct driver_attribute *const fw_drv_attrs[] = {
|
|
|
|
&driver_attr_drv_name,
|
|
|
|
&driver_attr_device_ids,
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
static void nodemgr_create_drv_files(struct hpsb_protocol_driver *driver)
|
|
|
|
{
|
|
|
|
struct device_driver *drv = &driver->driver;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(fw_drv_attrs); i++)
|
2006-10-10 15:19:21 -04:00
|
|
|
if (driver_create_file(drv, fw_drv_attrs[i]))
|
|
|
|
goto fail;
|
|
|
|
return;
|
|
|
|
fail:
|
2007-03-30 13:21:05 -04:00
|
|
|
HPSB_ERR("Failed to add sysfs attribute");
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void nodemgr_remove_drv_files(struct hpsb_protocol_driver *driver)
|
|
|
|
{
|
|
|
|
struct device_driver *drv = &driver->driver;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(fw_drv_attrs); i++)
|
|
|
|
driver_remove_file(drv, fw_drv_attrs[i]);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void nodemgr_create_ne_dev_files(struct node_entry *ne)
|
|
|
|
{
|
|
|
|
struct device *dev = &ne->device;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(fw_ne_attrs); i++)
|
2006-10-10 15:19:21 -04:00
|
|
|
if (device_create_file(dev, fw_ne_attrs[i]))
|
|
|
|
goto fail;
|
|
|
|
return;
|
|
|
|
fail:
|
2007-03-30 13:21:05 -04:00
|
|
|
HPSB_ERR("Failed to add sysfs attribute");
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void nodemgr_create_host_dev_files(struct hpsb_host *host)
|
|
|
|
{
|
|
|
|
struct device *dev = &host->device;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(fw_host_attrs); i++)
|
2006-10-10 15:19:21 -04:00
|
|
|
if (device_create_file(dev, fw_host_attrs[i]))
|
|
|
|
goto fail;
|
|
|
|
return;
|
|
|
|
fail:
|
2007-03-30 13:21:05 -04:00
|
|
|
HPSB_ERR("Failed to add sysfs attribute");
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-10-10 15:19:21 -04:00
|
|
|
static struct node_entry *find_entry_by_nodeid(struct hpsb_host *host,
|
|
|
|
nodeid_t nodeid);
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
static void nodemgr_update_host_dev_links(struct hpsb_host *host)
|
|
|
|
{
|
|
|
|
struct device *dev = &host->device;
|
|
|
|
struct node_entry *ne;
|
|
|
|
|
|
|
|
sysfs_remove_link(&dev->kobj, "irm_id");
|
|
|
|
sysfs_remove_link(&dev->kobj, "busmgr_id");
|
|
|
|
sysfs_remove_link(&dev->kobj, "host_id");
|
|
|
|
|
2006-10-10 15:19:21 -04:00
|
|
|
if ((ne = find_entry_by_nodeid(host, host->irm_id)) &&
|
|
|
|
sysfs_create_link(&dev->kobj, &ne->device.kobj, "irm_id"))
|
|
|
|
goto fail;
|
|
|
|
if ((ne = find_entry_by_nodeid(host, host->busmgr_id)) &&
|
|
|
|
sysfs_create_link(&dev->kobj, &ne->device.kobj, "busmgr_id"))
|
|
|
|
goto fail;
|
|
|
|
if ((ne = find_entry_by_nodeid(host, host->node_id)) &&
|
|
|
|
sysfs_create_link(&dev->kobj, &ne->device.kobj, "host_id"))
|
|
|
|
goto fail;
|
|
|
|
return;
|
|
|
|
fail:
|
|
|
|
HPSB_ERR("Failed to update sysfs attributes for host %d", host->id);
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
static void nodemgr_create_ud_dev_files(struct unit_directory *ud)
|
|
|
|
{
|
|
|
|
struct device *dev = &ud->device;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(fw_ud_attrs); i++)
|
2006-10-10 15:19:21 -04:00
|
|
|
if (device_create_file(dev, fw_ud_attrs[i]))
|
|
|
|
goto fail;
|
2005-04-16 18:20:36 -04:00
|
|
|
if (ud->flags & UNIT_DIRECTORY_SPECIFIER_ID)
|
2006-10-10 15:19:21 -04:00
|
|
|
if (device_create_file(dev, &dev_attr_ud_specifier_id))
|
|
|
|
goto fail;
|
2005-04-16 18:20:36 -04:00
|
|
|
if (ud->flags & UNIT_DIRECTORY_VERSION)
|
2006-10-10 15:19:21 -04:00
|
|
|
if (device_create_file(dev, &dev_attr_ud_version))
|
|
|
|
goto fail;
|
2005-04-16 18:20:36 -04:00
|
|
|
if (ud->flags & UNIT_DIRECTORY_VENDOR_ID) {
|
2006-10-10 15:19:21 -04:00
|
|
|
if (device_create_file(dev, &dev_attr_ud_vendor_id))
|
|
|
|
goto fail;
|
|
|
|
if (ud->vendor_name_kv &&
|
|
|
|
device_create_file(dev, &dev_attr_ud_vendor_name_kv))
|
|
|
|
goto fail;
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
if (ud->flags & UNIT_DIRECTORY_MODEL_ID) {
|
2006-10-10 15:19:21 -04:00
|
|
|
if (device_create_file(dev, &dev_attr_ud_model_id))
|
|
|
|
goto fail;
|
|
|
|
if (ud->model_name_kv &&
|
|
|
|
device_create_file(dev, &dev_attr_ud_model_name_kv))
|
|
|
|
goto fail;
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
2006-10-10 15:19:21 -04:00
|
|
|
return;
|
|
|
|
fail:
|
2007-03-30 13:21:05 -04:00
|
|
|
HPSB_ERR("Failed to add sysfs attribute");
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static int nodemgr_bus_match(struct device * dev, struct device_driver * drv)
|
|
|
|
{
|
2006-11-22 15:28:19 -05:00
|
|
|
struct hpsb_protocol_driver *driver;
|
|
|
|
struct unit_directory *ud;
|
2005-04-16 18:20:36 -04:00
|
|
|
struct ieee1394_device_id *id;
|
|
|
|
|
|
|
|
/* We only match unit directories */
|
|
|
|
if (dev->platform_data != &nodemgr_ud_platform_data)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
ud = container_of(dev, struct unit_directory, device);
|
|
|
|
if (ud->ne->in_limbo || ud->ignore_driver)
|
|
|
|
return 0;
|
|
|
|
|
2006-11-22 15:09:42 -05:00
|
|
|
/* We only match drivers of type hpsb_protocol_driver */
|
|
|
|
if (drv == &nodemgr_mid_layer_driver)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
driver = container_of(drv, struct hpsb_protocol_driver, driver);
|
2006-11-22 15:28:19 -05:00
|
|
|
for (id = driver->id_table; id->match_flags != 0; id++) {
|
|
|
|
if ((id->match_flags & IEEE1394_MATCH_VENDOR_ID) &&
|
|
|
|
id->vendor_id != ud->vendor_id)
|
|
|
|
continue;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2006-11-22 15:28:19 -05:00
|
|
|
if ((id->match_flags & IEEE1394_MATCH_MODEL_ID) &&
|
|
|
|
id->model_id != ud->model_id)
|
|
|
|
continue;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2006-11-22 15:28:19 -05:00
|
|
|
if ((id->match_flags & IEEE1394_MATCH_SPECIFIER_ID) &&
|
|
|
|
id->specifier_id != ud->specifier_id)
|
|
|
|
continue;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2006-11-22 15:28:19 -05:00
|
|
|
if ((id->match_flags & IEEE1394_MATCH_VERSION) &&
|
|
|
|
id->version != ud->version)
|
|
|
|
continue;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
return 1;
|
2006-11-22 15:28:19 -05:00
|
|
|
}
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-10-22 10:16:27 -04:00
|
|
|
static DEFINE_MUTEX(nodemgr_serialize_remove_uds);
|
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
static void nodemgr_remove_uds(struct node_entry *ne)
|
|
|
|
{
|
2007-05-25 05:50:53 -04:00
|
|
|
struct device *dev;
|
2006-12-02 16:23:34 -05:00
|
|
|
struct unit_directory *tmp, *ud;
|
2006-10-22 10:16:27 -04:00
|
|
|
|
2007-05-25 05:50:53 -04:00
|
|
|
/* Iteration over nodemgr_ud_class.devices has to be protected by
|
|
|
|
* nodemgr_ud_class.sem, but device_unregister() will eventually
|
2006-12-02 16:23:34 -05:00
|
|
|
* take nodemgr_ud_class.sem too. Therefore pick out one ud at a time,
|
|
|
|
* release the semaphore, and then unregister the ud. Since this code
|
|
|
|
* may be called from other contexts besides the knodemgrds, protect the
|
2006-10-22 10:16:27 -04:00
|
|
|
* gap after release of the semaphore by nodemgr_serialize_remove_uds.
|
|
|
|
*/
|
|
|
|
mutex_lock(&nodemgr_serialize_remove_uds);
|
2006-12-02 16:23:34 -05:00
|
|
|
for (;;) {
|
|
|
|
ud = NULL;
|
|
|
|
down(&nodemgr_ud_class.sem);
|
2007-05-25 05:50:53 -04:00
|
|
|
list_for_each_entry(dev, &nodemgr_ud_class.devices, node) {
|
|
|
|
tmp = container_of(dev, struct unit_directory,
|
|
|
|
unit_dev);
|
2006-12-02 16:23:34 -05:00
|
|
|
if (tmp->ne == ne) {
|
|
|
|
ud = tmp;
|
|
|
|
break;
|
|
|
|
}
|
2006-10-22 10:16:27 -04:00
|
|
|
}
|
2006-12-02 16:23:34 -05:00
|
|
|
up(&nodemgr_ud_class.sem);
|
|
|
|
if (ud == NULL)
|
|
|
|
break;
|
2007-05-25 05:50:53 -04:00
|
|
|
device_unregister(&ud->unit_dev);
|
2006-12-02 16:23:34 -05:00
|
|
|
device_unregister(&ud->device);
|
2006-10-22 10:16:27 -04:00
|
|
|
}
|
|
|
|
mutex_unlock(&nodemgr_serialize_remove_uds);
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void nodemgr_remove_ne(struct node_entry *ne)
|
|
|
|
{
|
2006-11-18 17:16:11 -05:00
|
|
|
struct device *dev;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
dev = get_device(&ne->device);
|
|
|
|
if (!dev)
|
|
|
|
return;
|
|
|
|
|
|
|
|
HPSB_DEBUG("Node removed: ID:BUS[" NODE_BUS_FMT "] GUID[%016Lx]",
|
|
|
|
NODE_BUS_ARGS(ne->host, ne->nodeid), (unsigned long long)ne->guid);
|
|
|
|
nodemgr_remove_uds(ne);
|
|
|
|
|
2007-05-25 05:50:53 -04:00
|
|
|
device_unregister(&ne->node_dev);
|
2005-04-16 18:20:36 -04:00
|
|
|
device_unregister(dev);
|
|
|
|
|
|
|
|
put_device(dev);
|
|
|
|
}
|
|
|
|
|
2005-03-25 14:45:31 -05:00
|
|
|
static int __nodemgr_remove_host_dev(struct device *dev, void *data)
|
|
|
|
{
|
2007-05-25 05:50:53 -04:00
|
|
|
if (dev->bus == &ieee1394_bus_type)
|
|
|
|
nodemgr_remove_ne(container_of(dev, struct node_entry,
|
|
|
|
device));
|
2005-03-25 14:45:31 -05:00
|
|
|
return 0;
|
|
|
|
}
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
static void nodemgr_remove_host_dev(struct device *dev)
|
|
|
|
{
|
2006-10-10 15:19:21 -04:00
|
|
|
WARN_ON(device_for_each_child(dev, NULL, __nodemgr_remove_host_dev));
|
2005-04-16 18:20:36 -04:00
|
|
|
sysfs_remove_link(&dev->kobj, "irm_id");
|
|
|
|
sysfs_remove_link(&dev->kobj, "busmgr_id");
|
|
|
|
sysfs_remove_link(&dev->kobj, "host_id");
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void nodemgr_update_bus_options(struct node_entry *ne)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_IEEE1394_VERBOSEDEBUG
|
|
|
|
static const u16 mr[] = { 4, 64, 1024, 0};
|
|
|
|
#endif
|
|
|
|
quadlet_t busoptions = be32_to_cpu(ne->csr->bus_info_data[2]);
|
|
|
|
|
2006-11-22 15:28:19 -05:00
|
|
|
ne->busopt.irmc = (busoptions >> 31) & 1;
|
|
|
|
ne->busopt.cmc = (busoptions >> 30) & 1;
|
|
|
|
ne->busopt.isc = (busoptions >> 29) & 1;
|
|
|
|
ne->busopt.bmc = (busoptions >> 28) & 1;
|
|
|
|
ne->busopt.pmc = (busoptions >> 27) & 1;
|
|
|
|
ne->busopt.cyc_clk_acc = (busoptions >> 16) & 0xff;
|
|
|
|
ne->busopt.max_rec = 1 << (((busoptions >> 12) & 0xf) + 1);
|
2005-04-16 18:20:36 -04:00
|
|
|
ne->busopt.max_rom = (busoptions >> 8) & 0x3;
|
2006-11-22 15:28:19 -05:00
|
|
|
ne->busopt.generation = (busoptions >> 4) & 0xf;
|
|
|
|
ne->busopt.lnkspd = busoptions & 0x7;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
HPSB_VERBOSE("NodeMgr: raw=0x%08x irmc=%d cmc=%d isc=%d bmc=%d pmc=%d "
|
|
|
|
"cyc_clk_acc=%d max_rec=%d max_rom=%d gen=%d lspd=%d",
|
|
|
|
busoptions, ne->busopt.irmc, ne->busopt.cmc,
|
|
|
|
ne->busopt.isc, ne->busopt.bmc, ne->busopt.pmc,
|
|
|
|
ne->busopt.cyc_clk_acc, ne->busopt.max_rec,
|
|
|
|
mr[ne->busopt.max_rom],
|
|
|
|
ne->busopt.generation, ne->busopt.lnkspd);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static struct node_entry *nodemgr_create_node(octlet_t guid, struct csr1212_csr *csr,
|
|
|
|
struct host_info *hi, nodeid_t nodeid,
|
|
|
|
unsigned int generation)
|
|
|
|
{
|
|
|
|
struct hpsb_host *host = hi->host;
|
2005-11-07 06:31:45 -05:00
|
|
|
struct node_entry *ne;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2005-11-07 06:31:45 -05:00
|
|
|
ne = kzalloc(sizeof(*ne), GFP_KERNEL);
|
|
|
|
if (!ne)
|
2006-10-10 15:19:21 -04:00
|
|
|
goto fail_alloc;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2005-11-07 06:31:45 -05:00
|
|
|
ne->host = host;
|
|
|
|
ne->nodeid = nodeid;
|
2005-04-16 18:20:36 -04:00
|
|
|
ne->generation = generation;
|
|
|
|
ne->needs_probe = 1;
|
|
|
|
|
2005-11-07 06:31:45 -05:00
|
|
|
ne->guid = guid;
|
2005-04-16 18:20:36 -04:00
|
|
|
ne->guid_vendor_id = (guid >> 40) & 0xffffff;
|
|
|
|
ne->csr = csr;
|
|
|
|
|
|
|
|
memcpy(&ne->device, &nodemgr_dev_template_ne,
|
|
|
|
sizeof(ne->device));
|
|
|
|
ne->device.parent = &host->device;
|
|
|
|
snprintf(ne->device.bus_id, BUS_ID_SIZE, "%016Lx",
|
|
|
|
(unsigned long long)(ne->guid));
|
|
|
|
|
2007-05-25 05:50:53 -04:00
|
|
|
ne->node_dev.parent = &ne->device;
|
|
|
|
ne->node_dev.class = &nodemgr_ne_class;
|
|
|
|
snprintf(ne->node_dev.bus_id, BUS_ID_SIZE, "%016Lx",
|
|
|
|
(unsigned long long)(ne->guid));
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2006-10-10 15:19:21 -04:00
|
|
|
if (device_register(&ne->device))
|
|
|
|
goto fail_devreg;
|
2007-05-25 05:50:53 -04:00
|
|
|
if (device_register(&ne->node_dev))
|
2006-10-10 15:19:21 -04:00
|
|
|
goto fail_classdevreg;
|
2005-04-16 18:20:36 -04:00
|
|
|
get_device(&ne->device);
|
|
|
|
|
|
|
|
nodemgr_create_ne_dev_files(ne);
|
|
|
|
|
|
|
|
nodemgr_update_bus_options(ne);
|
|
|
|
|
|
|
|
HPSB_DEBUG("%s added: ID:BUS[" NODE_BUS_FMT "] GUID[%016Lx]",
|
|
|
|
(host->node_id == nodeid) ? "Host" : "Node",
|
|
|
|
NODE_BUS_ARGS(host, nodeid), (unsigned long long)guid);
|
|
|
|
|
2005-11-07 06:31:45 -05:00
|
|
|
return ne;
|
2006-10-10 15:19:21 -04:00
|
|
|
|
|
|
|
fail_classdevreg:
|
|
|
|
device_unregister(&ne->device);
|
|
|
|
fail_devreg:
|
|
|
|
kfree(ne);
|
|
|
|
fail_alloc:
|
|
|
|
HPSB_ERR("Failed to create node ID:BUS[" NODE_BUS_FMT "] GUID[%016Lx]",
|
|
|
|
NODE_BUS_ARGS(host, nodeid), (unsigned long long)guid);
|
|
|
|
|
|
|
|
return NULL;
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static struct node_entry *find_entry_by_guid(u64 guid)
|
|
|
|
{
|
2007-05-25 05:50:53 -04:00
|
|
|
struct device *dev;
|
2005-04-16 18:20:36 -04:00
|
|
|
struct node_entry *ne, *ret_ne = NULL;
|
|
|
|
|
2006-10-22 10:16:27 -04:00
|
|
|
down(&nodemgr_ne_class.sem);
|
2007-05-25 05:50:53 -04:00
|
|
|
list_for_each_entry(dev, &nodemgr_ne_class.devices, node) {
|
|
|
|
ne = container_of(dev, struct node_entry, node_dev);
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
if (ne->guid == guid) {
|
|
|
|
ret_ne = ne;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2006-10-22 10:16:27 -04:00
|
|
|
up(&nodemgr_ne_class.sem);
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2006-11-22 15:28:19 -05:00
|
|
|
return ret_ne;
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-10-22 10:16:27 -04:00
|
|
|
static struct node_entry *find_entry_by_nodeid(struct hpsb_host *host,
|
|
|
|
nodeid_t nodeid)
|
2005-04-16 18:20:36 -04:00
|
|
|
{
|
2007-05-25 05:50:53 -04:00
|
|
|
struct device *dev;
|
2005-04-16 18:20:36 -04:00
|
|
|
struct node_entry *ne, *ret_ne = NULL;
|
|
|
|
|
2006-10-22 10:16:27 -04:00
|
|
|
down(&nodemgr_ne_class.sem);
|
2007-05-25 05:50:53 -04:00
|
|
|
list_for_each_entry(dev, &nodemgr_ne_class.devices, node) {
|
|
|
|
ne = container_of(dev, struct node_entry, node_dev);
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
if (ne->host == host && ne->nodeid == nodeid) {
|
|
|
|
ret_ne = ne;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2006-10-22 10:16:27 -04:00
|
|
|
up(&nodemgr_ne_class.sem);
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
return ret_ne;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void nodemgr_register_device(struct node_entry *ne,
|
|
|
|
struct unit_directory *ud, struct device *parent)
|
|
|
|
{
|
|
|
|
memcpy(&ud->device, &nodemgr_dev_template_ud,
|
|
|
|
sizeof(ud->device));
|
|
|
|
|
|
|
|
ud->device.parent = parent;
|
|
|
|
|
|
|
|
snprintf(ud->device.bus_id, BUS_ID_SIZE, "%s-%u",
|
|
|
|
ne->device.bus_id, ud->id);
|
|
|
|
|
2007-05-25 05:50:53 -04:00
|
|
|
ud->unit_dev.parent = &ud->device;
|
|
|
|
ud->unit_dev.class = &nodemgr_ud_class;
|
|
|
|
snprintf(ud->unit_dev.bus_id, BUS_ID_SIZE, "%s-%u",
|
2005-04-16 18:20:36 -04:00
|
|
|
ne->device.bus_id, ud->id);
|
|
|
|
|
2006-10-10 15:19:21 -04:00
|
|
|
if (device_register(&ud->device))
|
|
|
|
goto fail_devreg;
|
2007-05-25 05:50:53 -04:00
|
|
|
if (device_register(&ud->unit_dev))
|
2006-10-10 15:19:21 -04:00
|
|
|
goto fail_classdevreg;
|
2005-04-16 18:20:36 -04:00
|
|
|
get_device(&ud->device);
|
|
|
|
|
|
|
|
nodemgr_create_ud_dev_files(ud);
|
2006-10-10 15:19:21 -04:00
|
|
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
fail_classdevreg:
|
|
|
|
device_unregister(&ud->device);
|
|
|
|
fail_devreg:
|
|
|
|
HPSB_ERR("Failed to create unit %s", ud->device.bus_id);
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* This implementation currently only scans the config rom and its
|
|
|
|
* immediate unit directories looking for software_id and
|
|
|
|
* software_version entries, in order to get driver autoloading working. */
|
|
|
|
static struct unit_directory *nodemgr_process_unit_directory
|
|
|
|
(struct host_info *hi, struct node_entry *ne, struct csr1212_keyval *ud_kv,
|
|
|
|
unsigned int *id, struct unit_directory *parent)
|
|
|
|
{
|
|
|
|
struct unit_directory *ud;
|
|
|
|
struct unit_directory *ud_child = NULL;
|
|
|
|
struct csr1212_dentry *dentry;
|
|
|
|
struct csr1212_keyval *kv;
|
|
|
|
u8 last_key_id = 0;
|
|
|
|
|
2005-11-07 06:31:45 -05:00
|
|
|
ud = kzalloc(sizeof(*ud), GFP_KERNEL);
|
2005-04-16 18:20:36 -04:00
|
|
|
if (!ud)
|
|
|
|
goto unit_directory_error;
|
|
|
|
|
|
|
|
ud->ne = ne;
|
|
|
|
ud->ignore_driver = ignore_drivers;
|
2007-05-27 07:11:47 -04:00
|
|
|
ud->address = ud_kv->offset + CSR1212_REGISTER_SPACE_BASE;
|
2007-05-27 07:17:15 -04:00
|
|
|
ud->directory_id = ud->address & 0xffffff;
|
2005-04-16 18:20:36 -04:00
|
|
|
ud->ud_kv = ud_kv;
|
|
|
|
ud->id = (*id)++;
|
|
|
|
|
|
|
|
csr1212_for_each_dir_entry(ne->csr, kv, ud_kv, dentry) {
|
|
|
|
switch (kv->key.id) {
|
|
|
|
case CSR1212_KV_ID_VENDOR:
|
|
|
|
if (kv->key.type == CSR1212_KV_TYPE_IMMEDIATE) {
|
|
|
|
ud->vendor_id = kv->value.immediate;
|
|
|
|
ud->flags |= UNIT_DIRECTORY_VENDOR_ID;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case CSR1212_KV_ID_MODEL:
|
|
|
|
ud->model_id = kv->value.immediate;
|
|
|
|
ud->flags |= UNIT_DIRECTORY_MODEL_ID;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case CSR1212_KV_ID_SPECIFIER_ID:
|
|
|
|
ud->specifier_id = kv->value.immediate;
|
|
|
|
ud->flags |= UNIT_DIRECTORY_SPECIFIER_ID;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case CSR1212_KV_ID_VERSION:
|
|
|
|
ud->version = kv->value.immediate;
|
|
|
|
ud->flags |= UNIT_DIRECTORY_VERSION;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case CSR1212_KV_ID_DESCRIPTOR:
|
|
|
|
if (kv->key.type == CSR1212_KV_TYPE_LEAF &&
|
|
|
|
CSR1212_DESCRIPTOR_LEAF_TYPE(kv) == 0 &&
|
|
|
|
CSR1212_DESCRIPTOR_LEAF_SPECIFIER_ID(kv) == 0 &&
|
|
|
|
CSR1212_TEXTUAL_DESCRIPTOR_LEAF_WIDTH(kv) == 0 &&
|
|
|
|
CSR1212_TEXTUAL_DESCRIPTOR_LEAF_CHAR_SET(kv) == 0 &&
|
|
|
|
CSR1212_TEXTUAL_DESCRIPTOR_LEAF_LANGUAGE(kv) == 0) {
|
|
|
|
switch (last_key_id) {
|
|
|
|
case CSR1212_KV_ID_VENDOR:
|
|
|
|
ud->vendor_name_kv = kv;
|
|
|
|
csr1212_keep_keyval(kv);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case CSR1212_KV_ID_MODEL:
|
|
|
|
ud->model_name_kv = kv;
|
|
|
|
csr1212_keep_keyval(kv);
|
|
|
|
break;
|
|
|
|
|
|
|
|
}
|
|
|
|
} /* else if (kv->key.type == CSR1212_KV_TYPE_DIRECTORY) ... */
|
|
|
|
break;
|
|
|
|
|
|
|
|
case CSR1212_KV_ID_DEPENDENT_INFO:
|
|
|
|
/* Logical Unit Number */
|
|
|
|
if (kv->key.type == CSR1212_KV_TYPE_IMMEDIATE) {
|
|
|
|
if (ud->flags & UNIT_DIRECTORY_HAS_LUN) {
|
2006-10-29 15:13:40 -05:00
|
|
|
ud_child = kmemdup(ud, sizeof(*ud_child), GFP_KERNEL);
|
2005-04-16 18:20:36 -04:00
|
|
|
if (!ud_child)
|
|
|
|
goto unit_directory_error;
|
|
|
|
nodemgr_register_device(ne, ud_child, &ne->device);
|
|
|
|
ud_child = NULL;
|
|
|
|
|
|
|
|
ud->id = (*id)++;
|
|
|
|
}
|
|
|
|
ud->lun = kv->value.immediate;
|
|
|
|
ud->flags |= UNIT_DIRECTORY_HAS_LUN;
|
|
|
|
|
|
|
|
/* Logical Unit Directory */
|
|
|
|
} else if (kv->key.type == CSR1212_KV_TYPE_DIRECTORY) {
|
|
|
|
/* This should really be done in SBP2 as this is
|
|
|
|
* doing SBP2 specific parsing.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* first register the parent unit */
|
|
|
|
ud->flags |= UNIT_DIRECTORY_HAS_LUN_DIRECTORY;
|
|
|
|
if (ud->device.bus != &ieee1394_bus_type)
|
|
|
|
nodemgr_register_device(ne, ud, &ne->device);
|
|
|
|
|
|
|
|
/* process the child unit */
|
|
|
|
ud_child = nodemgr_process_unit_directory(hi, ne, kv, id, ud);
|
|
|
|
|
|
|
|
if (ud_child == NULL)
|
|
|
|
break;
|
|
|
|
|
2005-11-16 03:00:00 -05:00
|
|
|
/* inherit unspecified values, the driver core picks it up */
|
2005-04-16 18:20:36 -04:00
|
|
|
if ((ud->flags & UNIT_DIRECTORY_MODEL_ID) &&
|
|
|
|
!(ud_child->flags & UNIT_DIRECTORY_MODEL_ID))
|
|
|
|
{
|
|
|
|
ud_child->flags |= UNIT_DIRECTORY_MODEL_ID;
|
|
|
|
ud_child->model_id = ud->model_id;
|
|
|
|
}
|
|
|
|
if ((ud->flags & UNIT_DIRECTORY_SPECIFIER_ID) &&
|
|
|
|
!(ud_child->flags & UNIT_DIRECTORY_SPECIFIER_ID))
|
|
|
|
{
|
|
|
|
ud_child->flags |= UNIT_DIRECTORY_SPECIFIER_ID;
|
|
|
|
ud_child->specifier_id = ud->specifier_id;
|
|
|
|
}
|
|
|
|
if ((ud->flags & UNIT_DIRECTORY_VERSION) &&
|
|
|
|
!(ud_child->flags & UNIT_DIRECTORY_VERSION))
|
|
|
|
{
|
|
|
|
ud_child->flags |= UNIT_DIRECTORY_VERSION;
|
|
|
|
ud_child->version = ud->version;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* register the child unit */
|
|
|
|
ud_child->flags |= UNIT_DIRECTORY_LUN_DIRECTORY;
|
|
|
|
nodemgr_register_device(ne, ud_child, &ud->device);
|
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
2007-05-27 07:17:15 -04:00
|
|
|
case CSR1212_KV_ID_DIRECTORY_ID:
|
|
|
|
ud->directory_id = kv->value.immediate;
|
|
|
|
break;
|
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
last_key_id = kv->key.id;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* do not process child units here and only if not already registered */
|
|
|
|
if (!parent && ud->device.bus != &ieee1394_bus_type)
|
|
|
|
nodemgr_register_device(ne, ud, &ne->device);
|
|
|
|
|
|
|
|
return ud;
|
|
|
|
|
|
|
|
unit_directory_error:
|
2005-05-17 00:54:01 -04:00
|
|
|
kfree(ud);
|
2005-04-16 18:20:36 -04:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void nodemgr_process_root_directory(struct host_info *hi, struct node_entry *ne)
|
|
|
|
{
|
|
|
|
unsigned int ud_id = 0;
|
|
|
|
struct csr1212_dentry *dentry;
|
|
|
|
struct csr1212_keyval *kv;
|
|
|
|
u8 last_key_id = 0;
|
|
|
|
|
|
|
|
ne->needs_probe = 0;
|
|
|
|
|
|
|
|
csr1212_for_each_dir_entry(ne->csr, kv, ne->csr->root_kv, dentry) {
|
|
|
|
switch (kv->key.id) {
|
|
|
|
case CSR1212_KV_ID_VENDOR:
|
|
|
|
ne->vendor_id = kv->value.immediate;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case CSR1212_KV_ID_NODE_CAPABILITIES:
|
|
|
|
ne->capabilities = kv->value.immediate;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case CSR1212_KV_ID_UNIT:
|
|
|
|
nodemgr_process_unit_directory(hi, ne, kv, &ud_id, NULL);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case CSR1212_KV_ID_DESCRIPTOR:
|
|
|
|
if (last_key_id == CSR1212_KV_ID_VENDOR) {
|
|
|
|
if (kv->key.type == CSR1212_KV_TYPE_LEAF &&
|
|
|
|
CSR1212_DESCRIPTOR_LEAF_TYPE(kv) == 0 &&
|
|
|
|
CSR1212_DESCRIPTOR_LEAF_SPECIFIER_ID(kv) == 0 &&
|
|
|
|
CSR1212_TEXTUAL_DESCRIPTOR_LEAF_WIDTH(kv) == 0 &&
|
|
|
|
CSR1212_TEXTUAL_DESCRIPTOR_LEAF_CHAR_SET(kv) == 0 &&
|
|
|
|
CSR1212_TEXTUAL_DESCRIPTOR_LEAF_LANGUAGE(kv) == 0) {
|
|
|
|
ne->vendor_name_kv = kv;
|
|
|
|
csr1212_keep_keyval(kv);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
last_key_id = kv->key.id;
|
|
|
|
}
|
|
|
|
|
2007-03-30 13:19:55 -04:00
|
|
|
if (ne->vendor_name_kv) {
|
|
|
|
int error = device_create_file(&ne->device,
|
|
|
|
&dev_attr_ne_vendor_name_kv);
|
|
|
|
|
|
|
|
if (error && error != -EEXIST)
|
2007-03-30 13:21:05 -04:00
|
|
|
HPSB_ERR("Failed to add sysfs attribute");
|
2007-03-30 13:19:55 -04:00
|
|
|
}
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_HOTPLUG
|
|
|
|
|
2007-08-14 09:15:12 -04:00
|
|
|
static int nodemgr_uevent(struct device *dev, struct kobj_uevent_env *env)
|
2005-04-16 18:20:36 -04:00
|
|
|
{
|
|
|
|
struct unit_directory *ud;
|
2007-03-31 01:23:12 -04:00
|
|
|
int retval = 0;
|
2005-09-06 18:18:18 -04:00
|
|
|
/* ieee1394:venNmoNspNverN */
|
|
|
|
char buf[8 + 1 + 3 + 8 + 2 + 8 + 2 + 8 + 3 + 8 + 1];
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2007-05-25 05:50:53 -04:00
|
|
|
if (!dev)
|
2005-04-16 18:20:36 -04:00
|
|
|
return -ENODEV;
|
|
|
|
|
2007-05-25 05:50:53 -04:00
|
|
|
ud = container_of(dev, struct unit_directory, unit_dev);
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
if (ud->ne->in_limbo || ud->ignore_driver)
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
#define PUT_ENVP(fmt,val) \
|
|
|
|
do { \
|
2007-08-14 09:15:12 -04:00
|
|
|
retval = add_uevent_var(env, fmt, val); \
|
2007-03-31 01:23:12 -04:00
|
|
|
if (retval) \
|
|
|
|
return retval; \
|
2005-04-16 18:20:36 -04:00
|
|
|
} while (0)
|
|
|
|
|
|
|
|
PUT_ENVP("VENDOR_ID=%06x", ud->vendor_id);
|
|
|
|
PUT_ENVP("MODEL_ID=%06x", ud->model_id);
|
|
|
|
PUT_ENVP("GUID=%016Lx", (unsigned long long)ud->ne->guid);
|
|
|
|
PUT_ENVP("SPECIFIER_ID=%06x", ud->specifier_id);
|
|
|
|
PUT_ENVP("VERSION=%06x", ud->version);
|
2005-09-06 18:18:18 -04:00
|
|
|
snprintf(buf, sizeof(buf), "ieee1394:ven%08Xmo%08Xsp%08Xver%08X",
|
|
|
|
ud->vendor_id,
|
|
|
|
ud->model_id,
|
|
|
|
ud->specifier_id,
|
|
|
|
ud->version);
|
|
|
|
PUT_ENVP("MODALIAS=%s", buf);
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
#undef PUT_ENVP
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
#else
|
|
|
|
|
2007-08-14 09:15:12 -04:00
|
|
|
static int nodemgr_uevent(struct device *dev, struct kobj_uevent_env *env)
|
2005-04-16 18:20:36 -04:00
|
|
|
{
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif /* CONFIG_HOTPLUG */
|
|
|
|
|
|
|
|
|
2006-11-23 13:59:48 -05:00
|
|
|
int __hpsb_register_protocol(struct hpsb_protocol_driver *drv,
|
|
|
|
struct module *owner)
|
2005-04-16 18:20:36 -04:00
|
|
|
{
|
2006-11-23 13:59:48 -05:00
|
|
|
int error;
|
|
|
|
|
|
|
|
drv->driver.bus = &ieee1394_bus_type;
|
|
|
|
drv->driver.owner = owner;
|
|
|
|
drv->driver.name = drv->name;
|
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
/* This will cause a probe for devices */
|
2006-11-23 13:59:48 -05:00
|
|
|
error = driver_register(&drv->driver);
|
2006-10-20 19:23:56 -04:00
|
|
|
if (!error)
|
2006-11-23 13:59:48 -05:00
|
|
|
nodemgr_create_drv_files(drv);
|
2006-10-20 19:23:56 -04:00
|
|
|
return error;
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void hpsb_unregister_protocol(struct hpsb_protocol_driver *driver)
|
|
|
|
{
|
|
|
|
nodemgr_remove_drv_files(driver);
|
|
|
|
/* This will subsequently disconnect all devices that our driver
|
|
|
|
* is attached to. */
|
|
|
|
driver_unregister(&driver->driver);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This function updates nodes that were present on the bus before the
|
|
|
|
* reset and still are after the reset. The nodeid and the config rom
|
|
|
|
* may have changed, and the drivers managing this device must be
|
|
|
|
* informed that this device just went through a bus reset, to allow
|
|
|
|
* the to take whatever actions required.
|
|
|
|
*/
|
|
|
|
static void nodemgr_update_node(struct node_entry *ne, struct csr1212_csr *csr,
|
|
|
|
struct host_info *hi, nodeid_t nodeid,
|
|
|
|
unsigned int generation)
|
|
|
|
{
|
|
|
|
if (ne->nodeid != nodeid) {
|
|
|
|
HPSB_DEBUG("Node changed: " NODE_BUS_FMT " -> " NODE_BUS_FMT,
|
|
|
|
NODE_BUS_ARGS(ne->host, ne->nodeid),
|
|
|
|
NODE_BUS_ARGS(ne->host, nodeid));
|
|
|
|
ne->nodeid = nodeid;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ne->busopt.generation != ((be32_to_cpu(csr->bus_info_data[2]) >> 4) & 0xf)) {
|
|
|
|
kfree(ne->csr->private);
|
|
|
|
csr1212_destroy_csr(ne->csr);
|
|
|
|
ne->csr = csr;
|
|
|
|
|
|
|
|
/* If the node's configrom generation has changed, we
|
|
|
|
* unregister all the unit directories. */
|
|
|
|
nodemgr_remove_uds(ne);
|
|
|
|
|
|
|
|
nodemgr_update_bus_options(ne);
|
|
|
|
|
|
|
|
/* Mark the node as new, so it gets re-probed */
|
|
|
|
ne->needs_probe = 1;
|
|
|
|
} else {
|
|
|
|
/* old cache is valid, so update its generation */
|
|
|
|
struct nodemgr_csr_info *ci = ne->csr->private;
|
|
|
|
ci->generation = generation;
|
|
|
|
/* free the partially filled now unneeded new cache */
|
|
|
|
kfree(csr->private);
|
|
|
|
csr1212_destroy_csr(csr);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ne->in_limbo)
|
|
|
|
nodemgr_resume_ne(ne);
|
|
|
|
|
|
|
|
/* Mark the node current */
|
|
|
|
ne->generation = generation;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static void nodemgr_node_scan_one(struct host_info *hi,
|
|
|
|
nodeid_t nodeid, int generation)
|
|
|
|
{
|
|
|
|
struct hpsb_host *host = hi->host;
|
|
|
|
struct node_entry *ne;
|
|
|
|
octlet_t guid;
|
|
|
|
struct csr1212_csr *csr;
|
|
|
|
struct nodemgr_csr_info *ci;
|
2006-07-02 18:58:01 -04:00
|
|
|
u8 *speed;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2005-11-07 06:31:45 -05:00
|
|
|
ci = kmalloc(sizeof(*ci), GFP_KERNEL);
|
2005-04-16 18:20:36 -04:00
|
|
|
if (!ci)
|
|
|
|
return;
|
|
|
|
|
|
|
|
ci->host = host;
|
|
|
|
ci->nodeid = nodeid;
|
|
|
|
ci->generation = generation;
|
2006-07-02 18:58:01 -04:00
|
|
|
|
|
|
|
/* Prepare for speed probe which occurs when reading the ROM */
|
|
|
|
speed = &(host->speed[NODEID_TO_NODE(nodeid)]);
|
|
|
|
if (*speed > host->csr.lnk_spd)
|
|
|
|
*speed = host->csr.lnk_spd;
|
|
|
|
ci->speed_unverified = *speed > IEEE1394_SPEED_100;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
/* We need to detect when the ConfigROM's generation has changed,
|
|
|
|
* so we only update the node's info when it needs to be. */
|
|
|
|
|
|
|
|
csr = csr1212_create_csr(&nodemgr_csr_ops, 5 * sizeof(quadlet_t), ci);
|
|
|
|
if (!csr || csr1212_parse_csr(csr) != CSR1212_SUCCESS) {
|
|
|
|
HPSB_ERR("Error parsing configrom for node " NODE_BUS_FMT,
|
|
|
|
NODE_BUS_ARGS(host, nodeid));
|
|
|
|
if (csr)
|
|
|
|
csr1212_destroy_csr(csr);
|
|
|
|
kfree(ci);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (csr->bus_info_data[1] != IEEE1394_BUSID_MAGIC) {
|
|
|
|
/* This isn't a 1394 device, but we let it slide. There
|
|
|
|
* was a report of a device with broken firmware which
|
|
|
|
* reported '2394' instead of '1394', which is obviously a
|
|
|
|
* mistake. One would hope that a non-1394 device never
|
|
|
|
* gets connected to Firewire bus. If someone does, we
|
|
|
|
* shouldn't be held responsible, so we'll allow it with a
|
|
|
|
* warning. */
|
|
|
|
HPSB_WARN("Node " NODE_BUS_FMT " has invalid busID magic [0x%08x]",
|
|
|
|
NODE_BUS_ARGS(host, nodeid), csr->bus_info_data[1]);
|
|
|
|
}
|
|
|
|
|
|
|
|
guid = ((u64)be32_to_cpu(csr->bus_info_data[3]) << 32) | be32_to_cpu(csr->bus_info_data[4]);
|
|
|
|
ne = find_entry_by_guid(guid);
|
|
|
|
|
|
|
|
if (ne && ne->host != host && ne->in_limbo) {
|
|
|
|
/* Must have moved this device from one host to another */
|
|
|
|
nodemgr_remove_ne(ne);
|
|
|
|
ne = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!ne)
|
|
|
|
nodemgr_create_node(guid, csr, hi, nodeid, generation);
|
|
|
|
else
|
|
|
|
nodemgr_update_node(ne, csr, hi, nodeid, generation);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void nodemgr_node_scan(struct host_info *hi, int generation)
|
|
|
|
{
|
2006-11-22 15:28:19 -05:00
|
|
|
int count;
|
|
|
|
struct hpsb_host *host = hi->host;
|
|
|
|
struct selfid *sid = (struct selfid *)host->topology_map;
|
|
|
|
nodeid_t nodeid = LOCAL_BUS;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2006-11-22 15:28:19 -05:00
|
|
|
/* Scan each node on the bus */
|
|
|
|
for (count = host->selfid_count; count; count--, sid++) {
|
|
|
|
if (sid->extended)
|
|
|
|
continue;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2006-11-22 15:28:19 -05:00
|
|
|
if (!sid->link_active) {
|
|
|
|
nodeid++;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
nodemgr_node_scan_one(hi, nodeid++, generation);
|
|
|
|
}
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void nodemgr_suspend_ne(struct node_entry *ne)
|
|
|
|
{
|
2007-05-25 05:50:53 -04:00
|
|
|
struct device *dev;
|
2005-04-16 18:20:36 -04:00
|
|
|
struct unit_directory *ud;
|
2007-06-17 17:47:45 -04:00
|
|
|
struct device_driver *drv;
|
|
|
|
int error;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
HPSB_DEBUG("Node suspended: ID:BUS[" NODE_BUS_FMT "] GUID[%016Lx]",
|
|
|
|
NODE_BUS_ARGS(ne->host, ne->nodeid), (unsigned long long)ne->guid);
|
|
|
|
|
|
|
|
ne->in_limbo = 1;
|
2006-10-10 15:19:21 -04:00
|
|
|
WARN_ON(device_create_file(&ne->device, &dev_attr_ne_in_limbo));
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2006-10-22 10:16:27 -04:00
|
|
|
down(&nodemgr_ud_class.sem);
|
2007-05-25 05:50:53 -04:00
|
|
|
list_for_each_entry(dev, &nodemgr_ud_class.devices, node) {
|
|
|
|
ud = container_of(dev, struct unit_directory, unit_dev);
|
2005-04-16 18:20:36 -04:00
|
|
|
if (ud->ne != ne)
|
|
|
|
continue;
|
|
|
|
|
2007-06-17 17:47:45 -04:00
|
|
|
drv = get_driver(ud->device.driver);
|
|
|
|
if (!drv)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
error = 1; /* release if suspend is not implemented */
|
|
|
|
if (drv->suspend) {
|
|
|
|
down(&ud->device.sem);
|
|
|
|
error = drv->suspend(&ud->device, PMSG_SUSPEND);
|
|
|
|
up(&ud->device.sem);
|
|
|
|
}
|
|
|
|
if (error)
|
2005-04-16 18:20:36 -04:00
|
|
|
device_release_driver(&ud->device);
|
2007-06-17 17:47:45 -04:00
|
|
|
put_driver(drv);
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
2006-10-22 10:16:27 -04:00
|
|
|
up(&nodemgr_ud_class.sem);
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void nodemgr_resume_ne(struct node_entry *ne)
|
|
|
|
{
|
2007-05-25 05:50:53 -04:00
|
|
|
struct device *dev;
|
2005-04-16 18:20:36 -04:00
|
|
|
struct unit_directory *ud;
|
2007-06-17 17:47:45 -04:00
|
|
|
struct device_driver *drv;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
ne->in_limbo = 0;
|
|
|
|
device_remove_file(&ne->device, &dev_attr_ne_in_limbo);
|
|
|
|
|
2006-10-22 10:16:27 -04:00
|
|
|
down(&nodemgr_ud_class.sem);
|
2007-05-25 05:50:53 -04:00
|
|
|
list_for_each_entry(dev, &nodemgr_ud_class.devices, node) {
|
|
|
|
ud = container_of(dev, struct unit_directory, unit_dev);
|
2005-04-16 18:20:36 -04:00
|
|
|
if (ud->ne != ne)
|
|
|
|
continue;
|
|
|
|
|
2007-06-17 17:47:45 -04:00
|
|
|
drv = get_driver(ud->device.driver);
|
|
|
|
if (!drv)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (drv->resume) {
|
|
|
|
down(&ud->device.sem);
|
|
|
|
drv->resume(&ud->device);
|
|
|
|
up(&ud->device.sem);
|
|
|
|
}
|
|
|
|
put_driver(drv);
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
2006-10-22 10:16:27 -04:00
|
|
|
up(&nodemgr_ud_class.sem);
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
HPSB_DEBUG("Node resumed: ID:BUS[" NODE_BUS_FMT "] GUID[%016Lx]",
|
|
|
|
NODE_BUS_ARGS(ne->host, ne->nodeid), (unsigned long long)ne->guid);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void nodemgr_update_pdrv(struct node_entry *ne)
|
|
|
|
{
|
2007-06-17 17:47:45 -04:00
|
|
|
struct device *dev;
|
2005-04-16 18:20:36 -04:00
|
|
|
struct unit_directory *ud;
|
2007-06-17 17:47:45 -04:00
|
|
|
struct device_driver *drv;
|
2005-04-16 18:20:36 -04:00
|
|
|
struct hpsb_protocol_driver *pdrv;
|
2007-06-17 17:47:45 -04:00
|
|
|
int error;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2006-10-22 10:16:27 -04:00
|
|
|
down(&nodemgr_ud_class.sem);
|
2007-05-25 05:50:53 -04:00
|
|
|
list_for_each_entry(dev, &nodemgr_ud_class.devices, node) {
|
|
|
|
ud = container_of(dev, struct unit_directory, unit_dev);
|
2006-10-22 10:16:27 -04:00
|
|
|
if (ud->ne != ne)
|
2005-04-16 18:20:36 -04:00
|
|
|
continue;
|
|
|
|
|
2007-06-17 17:47:45 -04:00
|
|
|
drv = get_driver(ud->device.driver);
|
|
|
|
if (!drv)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
error = 0;
|
|
|
|
pdrv = container_of(drv, struct hpsb_protocol_driver, driver);
|
|
|
|
if (pdrv->update) {
|
|
|
|
down(&ud->device.sem);
|
|
|
|
error = pdrv->update(ud);
|
|
|
|
up(&ud->device.sem);
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
2007-06-17 17:47:45 -04:00
|
|
|
if (error)
|
|
|
|
device_release_driver(&ud->device);
|
|
|
|
put_driver(drv);
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
2006-10-22 10:16:27 -04:00
|
|
|
up(&nodemgr_ud_class.sem);
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-12-05 16:28:59 -05:00
|
|
|
/* Write the BROADCAST_CHANNEL as per IEEE1394a 8.3.2.3.11 and 8.4.2.3. This
|
|
|
|
* seems like an optional service but in the end it is practically mandatory
|
|
|
|
* as a consequence of these clauses.
|
|
|
|
*
|
|
|
|
* Note that we cannot do a broadcast write to all nodes at once because some
|
|
|
|
* pre-1394a devices would hang. */
|
|
|
|
static void nodemgr_irm_write_bc(struct node_entry *ne, int generation)
|
|
|
|
{
|
|
|
|
const u64 bc_addr = (CSR_REGISTER_BASE | CSR_BROADCAST_CHANNEL);
|
|
|
|
quadlet_t bc_remote, bc_local;
|
2006-10-20 19:23:56 -04:00
|
|
|
int error;
|
2005-12-05 16:28:59 -05:00
|
|
|
|
|
|
|
if (!ne->host->is_irm || ne->generation != generation ||
|
|
|
|
ne->nodeid == ne->host->node_id)
|
|
|
|
return;
|
|
|
|
|
|
|
|
bc_local = cpu_to_be32(ne->host->csr.broadcast_channel);
|
|
|
|
|
|
|
|
/* Check if the register is implemented and 1394a compliant. */
|
2006-10-20 19:23:56 -04:00
|
|
|
error = hpsb_read(ne->host, ne->nodeid, generation, bc_addr, &bc_remote,
|
|
|
|
sizeof(bc_remote));
|
|
|
|
if (!error && bc_remote & cpu_to_be32(0x80000000) &&
|
2005-12-05 16:28:59 -05:00
|
|
|
bc_remote != bc_local)
|
|
|
|
hpsb_node_write(ne, bc_addr, &bc_local, sizeof(bc_local));
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
static void nodemgr_probe_ne(struct host_info *hi, struct node_entry *ne, int generation)
|
|
|
|
{
|
|
|
|
struct device *dev;
|
|
|
|
|
|
|
|
if (ne->host != hi->host || ne->in_limbo)
|
|
|
|
return;
|
|
|
|
|
|
|
|
dev = get_device(&ne->device);
|
|
|
|
if (!dev)
|
|
|
|
return;
|
|
|
|
|
2005-12-05 16:28:59 -05:00
|
|
|
nodemgr_irm_write_bc(ne, generation);
|
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
/* If "needs_probe", then this is either a new or changed node we
|
|
|
|
* rescan totally. If the generation matches for an existing node
|
|
|
|
* (one that existed prior to the bus reset) we send update calls
|
|
|
|
* down to the drivers. Otherwise, this is a dead node and we
|
|
|
|
* suspend it. */
|
|
|
|
if (ne->needs_probe)
|
|
|
|
nodemgr_process_root_directory(hi, ne);
|
|
|
|
else if (ne->generation == generation)
|
|
|
|
nodemgr_update_pdrv(ne);
|
|
|
|
else
|
|
|
|
nodemgr_suspend_ne(ne);
|
|
|
|
|
|
|
|
put_device(dev);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void nodemgr_node_probe(struct host_info *hi, int generation)
|
|
|
|
{
|
|
|
|
struct hpsb_host *host = hi->host;
|
2007-05-25 05:50:53 -04:00
|
|
|
struct device *dev;
|
2005-12-12 23:03:19 -05:00
|
|
|
struct node_entry *ne;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
/* Do some processing of the nodes we've probed. This pulls them
|
|
|
|
* into the sysfs layer if needed, and can result in processing of
|
|
|
|
* unit-directories, or just updating the node and it's
|
2005-12-12 23:03:19 -05:00
|
|
|
* unit-directories.
|
|
|
|
*
|
|
|
|
* Run updates before probes. Usually, updates are time-critical
|
|
|
|
* while probes are time-consuming. (Well, those probes need some
|
|
|
|
* improvement...) */
|
|
|
|
|
2006-10-22 10:16:27 -04:00
|
|
|
down(&nodemgr_ne_class.sem);
|
2007-05-25 05:50:53 -04:00
|
|
|
list_for_each_entry(dev, &nodemgr_ne_class.devices, node) {
|
|
|
|
ne = container_of(dev, struct node_entry, node_dev);
|
2005-12-12 23:03:19 -05:00
|
|
|
if (!ne->needs_probe)
|
|
|
|
nodemgr_probe_ne(hi, ne, generation);
|
|
|
|
}
|
2007-05-25 05:50:53 -04:00
|
|
|
list_for_each_entry(dev, &nodemgr_ne_class.devices, node) {
|
|
|
|
ne = container_of(dev, struct node_entry, node_dev);
|
2005-12-12 23:03:19 -05:00
|
|
|
if (ne->needs_probe)
|
|
|
|
nodemgr_probe_ne(hi, ne, generation);
|
|
|
|
}
|
2006-11-22 15:28:19 -05:00
|
|
|
up(&nodemgr_ne_class.sem);
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
|
|
|
|
/* If we had a bus reset while we were scanning the bus, it is
|
|
|
|
* possible that we did not probe all nodes. In that case, we
|
|
|
|
* skip the clean up for now, since we could remove nodes that
|
2006-07-03 12:02:35 -04:00
|
|
|
* were still on the bus. Another bus scan is pending which will
|
|
|
|
* do the clean up eventually.
|
2005-04-16 18:20:36 -04:00
|
|
|
*
|
|
|
|
* Now let's tell the bus to rescan our devices. This may seem
|
|
|
|
* like overhead, but the driver-model core will only scan a
|
|
|
|
* device for a driver when either the device is added, or when a
|
|
|
|
* new driver is added. A bus reset is a good reason to rescan
|
|
|
|
* devices that were there before. For example, an sbp2 device
|
|
|
|
* may become available for login, if the host that held it was
|
|
|
|
* just removed. */
|
|
|
|
|
|
|
|
if (generation == get_hpsb_generation(host))
|
2006-10-29 17:09:11 -05:00
|
|
|
if (bus_rescan_devices(&ieee1394_bus_type))
|
|
|
|
HPSB_DEBUG("bus_rescan_devices had an error");
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
2005-12-01 18:51:52 -05:00
|
|
|
static int nodemgr_send_resume_packet(struct hpsb_host *host)
|
|
|
|
{
|
|
|
|
struct hpsb_packet *packet;
|
2006-10-20 19:23:56 -04:00
|
|
|
int error = -ENOMEM;
|
2005-12-01 18:51:52 -05:00
|
|
|
|
|
|
|
packet = hpsb_make_phypacket(host,
|
2005-12-01 18:51:56 -05:00
|
|
|
EXTPHYPACKET_TYPE_RESUME |
|
|
|
|
NODEID_TO_NODE(host->node_id) << PHYPACKET_PORT_SHIFT);
|
2005-12-01 18:51:52 -05:00
|
|
|
if (packet) {
|
|
|
|
packet->no_waiter = 1;
|
|
|
|
packet->generation = get_hpsb_generation(host);
|
2006-10-20 19:23:56 -04:00
|
|
|
error = hpsb_send_packet(packet);
|
2005-12-01 18:51:52 -05:00
|
|
|
}
|
2006-10-20 19:23:56 -04:00
|
|
|
if (error)
|
2005-12-01 18:51:52 -05:00
|
|
|
HPSB_WARN("fw-host%d: Failed to broadcast resume packet",
|
|
|
|
host->id);
|
2006-10-20 19:23:56 -04:00
|
|
|
return error;
|
2005-12-01 18:51:52 -05:00
|
|
|
}
|
|
|
|
|
2005-12-05 16:28:59 -05:00
|
|
|
/* Perform a few high-level IRM responsibilities. */
|
2005-04-16 18:20:36 -04:00
|
|
|
static int nodemgr_do_irm_duties(struct hpsb_host *host, int cycles)
|
|
|
|
{
|
|
|
|
quadlet_t bc;
|
|
|
|
|
|
|
|
/* if irm_id == -1 then there is no IRM on this bus */
|
|
|
|
if (!host->is_irm || host->irm_id == (nodeid_t)-1)
|
|
|
|
return 1;
|
|
|
|
|
2005-12-05 16:28:59 -05:00
|
|
|
/* We are a 1394a-2000 compliant IRM. Set the validity bit. */
|
|
|
|
host->csr.broadcast_channel |= 0x40000000;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
/* If there is no bus manager then we should set the root node's
|
|
|
|
* force_root bit to promote bus stability per the 1394
|
|
|
|
* spec. (8.4.2.6) */
|
|
|
|
if (host->busmgr_id == 0xffff && host->node_count > 1)
|
|
|
|
{
|
|
|
|
u16 root_node = host->node_count - 1;
|
|
|
|
|
2005-09-30 14:59:08 -04:00
|
|
|
/* get cycle master capability flag from root node */
|
|
|
|
if (host->is_cycmst ||
|
|
|
|
(!hpsb_read(host, LOCAL_BUS | root_node, get_hpsb_generation(host),
|
|
|
|
(CSR_REGISTER_BASE + CSR_CONFIG_ROM + 2 * sizeof(quadlet_t)),
|
|
|
|
&bc, sizeof(quadlet_t)) &&
|
|
|
|
be32_to_cpu(bc) & 1 << CSR_CMC_SHIFT))
|
2005-04-16 18:20:36 -04:00
|
|
|
hpsb_send_phy_config(host, root_node, -1);
|
|
|
|
else {
|
|
|
|
HPSB_DEBUG("The root node is not cycle master capable; "
|
|
|
|
"selecting a new root node and resetting...");
|
|
|
|
|
|
|
|
if (cycles >= 5) {
|
|
|
|
/* Oh screw it! Just leave the bus as it is */
|
|
|
|
HPSB_DEBUG("Stopping reset loop for IRM sanity");
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
hpsb_send_phy_config(host, NODEID_TO_NODE(host->node_id), -1);
|
|
|
|
hpsb_reset_bus(host, LONG_RESET_FORCE_ROOT);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-12-01 18:51:52 -05:00
|
|
|
/* Some devices suspend their ports while being connected to an inactive
|
|
|
|
* host adapter, i.e. if connected before the low-level driver is
|
|
|
|
* loaded. They become visible either when physically unplugged and
|
|
|
|
* replugged, or when receiving a resume packet. Send one once. */
|
|
|
|
if (!host->resume_packet_sent && !nodemgr_send_resume_packet(host))
|
|
|
|
host->resume_packet_sent = 1;
|
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* We need to ensure that if we are not the IRM, that the IRM node is capable of
|
|
|
|
* everything we can do, otherwise issue a bus reset and try to become the IRM
|
|
|
|
* ourselves. */
|
|
|
|
static int nodemgr_check_irm_capability(struct hpsb_host *host, int cycles)
|
|
|
|
{
|
|
|
|
quadlet_t bc;
|
|
|
|
int status;
|
|
|
|
|
|
|
|
if (hpsb_disable_irm || host->is_irm)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
status = hpsb_read(host, LOCAL_BUS | (host->irm_id),
|
|
|
|
get_hpsb_generation(host),
|
|
|
|
(CSR_REGISTER_BASE | CSR_BROADCAST_CHANNEL),
|
|
|
|
&bc, sizeof(quadlet_t));
|
|
|
|
|
|
|
|
if (status < 0 || !(be32_to_cpu(bc) & 0x80000000)) {
|
|
|
|
/* The current irm node does not have a valid BROADCAST_CHANNEL
|
|
|
|
* register and we do, so reset the bus with force_root set */
|
|
|
|
HPSB_DEBUG("Current remote IRM is not 1394a-2000 compliant, resetting...");
|
|
|
|
|
|
|
|
if (cycles >= 5) {
|
|
|
|
/* Oh screw it! Just leave the bus as it is */
|
|
|
|
HPSB_DEBUG("Stopping reset loop for IRM sanity");
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
hpsb_send_phy_config(host, NODEID_TO_NODE(host->node_id), -1);
|
|
|
|
hpsb_reset_bus(host, LONG_RESET_FORCE_ROOT);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int nodemgr_host_thread(void *__hi)
|
|
|
|
{
|
|
|
|
struct host_info *hi = (struct host_info *)__hi;
|
|
|
|
struct hpsb_host *host = hi->host;
|
2006-10-06 13:49:52 -04:00
|
|
|
unsigned int g, generation = 0;
|
2006-07-03 12:02:35 -04:00
|
|
|
int i, reset_cycles = 0;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2007-07-17 07:03:35 -04:00
|
|
|
set_freezable();
|
2005-04-16 18:20:36 -04:00
|
|
|
/* Setup our device-model entries */
|
|
|
|
nodemgr_create_host_dev_files(host);
|
|
|
|
|
2006-07-03 12:02:35 -04:00
|
|
|
for (;;) {
|
|
|
|
/* Sleep until next bus reset */
|
|
|
|
set_current_state(TASK_INTERRUPTIBLE);
|
2007-02-10 16:06:18 -05:00
|
|
|
if (get_hpsb_generation(host) == generation &&
|
|
|
|
!kthread_should_stop())
|
2006-07-03 12:02:35 -04:00
|
|
|
schedule();
|
|
|
|
__set_current_state(TASK_RUNNING);
|
|
|
|
|
|
|
|
/* Thread may have been woken up to freeze or to exit */
|
|
|
|
if (try_to_freeze())
|
|
|
|
continue;
|
|
|
|
if (kthread_should_stop())
|
|
|
|
goto exit;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
/* Pause for 1/4 second in 1/16 second intervals,
|
|
|
|
* to make sure things settle down. */
|
2006-07-03 12:02:35 -04:00
|
|
|
g = get_hpsb_generation(host);
|
2005-04-16 18:20:36 -04:00
|
|
|
for (i = 0; i < 4 ; i++) {
|
2006-07-03 12:02:35 -04:00
|
|
|
if (msleep_interruptible(63) || kthread_should_stop())
|
2007-06-17 17:47:45 -04:00
|
|
|
goto exit;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
/* Now get the generation in which the node ID's we collect
|
|
|
|
* are valid. During the bus scan we will use this generation
|
|
|
|
* for the read transactions, so that if another reset occurs
|
|
|
|
* during the scan the transactions will fail instead of
|
|
|
|
* returning bogus data. */
|
|
|
|
generation = get_hpsb_generation(host);
|
|
|
|
|
|
|
|
/* If we get a reset before we are done waiting, then
|
2007-05-09 02:57:56 -04:00
|
|
|
* start the waiting over again */
|
2006-07-03 12:02:35 -04:00
|
|
|
if (generation != g)
|
|
|
|
g = generation, i = 0;
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
2005-09-30 14:59:08 -04:00
|
|
|
if (!nodemgr_check_irm_capability(host, reset_cycles) ||
|
|
|
|
!nodemgr_do_irm_duties(host, reset_cycles)) {
|
2005-04-16 18:20:36 -04:00
|
|
|
reset_cycles++;
|
|
|
|
continue;
|
|
|
|
}
|
2005-09-30 14:59:08 -04:00
|
|
|
reset_cycles = 0;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
/* Scan our nodes to get the bus options and create node
|
|
|
|
* entries. This does not do the sysfs stuff, since that
|
2005-11-16 03:00:00 -05:00
|
|
|
* would trigger uevents and such, which is a bad idea at
|
|
|
|
* this point. */
|
2005-04-16 18:20:36 -04:00
|
|
|
nodemgr_node_scan(hi, generation);
|
|
|
|
|
|
|
|
/* This actually does the full probe, with sysfs
|
|
|
|
* registration. */
|
|
|
|
nodemgr_node_probe(hi, generation);
|
|
|
|
|
|
|
|
/* Update some of our sysfs symlinks */
|
|
|
|
nodemgr_update_host_dev_links(host);
|
|
|
|
}
|
2006-07-03 12:02:35 -04:00
|
|
|
exit:
|
2005-04-16 18:20:36 -04:00
|
|
|
HPSB_VERBOSE("NodeMgr: Exiting thread");
|
2006-07-03 12:02:35 -04:00
|
|
|
return 0;
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
2007-03-04 21:06:23 -05:00
|
|
|
/**
|
|
|
|
* nodemgr_for_each_host - call a function for each IEEE 1394 host
|
|
|
|
* @data: an address to supply to the callback
|
|
|
|
* @cb: function to call for each host
|
|
|
|
*
|
|
|
|
* Iterate the hosts, calling a given function with supplied data for each host.
|
|
|
|
* If the callback fails on a host, i.e. if it returns a non-zero value, the
|
|
|
|
* iteration is stopped.
|
|
|
|
*
|
|
|
|
* Return value: 0 on success, non-zero on failure (same as returned by last run
|
|
|
|
* of the callback).
|
|
|
|
*/
|
|
|
|
int nodemgr_for_each_host(void *data, int (*cb)(struct hpsb_host *, void *))
|
2005-04-16 18:20:36 -04:00
|
|
|
{
|
2007-05-25 05:50:53 -04:00
|
|
|
struct device *dev;
|
2005-04-16 18:20:36 -04:00
|
|
|
struct hpsb_host *host;
|
|
|
|
int error = 0;
|
|
|
|
|
2006-10-22 10:16:27 -04:00
|
|
|
down(&hpsb_host_class.sem);
|
2007-05-25 05:50:53 -04:00
|
|
|
list_for_each_entry(dev, &hpsb_host_class.devices, node) {
|
|
|
|
host = container_of(dev, struct hpsb_host, host_dev);
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2007-03-04 21:06:23 -05:00
|
|
|
if ((error = cb(host, data)))
|
2005-04-16 18:20:36 -04:00
|
|
|
break;
|
|
|
|
}
|
2006-10-22 10:16:27 -04:00
|
|
|
up(&hpsb_host_class.sem);
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2007-03-04 21:05:32 -05:00
|
|
|
/* The following two convenience functions use a struct node_entry
|
2005-04-16 18:20:36 -04:00
|
|
|
* for addressing a node on the bus. They are intended for use by any
|
|
|
|
* process context, not just the nodemgr thread, so we need to be a
|
|
|
|
* little careful when reading out the node ID and generation. The
|
|
|
|
* thing that can go wrong is that we get the node ID, then a bus
|
|
|
|
* reset occurs, and then we read the generation. The node ID is
|
|
|
|
* possibly invalid, but the generation is current, and we end up
|
|
|
|
* sending a packet to a the wrong node.
|
|
|
|
*
|
|
|
|
* The solution is to make sure we read the generation first, so that
|
|
|
|
* if a reset occurs in the process, we end up with a stale generation
|
|
|
|
* and the transactions will fail instead of silently using wrong node
|
|
|
|
* ID's.
|
|
|
|
*/
|
|
|
|
|
2007-03-04 21:06:23 -05:00
|
|
|
/**
|
|
|
|
* hpsb_node_fill_packet - fill some destination information into a packet
|
|
|
|
* @ne: destination node
|
|
|
|
* @packet: packet to fill in
|
|
|
|
*
|
|
|
|
* This will fill in the given, pre-initialised hpsb_packet with the current
|
|
|
|
* information from the node entry (host, node ID, bus generation number).
|
|
|
|
*/
|
|
|
|
void hpsb_node_fill_packet(struct node_entry *ne, struct hpsb_packet *packet)
|
2005-04-16 18:20:36 -04:00
|
|
|
{
|
2007-03-04 21:06:23 -05:00
|
|
|
packet->host = ne->host;
|
|
|
|
packet->generation = ne->generation;
|
2005-04-16 18:20:36 -04:00
|
|
|
barrier();
|
2007-03-04 21:06:23 -05:00
|
|
|
packet->node_id = ne->nodeid;
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
int hpsb_node_write(struct node_entry *ne, u64 addr,
|
|
|
|
quadlet_t *buffer, size_t length)
|
|
|
|
{
|
|
|
|
unsigned int generation = ne->generation;
|
|
|
|
|
|
|
|
barrier();
|
|
|
|
return hpsb_write(ne->host, ne->nodeid, generation,
|
|
|
|
addr, buffer, length);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void nodemgr_add_host(struct hpsb_host *host)
|
|
|
|
{
|
|
|
|
struct host_info *hi;
|
|
|
|
|
|
|
|
hi = hpsb_create_hostinfo(&nodemgr_highlevel, host, sizeof(*hi));
|
|
|
|
if (!hi) {
|
2006-07-03 12:02:35 -04:00
|
|
|
HPSB_ERR("NodeMgr: out of memory in add host");
|
2005-04-16 18:20:36 -04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
hi->host = host;
|
2006-07-03 12:02:35 -04:00
|
|
|
hi->thread = kthread_run(nodemgr_host_thread, hi, "knodemgrd_%d",
|
|
|
|
host->id);
|
|
|
|
if (IS_ERR(hi->thread)) {
|
|
|
|
HPSB_ERR("NodeMgr: cannot start thread for host %d", host->id);
|
2005-04-16 18:20:36 -04:00
|
|
|
hpsb_destroy_hostinfo(&nodemgr_highlevel, host);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void nodemgr_host_reset(struct hpsb_host *host)
|
|
|
|
{
|
|
|
|
struct host_info *hi = hpsb_get_hostinfo(&nodemgr_highlevel, host);
|
|
|
|
|
2006-07-03 12:02:35 -04:00
|
|
|
if (hi) {
|
|
|
|
HPSB_VERBOSE("NodeMgr: Processing reset for host %d", host->id);
|
|
|
|
wake_up_process(hi->thread);
|
|
|
|
}
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
static void nodemgr_remove_host(struct hpsb_host *host)
|
|
|
|
{
|
|
|
|
struct host_info *hi = hpsb_get_hostinfo(&nodemgr_highlevel, host);
|
|
|
|
|
|
|
|
if (hi) {
|
2006-07-03 12:02:35 -04:00
|
|
|
kthread_stop(hi->thread);
|
|
|
|
nodemgr_remove_host_dev(&host->device);
|
|
|
|
}
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
static struct hpsb_highlevel nodemgr_highlevel = {
|
|
|
|
.name = "Node manager",
|
|
|
|
.add_host = nodemgr_add_host,
|
|
|
|
.host_reset = nodemgr_host_reset,
|
|
|
|
.remove_host = nodemgr_remove_host,
|
|
|
|
};
|
|
|
|
|
|
|
|
int init_ieee1394_nodemgr(void)
|
|
|
|
{
|
2006-10-20 19:23:56 -04:00
|
|
|
int error;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2006-10-20 19:23:56 -04:00
|
|
|
error = class_register(&nodemgr_ne_class);
|
|
|
|
if (error)
|
2007-02-05 20:34:45 -05:00
|
|
|
goto fail_ne;
|
2006-10-20 19:23:56 -04:00
|
|
|
error = class_register(&nodemgr_ud_class);
|
2007-02-05 20:34:45 -05:00
|
|
|
if (error)
|
|
|
|
goto fail_ud;
|
2006-11-22 15:09:42 -05:00
|
|
|
error = driver_register(&nodemgr_mid_layer_driver);
|
2007-02-05 20:34:45 -05:00
|
|
|
if (error)
|
|
|
|
goto fail_ml;
|
|
|
|
/* This driver is not used if nodemgr is off (disable_nodemgr=1). */
|
|
|
|
nodemgr_dev_template_host.driver = &nodemgr_mid_layer_driver;
|
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
hpsb_register_highlevel(&nodemgr_highlevel);
|
|
|
|
return 0;
|
2007-02-05 20:34:45 -05:00
|
|
|
|
|
|
|
fail_ml:
|
|
|
|
class_unregister(&nodemgr_ud_class);
|
|
|
|
fail_ud:
|
|
|
|
class_unregister(&nodemgr_ne_class);
|
|
|
|
fail_ne:
|
|
|
|
return error;
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void cleanup_ieee1394_nodemgr(void)
|
|
|
|
{
|
2006-11-22 15:28:19 -05:00
|
|
|
hpsb_unregister_highlevel(&nodemgr_highlevel);
|
2007-02-05 20:34:45 -05:00
|
|
|
driver_unregister(&nodemgr_mid_layer_driver);
|
2005-04-16 18:20:36 -04:00
|
|
|
class_unregister(&nodemgr_ud_class);
|
|
|
|
class_unregister(&nodemgr_ne_class);
|
|
|
|
}
|