nodemgr.c 51.2 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10
/*
 * 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.
 */

11
#include <linux/bitmap.h>
L
Linus Torvalds 已提交
12 13 14 15
#include <linux/kernel.h>
#include <linux/list.h>
#include <linux/slab.h>
#include <linux/delay.h>
16
#include <linux/kthread.h>
17
#include <linux/module.h>
L
Linus Torvalds 已提交
18
#include <linux/moduleparam.h>
S
Stefan Richter 已提交
19
#include <linux/mutex.h>
20
#include <linux/freezer.h>
21
#include <linux/semaphore.h>
L
Linus Torvalds 已提交
22 23
#include <asm/atomic.h>

24 25 26
#include "csr.h"
#include "highlevel.h"
#include "hosts.h"
L
Linus Torvalds 已提交
27 28
#include "ieee1394.h"
#include "ieee1394_core.h"
29 30
#include "ieee1394_hotplug.h"
#include "ieee1394_types.h"
L
Linus Torvalds 已提交
31 32 33
#include "ieee1394_transactions.h"
#include "nodemgr.h"

B
Ben Collins 已提交
34
static int ignore_drivers;
35
module_param(ignore_drivers, int, S_IRUGO | S_IWUSR);
L
Linus Torvalds 已提交
36 37 38 39 40 41
MODULE_PARM_DESC(ignore_drivers, "Disable automatic probing for drivers.");

struct nodemgr_csr_info {
	struct hpsb_host *host;
	nodeid_t nodeid;
	unsigned int generation;
42
	unsigned int speed_unverified:1;
L
Linus Torvalds 已提交
43 44 45
};


46 47 48 49 50 51 52 53 54 55 56
/*
 * 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;
57
	int error;
58

59
	speed = &(ci->host->speed[NODEID_TO_NODE(ci->nodeid)]);
60 61 62 63 64 65 66 67 68
	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;
69
		error = hpsb_read(ci->host, ci->nodeid, ci->generation, addr,
70
				  &q, 4);
71
		if (error)
72 73 74 75 76 77 78 79 80 81 82 83 84
			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;
85
	return error;
86
}
L
Linus Torvalds 已提交
87

88
static int nodemgr_bus_read(struct csr1212_csr *csr, u64 addr,
S
Stefan Richter 已提交
89
			    void *buffer, void *__ci)
L
Linus Torvalds 已提交
90 91
{
	struct nodemgr_csr_info *ci = (struct nodemgr_csr_info*)__ci;
92
	int i, error;
L
Linus Torvalds 已提交
93

94
	for (i = 1; ; i++) {
95
		error = hpsb_read(ci->host, ci->nodeid, ci->generation, addr,
96
				  buffer, 4);
97
		if (!error) {
98 99 100 101 102
			ci->speed_unverified = 0;
			break;
		}
		/* Give up after 3rd failure. */
		if (i == 3)
L
Linus Torvalds 已提交
103 104
			break;

105 106
		/* The ieee1394_core guessed the node's speed capability from
		 * the self ID.  Check whether a lower speed works. */
107
		if (ci->speed_unverified) {
108 109
			error = nodemgr_check_speed(ci, addr, buffer);
			if (!error)
110 111
				break;
		}
L
Linus Torvalds 已提交
112 113 114
		if (msleep_interruptible(334))
			return -EINTR;
	}
115
	return error;
L
Linus Torvalds 已提交
116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145
}

static struct csr1212_bus_ops nodemgr_csr_ops = {
	.bus_read =	nodemgr_bus_read,
};


/*
 * 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;
146
	struct task_struct *thread;
L
Linus Torvalds 已提交
147 148 149
};

static int nodemgr_bus_match(struct device * dev, struct device_driver * drv);
150
static int nodemgr_uevent(struct device *dev, struct kobj_uevent_env *env);
L
Linus Torvalds 已提交
151 152 153 154 155 156

struct bus_type ieee1394_bus_type = {
	.name		= "ieee1394",
	.match		= nodemgr_bus_match,
};

157
static void host_cls_release(struct device *dev)
L
Linus Torvalds 已提交
158
{
159
	put_device(&container_of((dev), struct hpsb_host, host_dev)->device);
L
Linus Torvalds 已提交
160 161 162 163
}

struct class hpsb_host_class = {
	.name		= "ieee1394_host",
164
	.dev_release	= host_cls_release,
L
Linus Torvalds 已提交
165 166
};

167
static void ne_cls_release(struct device *dev)
L
Linus Torvalds 已提交
168
{
169
	put_device(&container_of((dev), struct node_entry, node_dev)->device);
L
Linus Torvalds 已提交
170 171 172 173
}

static struct class nodemgr_ne_class = {
	.name		= "ieee1394_node",
174
	.dev_release	= ne_cls_release,
L
Linus Torvalds 已提交
175 176
};

177
static void ud_cls_release(struct device *dev)
L
Linus Torvalds 已提交
178
{
179
	put_device(&container_of((dev), struct unit_directory, unit_dev)->device);
L
Linus Torvalds 已提交
180 181 182
}

/* The name here is only so that unit directory hotplug works with old
183 184
 * style hotplug, which only ever did unit directories anyway.
 */
L
Linus Torvalds 已提交
185 186
static struct class nodemgr_ud_class = {
	.name		= "ieee1394",
187 188
	.dev_release	= ud_cls_release,
	.dev_uevent	= nodemgr_uevent,
L
Linus Torvalds 已提交
189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238
};

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,
};

239 240 241 242 243 244 245 246 247 248
/* 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,
};

L
Linus Torvalds 已提交
249 250 251 252 253 254 255
struct device nodemgr_dev_template_host = {
	.bus		= &ieee1394_bus_type,
	.release	= nodemgr_release_host,
};


#define fw_attr(class, class_type, field, type, format_string)		\
256
static ssize_t fw_show_##class##_##field (struct device *dev, struct device_attribute *attr, char *buf)\
L
Linus Torvalds 已提交
257 258 259 260 261 262 263 264 265 266 267
{									\
	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)				\
268
static ssize_t fw_show_##class##_##td_kv (struct device *dev, struct device_attribute *attr, char *buf)\
L
Linus Torvalds 已提交
269 270 271 272 273 274 275
{									\
	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);							\
A
Al Viro 已提交
276
	while (buf[len - 1] == '\0')					\
L
Linus Torvalds 已提交
277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295
		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 = {	\
S
Stefan Richter 已提交
296 297
	.attr = {.name = __stringify(field), .mode = S_IRUGO },	\
	.show   = fw_drv_show_##field,				\
L
Linus Torvalds 已提交
298 299 300
};


301
static ssize_t fw_show_ne_bus_options(struct device *dev, struct device_attribute *attr, char *buf)
L
Linus Torvalds 已提交
302 303 304 305 306 307 308 309 310 311 312 313 314 315 316
{
	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);


317 318 319
#ifdef HPSB_DEBUG_TLABELS
static ssize_t fw_show_ne_tlabels_free(struct device *dev,
				       struct device_attribute *attr, char *buf)
L
Linus Torvalds 已提交
320 321
{
	struct node_entry *ne = container_of(dev, struct node_entry, device);
322 323 324
	unsigned long flags;
	unsigned long *tp = ne->host->tl_pool[NODEID_TO_NODE(ne->nodeid)].map;
	int tf;
L
Linus Torvalds 已提交
325

326 327 328
	spin_lock_irqsave(&hpsb_tlabel_lock, flags);
	tf = 64 - bitmap_weight(tp, 64);
	spin_unlock_irqrestore(&hpsb_tlabel_lock, flags);
L
Linus Torvalds 已提交
329

330
	return sprintf(buf, "%d\n", tf);
L
Linus Torvalds 已提交
331
}
332
static DEVICE_ATTR(tlabels_free,S_IRUGO,fw_show_ne_tlabels_free,NULL);
L
Linus Torvalds 已提交
333 334


335 336
static ssize_t fw_show_ne_tlabels_mask(struct device *dev,
				       struct device_attribute *attr, char *buf)
L
Linus Torvalds 已提交
337 338
{
	struct node_entry *ne = container_of(dev, struct node_entry, device);
339 340 341 342 343
	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);
L
Linus Torvalds 已提交
344
#if (BITS_PER_LONG <= 32)
345
	tm = ((u64)tp[0] << 32) + tp[1];
L
Linus Torvalds 已提交
346
#else
347
	tm = tp[0];
L
Linus Torvalds 已提交
348
#endif
349 350
	spin_unlock_irqrestore(&hpsb_tlabel_lock, flags);

R
Randy Dunlap 已提交
351
	return sprintf(buf, "0x%016llx\n", (unsigned long long)tm);
L
Linus Torvalds 已提交
352 353
}
static DEVICE_ATTR(tlabels_mask, S_IRUGO, fw_show_ne_tlabels_mask, NULL);
354
#endif /* HPSB_DEBUG_TLABELS */
L
Linus Torvalds 已提交
355 356


357
static ssize_t fw_set_ignore_driver(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
L
Linus Torvalds 已提交
358 359 360 361 362 363
{
	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;
364 365
		device_release_driver(dev);
	} else if (state == 0)
L
Linus Torvalds 已提交
366 367 368 369
		ud->ignore_driver = 0;

	return count;
}
370
static ssize_t fw_get_ignore_driver(struct device *dev, struct device_attribute *attr, char *buf)
L
Linus Torvalds 已提交
371 372 373 374 375 376 377 378
{
	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);


S
Stefan Richter 已提交
379 380
static ssize_t fw_set_rescan(struct bus_type *bus, const char *buf,
			     size_t count)
L
Linus Torvalds 已提交
381
{
S
Stefan Richter 已提交
382 383
	int error = 0;

384
	if (simple_strtoul(buf, NULL, 10) == 1)
S
Stefan Richter 已提交
385 386
		error = bus_rescan_devices(&ieee1394_bus_type);
	return error ? error : count;
L
Linus Torvalds 已提交
387 388 389 390 391 392 393 394 395 396 397 398 399 400 401
}
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;
402
	else if (state == 0)
L
Linus Torvalds 已提交
403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437
		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_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,
438
#ifdef HPSB_DEBUG_TLABELS
L
Linus Torvalds 已提交
439 440
	&dev_attr_tlabels_free,
	&dev_attr_tlabels_mask,
441
#endif
L
Linus Torvalds 已提交
442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490
};



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;

S
Stefan Richter 已提交
491
	driver = container_of(drv, struct hpsb_protocol_driver, driver);
492 493 494
	id = driver->id_table;
	if (!id)
		return 0;
L
Linus Torvalds 已提交
495

496
	for (; id->match_flags != 0; id++) {
L
Linus Torvalds 已提交
497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550
		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++)
S
Stefan Richter 已提交
551 552 553 554
		if (driver_create_file(drv, fw_drv_attrs[i]))
			goto fail;
	return;
fail:
555
	HPSB_ERR("Failed to add sysfs attribute");
L
Linus Torvalds 已提交
556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574
}


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++)
S
Stefan Richter 已提交
575 576 577 578
		if (device_create_file(dev, fw_ne_attrs[i]))
			goto fail;
	return;
fail:
579
	HPSB_ERR("Failed to add sysfs attribute");
L
Linus Torvalds 已提交
580 581 582 583 584 585 586 587 588
}


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++)
S
Stefan Richter 已提交
589 590 591 592
		if (device_create_file(dev, fw_host_attrs[i]))
			goto fail;
	return;
fail:
593
	HPSB_ERR("Failed to add sysfs attribute");
L
Linus Torvalds 已提交
594 595 596
}


S
Stefan Richter 已提交
597 598
static struct node_entry *find_entry_by_nodeid(struct hpsb_host *host,
					       nodeid_t nodeid);
L
Linus Torvalds 已提交
599 600 601 602 603 604 605 606 607 608

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");

S
Stefan Richter 已提交
609 610 611 612 613 614 615 616 617 618 619 620
	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);
L
Linus Torvalds 已提交
621 622 623 624 625 626 627 628
}

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++)
S
Stefan Richter 已提交
629 630
		if (device_create_file(dev, fw_ud_attrs[i]))
			goto fail;
L
Linus Torvalds 已提交
631
	if (ud->flags & UNIT_DIRECTORY_SPECIFIER_ID)
S
Stefan Richter 已提交
632 633
		if (device_create_file(dev, &dev_attr_ud_specifier_id))
			goto fail;
L
Linus Torvalds 已提交
634
	if (ud->flags & UNIT_DIRECTORY_VERSION)
S
Stefan Richter 已提交
635 636
		if (device_create_file(dev, &dev_attr_ud_version))
			goto fail;
L
Linus Torvalds 已提交
637
	if (ud->flags & UNIT_DIRECTORY_VENDOR_ID) {
S
Stefan Richter 已提交
638 639 640 641 642
		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;
L
Linus Torvalds 已提交
643 644
	}
	if (ud->flags & UNIT_DIRECTORY_MODEL_ID) {
S
Stefan Richter 已提交
645 646 647 648 649
		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;
L
Linus Torvalds 已提交
650
	}
S
Stefan Richter 已提交
651 652
	return;
fail:
653
	HPSB_ERR("Failed to add sysfs attribute");
L
Linus Torvalds 已提交
654 655 656 657 658
}


static int nodemgr_bus_match(struct device * dev, struct device_driver * drv)
{
S
Stefan Richter 已提交
659 660
	struct hpsb_protocol_driver *driver;
	struct unit_directory *ud;
L
Linus Torvalds 已提交
661 662 663 664 665 666 667 668 669 670
	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;

671 672 673 674 675
	/* 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);
676 677 678 679 680
	id = driver->id_table;
	if (!id)
		return 0;

	for (; id->match_flags != 0; id++) {
S
Stefan Richter 已提交
681 682 683
		if ((id->match_flags & IEEE1394_MATCH_VENDOR_ID) &&
		    id->vendor_id != ud->vendor_id)
			continue;
L
Linus Torvalds 已提交
684

S
Stefan Richter 已提交
685 686 687
		if ((id->match_flags & IEEE1394_MATCH_MODEL_ID) &&
		    id->model_id != ud->model_id)
			continue;
L
Linus Torvalds 已提交
688

S
Stefan Richter 已提交
689 690 691
		if ((id->match_flags & IEEE1394_MATCH_SPECIFIER_ID) &&
		    id->specifier_id != ud->specifier_id)
			continue;
L
Linus Torvalds 已提交
692

S
Stefan Richter 已提交
693 694 695
		if ((id->match_flags & IEEE1394_MATCH_VERSION) &&
		    id->version != ud->version)
			continue;
L
Linus Torvalds 已提交
696 697

		return 1;
S
Stefan Richter 已提交
698
	}
L
Linus Torvalds 已提交
699 700 701 702 703

	return 0;
}


704 705
static DEFINE_MUTEX(nodemgr_serialize_remove_uds);

706
static int match_ne(struct device *dev, void *data)
D
Dave Young 已提交
707 708
{
	struct unit_directory *ud;
709
	struct node_entry *ne = data;
D
Dave Young 已提交
710 711 712 713 714

	ud = container_of(dev, struct unit_directory, unit_dev);
	return ud->ne == ne;
}

L
Linus Torvalds 已提交
715 716
static void nodemgr_remove_uds(struct node_entry *ne)
{
717
	struct device *dev;
D
Dave Young 已提交
718 719 720 721 722
	struct unit_directory *ud;

	/* Use class_find device to iterate the devices. Since this code
	 * may be called from other contexts besides the knodemgrds,
	 * protect it by nodemgr_serialize_remove_uds.
723 724
	 */
	mutex_lock(&nodemgr_serialize_remove_uds);
725
	for (;;) {
726
		dev = class_find_device(&nodemgr_ud_class, NULL, ne, match_ne);
D
Dave Young 已提交
727
		if (!dev)
728
			break;
D
Dave Young 已提交
729 730
		ud = container_of(dev, struct unit_directory, unit_dev);
		put_device(dev);
731
		device_unregister(&ud->unit_dev);
732
		device_unregister(&ud->device);
733 734
	}
	mutex_unlock(&nodemgr_serialize_remove_uds);
L
Linus Torvalds 已提交
735 736 737 738 739
}


static void nodemgr_remove_ne(struct node_entry *ne)
{
740
	struct device *dev;
L
Linus Torvalds 已提交
741 742 743 744 745 746 747 748 749

	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);

750
	device_unregister(&ne->node_dev);
L
Linus Torvalds 已提交
751 752 753 754 755
	device_unregister(dev);

	put_device(dev);
}

756
static int remove_host_dev(struct device *dev, void *data)
757
{
758 759 760
	if (dev->bus == &ieee1394_bus_type)
		nodemgr_remove_ne(container_of(dev, struct node_entry,
				  device));
761 762
	return 0;
}
L
Linus Torvalds 已提交
763 764 765

static void nodemgr_remove_host_dev(struct device *dev)
{
766
	device_for_each_child(dev, NULL, remove_host_dev);
L
Linus Torvalds 已提交
767 768 769 770 771 772 773 774 775 776 777 778 779
	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]);

S
Stefan Richter 已提交
780 781 782 783 784 785 786
	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);
L
Linus Torvalds 已提交
787
	ne->busopt.max_rom	= (busoptions >> 8) & 0x3;
S
Stefan Richter 已提交
788 789
	ne->busopt.generation	= (busoptions >> 4) & 0xf;
	ne->busopt.lnkspd	= busoptions & 0x7;
L
Linus Torvalds 已提交
790 791 792 793 794 795 796 797 798 799 800

	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);
}


801 802 803
static struct node_entry *nodemgr_create_node(octlet_t guid,
				struct csr1212_csr *csr, struct hpsb_host *host,
				nodeid_t nodeid, unsigned int generation)
L
Linus Torvalds 已提交
804
{
S
Stefan Richter 已提交
805
	struct node_entry *ne;
L
Linus Torvalds 已提交
806

S
Stefan Richter 已提交
807 808
	ne = kzalloc(sizeof(*ne), GFP_KERNEL);
	if (!ne)
S
Stefan Richter 已提交
809
		goto fail_alloc;
L
Linus Torvalds 已提交
810

S
Stefan Richter 已提交
811 812
	ne->host = host;
	ne->nodeid = nodeid;
L
Linus Torvalds 已提交
813
	ne->generation = generation;
814
	ne->needs_probe = true;
L
Linus Torvalds 已提交
815

S
Stefan Richter 已提交
816
	ne->guid = guid;
L
Linus Torvalds 已提交
817 818 819 820 821 822
	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;
823
	dev_set_name(&ne->device, "%016Lx", (unsigned long long)(ne->guid));
L
Linus Torvalds 已提交
824

825 826
	ne->node_dev.parent = &ne->device;
	ne->node_dev.class = &nodemgr_ne_class;
827
	dev_set_name(&ne->node_dev, "%016Lx", (unsigned long long)(ne->guid));
L
Linus Torvalds 已提交
828

S
Stefan Richter 已提交
829 830
	if (device_register(&ne->device))
		goto fail_devreg;
831
	if (device_register(&ne->node_dev))
S
Stefan Richter 已提交
832
		goto fail_classdevreg;
L
Linus Torvalds 已提交
833 834 835 836 837 838 839 840 841 842
	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);

S
Stefan Richter 已提交
843
	return ne;
S
Stefan Richter 已提交
844 845 846 847 848 849 850 851 852 853

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;
L
Linus Torvalds 已提交
854 855
}

856
static int match_ne_guid(struct device *dev, void *data)
D
Dave Young 已提交
857 858
{
	struct node_entry *ne;
859
	u64 *guid = data;
D
Dave Young 已提交
860 861 862 863

	ne = container_of(dev, struct node_entry, node_dev);
	return ne->guid == *guid;
}
L
Linus Torvalds 已提交
864 865 866

static struct node_entry *find_entry_by_guid(u64 guid)
{
867
	struct device *dev;
D
Dave Young 已提交
868
	struct node_entry *ne;
L
Linus Torvalds 已提交
869

870
	dev = class_find_device(&nodemgr_ne_class, NULL, &guid, match_ne_guid);
D
Dave Young 已提交
871 872 873 874
	if (!dev)
		return NULL;
	ne = container_of(dev, struct node_entry, node_dev);
	put_device(dev);
L
Linus Torvalds 已提交
875

D
Dave Young 已提交
876
	return ne;
L
Linus Torvalds 已提交
877 878
}

879
struct match_nodeid_parameter {
D
Dave Young 已提交
880 881 882 883
	struct hpsb_host *host;
	nodeid_t nodeid;
};

884
static int match_ne_nodeid(struct device *dev, void *data)
D
Dave Young 已提交
885 886 887
{
	int found = 0;
	struct node_entry *ne;
888
	struct match_nodeid_parameter *p = data;
D
Dave Young 已提交
889 890 891 892

	if (!dev)
		goto ret;
	ne = container_of(dev, struct node_entry, node_dev);
893
	if (ne->host == p->host && ne->nodeid == p->nodeid)
D
Dave Young 已提交
894 895 896 897
		found = 1;
ret:
	return found;
}
L
Linus Torvalds 已提交
898

899 900
static struct node_entry *find_entry_by_nodeid(struct hpsb_host *host,
					       nodeid_t nodeid)
L
Linus Torvalds 已提交
901
{
902
	struct device *dev;
D
Dave Young 已提交
903
	struct node_entry *ne;
904
	struct match_nodeid_parameter p;
L
Linus Torvalds 已提交
905

906 907
	p.host = host;
	p.nodeid = nodeid;
L
Linus Torvalds 已提交
908

909
	dev = class_find_device(&nodemgr_ne_class, NULL, &p, match_ne_nodeid);
D
Dave Young 已提交
910 911 912 913
	if (!dev)
		return NULL;
	ne = container_of(dev, struct node_entry, node_dev);
	put_device(dev);
L
Linus Torvalds 已提交
914

D
Dave Young 已提交
915
	return ne;
L
Linus Torvalds 已提交
916 917 918 919 920 921 922 923 924 925 926
}


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;

927
	dev_set_name(&ud->device, "%s-%u", dev_name(&ne->device), ud->id);
L
Linus Torvalds 已提交
928

929 930
	ud->unit_dev.parent = &ud->device;
	ud->unit_dev.class = &nodemgr_ud_class;
931
	dev_set_name(&ud->unit_dev, "%s-%u", dev_name(&ne->device), ud->id);
L
Linus Torvalds 已提交
932

S
Stefan Richter 已提交
933 934
	if (device_register(&ud->device))
		goto fail_devreg;
935
	if (device_register(&ud->unit_dev))
S
Stefan Richter 已提交
936
		goto fail_classdevreg;
L
Linus Torvalds 已提交
937 938 939
	get_device(&ud->device);

	nodemgr_create_ud_dev_files(ud);
S
Stefan Richter 已提交
940 941 942 943 944 945

	return;

fail_classdevreg:
	device_unregister(&ud->device);
fail_devreg:
946
	HPSB_ERR("Failed to create unit %s", dev_name(&ud->device));
L
Linus Torvalds 已提交
947 948 949 950 951 952 953
}	


/* 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
954
	(struct node_entry *ne, struct csr1212_keyval *ud_kv,
L
Linus Torvalds 已提交
955 956 957 958 959 960 961 962
	 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;

S
Stefan Richter 已提交
963
	ud = kzalloc(sizeof(*ud), GFP_KERNEL);
L
Linus Torvalds 已提交
964 965 966 967 968
	if (!ud)
		goto unit_directory_error;

	ud->ne = ne;
	ud->ignore_driver = ignore_drivers;
969
	ud->address = ud_kv->offset + CSR1212_REGISTER_SPACE_BASE;
970
	ud->directory_id = ud->address & 0xffffff;
L
Linus Torvalds 已提交
971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007
	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:
					csr1212_keep_keyval(kv);
1008
					ud->vendor_name_kv = kv;
L
Linus Torvalds 已提交
1009 1010 1011 1012
					break;

				case CSR1212_KV_ID_MODEL:
					csr1212_keep_keyval(kv);
1013
					ud->model_name_kv = kv;
L
Linus Torvalds 已提交
1014 1015 1016 1017 1018 1019 1020 1021 1022 1023
					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) {
1024
					ud_child = kmemdup(ud, sizeof(*ud_child), GFP_KERNEL);
L
Linus Torvalds 已提交
1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046
					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 */
1047
				ud_child = nodemgr_process_unit_directory(ne, kv, id, ud);
L
Linus Torvalds 已提交
1048 1049 1050 1051

				if (ud_child == NULL)
					break;
				
1052
				/* inherit unspecified values, the driver core picks it up */
L
Linus Torvalds 已提交
1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078
				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;

1079 1080 1081 1082
		case CSR1212_KV_ID_DIRECTORY_ID:
			ud->directory_id = kv->value.immediate;
			break;

L
Linus Torvalds 已提交
1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095
		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:
1096
	kfree(ud);
L
Linus Torvalds 已提交
1097 1098 1099 1100
	return NULL;
}


1101
static void nodemgr_process_root_directory(struct node_entry *ne)
L
Linus Torvalds 已提交
1102 1103 1104
{
	unsigned int ud_id = 0;
	struct csr1212_dentry *dentry;
1105
	struct csr1212_keyval *kv, *vendor_name_kv = NULL;
L
Linus Torvalds 已提交
1106 1107
	u8 last_key_id = 0;

1108
	ne->needs_probe = false;
L
Linus Torvalds 已提交
1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120

	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:
1121
			nodemgr_process_unit_directory(ne, kv, &ud_id, NULL);
L
Linus Torvalds 已提交
1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132
			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) {
					csr1212_keep_keyval(kv);
1133
					vendor_name_kv = kv;
L
Linus Torvalds 已提交
1134 1135 1136 1137 1138 1139 1140
				}
			}
			break;
		}
		last_key_id = kv->key.id;
	}

1141
	if (ne->vendor_name_kv) {
1142 1143 1144 1145 1146 1147 1148
		kv = ne->vendor_name_kv;
		ne->vendor_name_kv = vendor_name_kv;
		csr1212_release_keyval(kv);
	} else if (vendor_name_kv) {
		ne->vendor_name_kv = vendor_name_kv;
		if (device_create_file(&ne->device,
				       &dev_attr_ne_vendor_name_kv) != 0)
1149
			HPSB_ERR("Failed to add sysfs attribute");
1150
	}
L
Linus Torvalds 已提交
1151 1152 1153 1154
}

#ifdef CONFIG_HOTPLUG

1155
static int nodemgr_uevent(struct device *dev, struct kobj_uevent_env *env)
L
Linus Torvalds 已提交
1156 1157
{
	struct unit_directory *ud;
1158
	int retval = 0;
1159 1160
	/* ieee1394:venNmoNspNverN */
	char buf[8 + 1 + 3 + 8 + 2 + 8 + 2 + 8 + 3 + 8 + 1];
L
Linus Torvalds 已提交
1161

1162
	if (!dev)
L
Linus Torvalds 已提交
1163 1164
		return -ENODEV;

1165
	ud = container_of(dev, struct unit_directory, unit_dev);
L
Linus Torvalds 已提交
1166 1167 1168 1169 1170 1171

	if (ud->ne->in_limbo || ud->ignore_driver)
		return -ENODEV;

#define PUT_ENVP(fmt,val) 					\
do {								\
1172
	retval = add_uevent_var(env, fmt, val);		\
1173 1174
	if (retval)						\
		return retval;					\
L
Linus Torvalds 已提交
1175 1176 1177 1178 1179 1180 1181
} 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);
1182 1183 1184 1185 1186 1187
	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);
L
Linus Torvalds 已提交
1188 1189 1190 1191 1192 1193 1194 1195

#undef PUT_ENVP

	return 0;
}

#else

1196
static int nodemgr_uevent(struct device *dev, struct kobj_uevent_env *env)
L
Linus Torvalds 已提交
1197 1198 1199 1200 1201 1202 1203
{
	return -ENODEV;
}

#endif /* CONFIG_HOTPLUG */


1204 1205
int __hpsb_register_protocol(struct hpsb_protocol_driver *drv,
			     struct module *owner)
L
Linus Torvalds 已提交
1206
{
1207 1208 1209 1210 1211 1212
	int error;

	drv->driver.bus = &ieee1394_bus_type;
	drv->driver.owner = owner;
	drv->driver.name = drv->name;

L
Linus Torvalds 已提交
1213
	/* This will cause a probe for devices */
1214
	error = driver_register(&drv->driver);
1215
	if (!error)
1216
		nodemgr_create_drv_files(drv);
1217
	return error;
L
Linus Torvalds 已提交
1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236
}

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,
1237
				nodeid_t nodeid, unsigned int generation)
L
Linus Torvalds 已提交
1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257
{
	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 */
1258
		ne->needs_probe = true;
L
Linus Torvalds 已提交
1259 1260 1261 1262 1263 1264 1265 1266 1267
	} 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);
	}

1268 1269
	/* Finally, mark the node current */
	smp_wmb();
L
Linus Torvalds 已提交
1270 1271
	ne->generation = generation;

1272 1273 1274
	if (ne->in_limbo) {
		device_remove_file(&ne->device, &dev_attr_ne_in_limbo);
		ne->in_limbo = false;
L
Linus Torvalds 已提交
1275

1276 1277 1278 1279 1280 1281
		HPSB_DEBUG("Node reactivated: "
			   "ID:BUS[" NODE_BUS_FMT "]  GUID[%016Lx]",
			   NODE_BUS_ARGS(ne->host, ne->nodeid),
			   (unsigned long long)ne->guid);
	}
}
L
Linus Torvalds 已提交
1282

1283
static void nodemgr_node_scan_one(struct hpsb_host *host,
L
Linus Torvalds 已提交
1284 1285 1286 1287 1288 1289
				  nodeid_t nodeid, int generation)
{
	struct node_entry *ne;
	octlet_t guid;
	struct csr1212_csr *csr;
	struct nodemgr_csr_info *ci;
1290
	u8 *speed;
L
Linus Torvalds 已提交
1291

S
Stefan Richter 已提交
1292
	ci = kmalloc(sizeof(*ci), GFP_KERNEL);
L
Linus Torvalds 已提交
1293 1294 1295 1296 1297 1298
	if (!ci)
		return;

	ci->host = host;
	ci->nodeid = nodeid;
	ci->generation = generation;
1299 1300 1301 1302 1303 1304

	/* 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;
L
Linus Torvalds 已提交
1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340

	/* 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)
1341
		nodemgr_create_node(guid, csr, host, nodeid, generation);
L
Linus Torvalds 已提交
1342
	else
1343
		nodemgr_update_node(ne, csr, nodeid, generation);
L
Linus Torvalds 已提交
1344 1345 1346
}


1347
static void nodemgr_node_scan(struct hpsb_host *host, int generation)
L
Linus Torvalds 已提交
1348
{
S
Stefan Richter 已提交
1349 1350 1351
	int count;
	struct selfid *sid = (struct selfid *)host->topology_map;
	nodeid_t nodeid = LOCAL_BUS;
L
Linus Torvalds 已提交
1352

S
Stefan Richter 已提交
1353 1354 1355 1356
	/* Scan each node on the bus */
	for (count = host->selfid_count; count; count--, sid++) {
		if (sid->extended)
			continue;
L
Linus Torvalds 已提交
1357

S
Stefan Richter 已提交
1358 1359 1360 1361
		if (!sid->link_active) {
			nodeid++;
			continue;
		}
1362
		nodemgr_node_scan_one(host, nodeid++, generation);
S
Stefan Richter 已提交
1363
	}
L
Linus Torvalds 已提交
1364 1365
}

1366 1367
static void nodemgr_pause_ne(struct node_entry *ne)
{
1368
	HPSB_DEBUG("Node paused: ID:BUS[" NODE_BUS_FMT "]  GUID[%016Lx]",
1369 1370 1371
		   NODE_BUS_ARGS(ne->host, ne->nodeid),
		   (unsigned long long)ne->guid);

1372
	ne->in_limbo = true;
1373
	WARN_ON(device_create_file(&ne->device, &dev_attr_ne_in_limbo));
L
Linus Torvalds 已提交
1374 1375
}

1376
static int update_pdrv(struct device *dev, void *data)
L
Linus Torvalds 已提交
1377 1378
{
	struct unit_directory *ud;
1379
	struct device_driver *drv;
L
Linus Torvalds 已提交
1380
	struct hpsb_protocol_driver *pdrv;
1381
	struct node_entry *ne = data;
1382
	int error;
L
Linus Torvalds 已提交
1383

D
Dave Young 已提交
1384 1385
	ud = container_of(dev, struct unit_directory, unit_dev);
	if (ud->ne == ne) {
1386
		drv = get_driver(ud->device.driver);
D
Dave Young 已提交
1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398
		if (drv) {
			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);
			}
			if (error)
				device_release_driver(&ud->device);
			put_driver(drv);
L
Linus Torvalds 已提交
1399 1400
		}
	}
D
Dave Young 已提交
1401 1402 1403 1404 1405 1406

	return 0;
}

static void nodemgr_update_pdrv(struct node_entry *ne)
{
1407
	class_for_each_device(&nodemgr_ud_class, NULL, ne, update_pdrv);
L
Linus Torvalds 已提交
1408 1409
}

1410 1411 1412 1413 1414 1415 1416 1417 1418 1419
/* 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;
1420
	int error;
1421 1422 1423 1424 1425 1426 1427 1428

	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. */
1429 1430 1431
	error = hpsb_read(ne->host, ne->nodeid, generation, bc_addr, &bc_remote,
			  sizeof(bc_remote));
	if (!error && bc_remote & cpu_to_be32(0x80000000) &&
1432 1433 1434 1435 1436
	    bc_remote != bc_local)
		hpsb_node_write(ne, bc_addr, &bc_local, sizeof(bc_local));
}


1437 1438
static void nodemgr_probe_ne(struct hpsb_host *host, struct node_entry *ne,
			     int generation)
L
Linus Torvalds 已提交
1439 1440 1441
{
	struct device *dev;

1442
	if (ne->host != host || ne->in_limbo)
L
Linus Torvalds 已提交
1443 1444 1445 1446 1447 1448
		return;

	dev = get_device(&ne->device);
	if (!dev)
		return;

1449 1450
	nodemgr_irm_write_bc(ne, generation);

L
Linus Torvalds 已提交
1451 1452 1453 1454 1455 1456
	/* 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)
1457
		nodemgr_process_root_directory(ne);
L
Linus Torvalds 已提交
1458 1459 1460
	else if (ne->generation == generation)
		nodemgr_update_pdrv(ne);
	else
1461
		nodemgr_pause_ne(ne);
L
Linus Torvalds 已提交
1462 1463 1464 1465

	put_device(dev);
}

1466 1467
struct node_probe_parameter {
	struct hpsb_host *host;
D
Dave Young 已提交
1468
	int generation;
1469
	bool probe_now;
D
Dave Young 已提交
1470 1471
};

1472
static int node_probe(struct device *dev, void *data)
D
Dave Young 已提交
1473
{
1474
	struct node_probe_parameter *p = data;
D
Dave Young 已提交
1475 1476
	struct node_entry *ne;

1477
	if (p->generation != get_hpsb_generation(p->host))
1478 1479
		return -EAGAIN;

D
Dave Young 已提交
1480
	ne = container_of(dev, struct node_entry, node_dev);
1481
	if (ne->needs_probe == p->probe_now)
1482
		nodemgr_probe_ne(p->host, ne, p->generation);
D
Dave Young 已提交
1483 1484
	return 0;
}
L
Linus Torvalds 已提交
1485

1486
static int nodemgr_node_probe(struct hpsb_host *host, int generation)
L
Linus Torvalds 已提交
1487
{
1488
	struct node_probe_parameter p;
L
Linus Torvalds 已提交
1489

1490
	p.host = host;
1491
	p.generation = generation;
1492 1493
	/*
	 * Do some processing of the nodes we've probed. This pulls them
L
Linus Torvalds 已提交
1494 1495
	 * into the sysfs layer if needed, and can result in processing of
	 * unit-directories, or just updating the node and it's
1496 1497 1498
	 * unit-directories.
	 *
	 * Run updates before probes. Usually, updates are time-critical
1499 1500 1501 1502 1503 1504
	 * while probes are time-consuming.
	 *
	 * Meanwhile, another bus reset may have happened. In this case we
	 * skip everything here and let the next bus scan handle it.
	 * Otherwise we may prematurely remove nodes which are still there.
	 */
1505
	p.probe_now = false;
1506
	if (class_for_each_device(&nodemgr_ne_class, NULL, &p, node_probe) != 0)
1507
		return 0;
L
Linus Torvalds 已提交
1508

1509 1510
	p.probe_now = true;
	if (class_for_each_device(&nodemgr_ne_class, NULL, &p, node_probe) != 0)
1511
		return 0;
1512
	/*
L
Linus Torvalds 已提交
1513 1514 1515 1516 1517 1518
	 * 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
1519 1520 1521 1522
	 * just removed.
	 */
	if (bus_rescan_devices(&ieee1394_bus_type) != 0)
		HPSB_DEBUG("bus_rescan_devices had an error");
1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543

	return 1;
}

static int remove_nodes_in_limbo(struct device *dev, void *data)
{
	struct node_entry *ne;

	if (dev->bus != &ieee1394_bus_type)
		return 0;

	ne = container_of(dev, struct node_entry, device);
	if (ne->in_limbo)
		nodemgr_remove_ne(ne);

	return 0;
}

static void nodemgr_remove_nodes_in_limbo(struct hpsb_host *host)
{
	device_for_each_child(&host->device, NULL, remove_nodes_in_limbo);
L
Linus Torvalds 已提交
1544 1545
}

1546 1547 1548
static int nodemgr_send_resume_packet(struct hpsb_host *host)
{
	struct hpsb_packet *packet;
1549
	int error = -ENOMEM;
1550 1551

	packet = hpsb_make_phypacket(host,
1552 1553
			EXTPHYPACKET_TYPE_RESUME |
			NODEID_TO_NODE(host->node_id) << PHYPACKET_PORT_SHIFT);
1554 1555 1556
	if (packet) {
		packet->no_waiter = 1;
		packet->generation = get_hpsb_generation(host);
1557
		error = hpsb_send_packet(packet);
1558
	}
1559
	if (error)
1560 1561
		HPSB_WARN("fw-host%d: Failed to broadcast resume packet",
			  host->id);
1562
	return error;
1563 1564
}

1565
/* Perform a few high-level IRM responsibilities. */
L
Linus Torvalds 已提交
1566 1567 1568 1569 1570 1571 1572 1573
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;

1574 1575
	/* We are a 1394a-2000 compliant IRM. Set the validity bit. */
	host->csr.broadcast_channel |= 0x40000000;
L
Linus Torvalds 已提交
1576 1577 1578 1579 1580 1581 1582 1583

	/* 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;

1584 1585 1586 1587 1588 1589
		/* 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))
L
Linus Torvalds 已提交
1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607
			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;
		}
	}

1608 1609 1610 1611 1612 1613 1614
	/* 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;

L
Linus Torvalds 已提交
1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653
	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;
}

1654
static int nodemgr_host_thread(void *data)
L
Linus Torvalds 已提交
1655
{
1656
	struct hpsb_host *host = data;
1657
	unsigned int g, generation = 0;
1658
	int i, reset_cycles = 0;
L
Linus Torvalds 已提交
1659

1660
	set_freezable();
L
Linus Torvalds 已提交
1661 1662 1663
	/* Setup our device-model entries */
	nodemgr_create_host_dev_files(host);

1664 1665 1666
	for (;;) {
		/* Sleep until next bus reset */
		set_current_state(TASK_INTERRUPTIBLE);
1667 1668
		if (get_hpsb_generation(host) == generation &&
		    !kthread_should_stop())
1669 1670 1671 1672 1673 1674 1675 1676
			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;
L
Linus Torvalds 已提交
1677 1678 1679

		/* Pause for 1/4 second in 1/16 second intervals,
		 * to make sure things settle down. */
1680
		g = get_hpsb_generation(host);
L
Linus Torvalds 已提交
1681
		for (i = 0; i < 4 ; i++) {
1682
			msleep_interruptible(63);
1683
			try_to_freeze();
1684
			if (kthread_should_stop())
1685
				goto exit;
L
Linus Torvalds 已提交
1686 1687 1688 1689 1690 1691 1692 1693 1694

			/* 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
1695
			 * start the waiting over again */
1696 1697
			if (generation != g)
				g = generation, i = 0;
L
Linus Torvalds 已提交
1698 1699
		}

1700 1701
		if (!nodemgr_check_irm_capability(host, reset_cycles) ||
		    !nodemgr_do_irm_duties(host, reset_cycles)) {
L
Linus Torvalds 已提交
1702 1703 1704
			reset_cycles++;
			continue;
		}
1705
		reset_cycles = 0;
L
Linus Torvalds 已提交
1706 1707 1708

		/* Scan our nodes to get the bus options and create node
		 * entries. This does not do the sysfs stuff, since that
1709 1710
		 * would trigger uevents and such, which is a bad idea at
		 * this point. */
1711
		nodemgr_node_scan(host, generation);
L
Linus Torvalds 已提交
1712 1713 1714

		/* This actually does the full probe, with sysfs
		 * registration. */
1715 1716
		if (!nodemgr_node_probe(host, generation))
			continue;
L
Linus Torvalds 已提交
1717 1718 1719

		/* Update some of our sysfs symlinks */
		nodemgr_update_host_dev_links(host);
1720 1721 1722 1723

		/* Sleep 3 seconds */
		for (i = 3000/200; i; i--) {
			msleep_interruptible(200);
1724
			try_to_freeze();
1725 1726 1727 1728 1729 1730 1731 1732 1733
			if (kthread_should_stop())
				goto exit;

			if (generation != get_hpsb_generation(host))
				break;
		}
		/* Remove nodes which are gone, unless a bus reset happened */
		if (!i)
			nodemgr_remove_nodes_in_limbo(host);
L
Linus Torvalds 已提交
1734
	}
1735
exit:
L
Linus Torvalds 已提交
1736
	HPSB_VERBOSE("NodeMgr: Exiting thread");
1737
	return 0;
L
Linus Torvalds 已提交
1738 1739
}

1740
struct per_host_parameter {
D
Dave Young 已提交
1741 1742 1743 1744
	void *data;
	int (*cb)(struct hpsb_host *, void *);
};

1745
static int per_host(struct device *dev, void *data)
D
Dave Young 已提交
1746 1747
{
	struct hpsb_host *host;
1748
	struct per_host_parameter *p = data;
D
Dave Young 已提交
1749 1750

	host = container_of(dev, struct hpsb_host, host_dev);
1751
	return p->cb(host, p->data);
D
Dave Young 已提交
1752
}
1753

1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766
/**
 * 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 *))
L
Linus Torvalds 已提交
1767
{
1768
	struct per_host_parameter p;
L
Linus Torvalds 已提交
1769

1770 1771 1772
	p.cb = cb;
	p.data = data;
	return class_for_each_device(&hpsb_host_class, NULL, &p, per_host);
L
Linus Torvalds 已提交
1773 1774
}

1775
/* The following two convenience functions use a struct node_entry
L
Linus Torvalds 已提交
1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789
 * 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.
 */

1790 1791 1792 1793 1794 1795 1796 1797 1798
/**
 * 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)
L
Linus Torvalds 已提交
1799
{
1800 1801
	packet->host = ne->host;
	packet->generation = ne->generation;
1802
	smp_rmb();
1803
	packet->node_id = ne->nodeid;
L
Linus Torvalds 已提交
1804 1805 1806 1807 1808 1809 1810
}

int hpsb_node_write(struct node_entry *ne, u64 addr,
		    quadlet_t *buffer, size_t length)
{
	unsigned int generation = ne->generation;

1811
	smp_rmb();
L
Linus Torvalds 已提交
1812 1813 1814 1815 1816 1817 1818 1819 1820 1821
	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) {
1822
		HPSB_ERR("NodeMgr: out of memory in add host");
L
Linus Torvalds 已提交
1823 1824 1825
		return;
	}
	hi->host = host;
1826
	hi->thread = kthread_run(nodemgr_host_thread, host, "knodemgrd_%d",
1827 1828 1829
				 host->id);
	if (IS_ERR(hi->thread)) {
		HPSB_ERR("NodeMgr: cannot start thread for host %d", host->id);
L
Linus Torvalds 已提交
1830 1831 1832 1833 1834 1835 1836 1837
		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);

1838 1839 1840 1841
	if (hi) {
		HPSB_VERBOSE("NodeMgr: Processing reset for host %d", host->id);
		wake_up_process(hi->thread);
	}
L
Linus Torvalds 已提交
1842 1843 1844 1845 1846 1847 1848
}

static void nodemgr_remove_host(struct hpsb_host *host)
{
	struct host_info *hi = hpsb_get_hostinfo(&nodemgr_highlevel, host);

	if (hi) {
1849 1850 1851
		kthread_stop(hi->thread);
		nodemgr_remove_host_dev(&host->device);
	}
L
Linus Torvalds 已提交
1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862
}

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)
{
1863
	int error;
L
Linus Torvalds 已提交
1864

1865 1866
	error = class_register(&nodemgr_ne_class);
	if (error)
1867
		goto fail_ne;
1868
	error = class_register(&nodemgr_ud_class);
1869 1870
	if (error)
		goto fail_ud;
1871
	error = driver_register(&nodemgr_mid_layer_driver);
1872 1873 1874 1875 1876
	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;

L
Linus Torvalds 已提交
1877 1878
	hpsb_register_highlevel(&nodemgr_highlevel);
	return 0;
1879 1880 1881 1882 1883 1884 1885

fail_ml:
	class_unregister(&nodemgr_ud_class);
fail_ud:
	class_unregister(&nodemgr_ne_class);
fail_ne:
	return error;
L
Linus Torvalds 已提交
1886 1887 1888 1889
}

void cleanup_ieee1394_nodemgr(void)
{
S
Stefan Richter 已提交
1890
	hpsb_unregister_highlevel(&nodemgr_highlevel);
1891
	driver_unregister(&nodemgr_mid_layer_driver);
L
Linus Torvalds 已提交
1892 1893 1894
	class_unregister(&nodemgr_ud_class);
	class_unregister(&nodemgr_ne_class);
}