fw-device.c 20.3 KB
Newer Older
1 2
/*
 * Device probing and sysfs code.
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
 *
 * Copyright (C) 2005-2006  Kristian Hoegsberg <krh@bitplanet.net>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

#include <linux/module.h>
#include <linux/wait.h>
#include <linux/errno.h>
#include <linux/kthread.h>
#include <linux/device.h>
#include <linux/delay.h>
27
#include <linux/idr.h>
28 29
#include <linux/rwsem.h>
#include <asm/semaphore.h>
30
#include <linux/ctype.h>
31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52
#include "fw-transaction.h"
#include "fw-topology.h"
#include "fw-device.h"

void fw_csr_iterator_init(struct fw_csr_iterator *ci, u32 * p)
{
	ci->p = p + 1;
	ci->end = ci->p + (p[0] >> 16);
}
EXPORT_SYMBOL(fw_csr_iterator_init);

int fw_csr_iterator_next(struct fw_csr_iterator *ci, int *key, int *value)
{
	*key = *ci->p >> 24;
	*value = *ci->p & 0xffffff;

	return ci->p++ < ci->end;
}
EXPORT_SYMBOL(fw_csr_iterator_next);

static int is_fw_unit(struct device *dev);

53
static int match_unit_directory(u32 * directory, const struct fw_device_id *id)
54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 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 146 147 148 149 150 151 152 153
{
	struct fw_csr_iterator ci;
	int key, value, match;

	match = 0;
	fw_csr_iterator_init(&ci, directory);
	while (fw_csr_iterator_next(&ci, &key, &value)) {
		if (key == CSR_VENDOR && value == id->vendor)
			match |= FW_MATCH_VENDOR;
		if (key == CSR_MODEL && value == id->model)
			match |= FW_MATCH_MODEL;
		if (key == CSR_SPECIFIER_ID && value == id->specifier_id)
			match |= FW_MATCH_SPECIFIER_ID;
		if (key == CSR_VERSION && value == id->version)
			match |= FW_MATCH_VERSION;
	}

	return (match & id->match_flags) == id->match_flags;
}

static int fw_unit_match(struct device *dev, struct device_driver *drv)
{
	struct fw_unit *unit = fw_unit(dev);
	struct fw_driver *driver = fw_driver(drv);
	int i;

	/* We only allow binding to fw_units. */
	if (!is_fw_unit(dev))
		return 0;

	for (i = 0; driver->id_table[i].match_flags != 0; i++) {
		if (match_unit_directory(unit->directory, &driver->id_table[i]))
			return 1;
	}

	return 0;
}

static int get_modalias(struct fw_unit *unit, char *buffer, size_t buffer_size)
{
	struct fw_device *device = fw_device(unit->device.parent);
	struct fw_csr_iterator ci;

	int key, value;
	int vendor = 0;
	int model = 0;
	int specifier_id = 0;
	int version = 0;

	fw_csr_iterator_init(&ci, &device->config_rom[5]);
	while (fw_csr_iterator_next(&ci, &key, &value)) {
		switch (key) {
		case CSR_VENDOR:
			vendor = value;
			break;
		case CSR_MODEL:
			model = value;
			break;
		}
	}

	fw_csr_iterator_init(&ci, unit->directory);
	while (fw_csr_iterator_next(&ci, &key, &value)) {
		switch (key) {
		case CSR_SPECIFIER_ID:
			specifier_id = value;
			break;
		case CSR_VERSION:
			version = value;
			break;
		}
	}

	return snprintf(buffer, buffer_size,
			"ieee1394:ven%08Xmo%08Xsp%08Xver%08X",
			vendor, model, specifier_id, version);
}

static int
fw_unit_uevent(struct device *dev, char **envp, int num_envp,
	       char *buffer, int buffer_size)
{
	struct fw_unit *unit = fw_unit(dev);
	char modalias[64];
	int length = 0;
	int i = 0;

	get_modalias(unit, modalias, sizeof modalias);

	if (add_uevent_var(envp, num_envp, &i,
			   buffer, buffer_size, &length,
			   "MODALIAS=%s", modalias))
		return -ENOMEM;

	envp[i] = NULL;

	return 0;
}

struct bus_type fw_bus_type = {
154
	.name = "firewire",
155 156 157 158
	.match = fw_unit_match,
};
EXPORT_SYMBOL(fw_bus_type);

159
struct fw_device *fw_device_get(struct fw_device *device)
160 161 162 163 164 165
{
	get_device(&device->device);

	return device;
}

166
void fw_device_put(struct fw_device *device)
167 168 169 170 171 172 173 174 175
{
	put_device(&device->device);
}

static void fw_device_release(struct device *dev)
{
	struct fw_device *device = fw_device(dev);
	unsigned long flags;

176 177 178 179
	/*
	 * Take the card lock so we don't set this to NULL while a
	 * FW_NODE_UPDATED callback is being handled.
	 */
180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197
	spin_lock_irqsave(&device->card->lock, flags);
	device->node->data = NULL;
	spin_unlock_irqrestore(&device->card->lock, flags);

	fw_node_put(device->node);
	fw_card_put(device->card);
	kfree(device->config_rom);
	kfree(device);
}

int fw_device_enable_phys_dma(struct fw_device *device)
{
	return device->card->driver->enable_phys_dma(device->card,
						     device->node_id,
						     device->generation);
}
EXPORT_SYMBOL(fw_device_enable_phys_dma);

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 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292
struct config_rom_attribute {
	struct device_attribute attr;
	u32 key;
};

static ssize_t
show_immediate(struct device *dev, struct device_attribute *dattr, char *buf)
{
	struct config_rom_attribute *attr =
		container_of(dattr, struct config_rom_attribute, attr);
	struct fw_csr_iterator ci;
	u32 *dir;
	int key, value;

	if (is_fw_unit(dev))
		dir = fw_unit(dev)->directory;
	else
		dir = fw_device(dev)->config_rom + 5;

	fw_csr_iterator_init(&ci, dir);
	while (fw_csr_iterator_next(&ci, &key, &value))
		if (attr->key == key)
			return snprintf(buf, buf ? PAGE_SIZE : 0,
					"0x%06x\n", value);

	return -ENOENT;
}

#define IMMEDIATE_ATTR(name, key)				\
	{ __ATTR(name, S_IRUGO, show_immediate, NULL), key }

static ssize_t
show_text_leaf(struct device *dev, struct device_attribute *dattr, char *buf)
{
	struct config_rom_attribute *attr =
		container_of(dattr, struct config_rom_attribute, attr);
	struct fw_csr_iterator ci;
	u32 *dir, *block = NULL, *p, *end;
	int length, key, value, last_key = 0;
	char *b;

	if (is_fw_unit(dev))
		dir = fw_unit(dev)->directory;
	else
		dir = fw_device(dev)->config_rom + 5;

	fw_csr_iterator_init(&ci, dir);
	while (fw_csr_iterator_next(&ci, &key, &value)) {
		if (attr->key == last_key &&
		    key == (CSR_DESCRIPTOR | CSR_LEAF))
			block = ci.p - 1 + value;
		last_key = key;
	}

	if (block == NULL)
		return -ENOENT;

	length = min(block[0] >> 16, 256U);
	if (length < 3)
		return -ENOENT;

	if (block[1] != 0 || block[2] != 0)
		/* Unknown encoding. */
		return -ENOENT;

	if (buf == NULL)
		return length * 4;

	b = buf;
	end = &block[length + 1];
	for (p = &block[3]; p < end; p++, b += 4)
		* (u32 *) b = (__force u32) __cpu_to_be32(*p);

	/* Strip trailing whitespace and add newline. */
	while (b--, (isspace(*b) || *b == '\0') && b > buf);
	strcpy(b + 1, "\n");

	return b + 2 - buf;
}

#define TEXT_LEAF_ATTR(name, key)				\
	{ __ATTR(name, S_IRUGO, show_text_leaf, NULL), key }

static struct config_rom_attribute config_rom_attributes[] = {
	IMMEDIATE_ATTR(vendor, CSR_VENDOR),
	IMMEDIATE_ATTR(hardware_version, CSR_HARDWARE_VERSION),
	IMMEDIATE_ATTR(specifier_id, CSR_SPECIFIER_ID),
	IMMEDIATE_ATTR(version, CSR_VERSION),
	IMMEDIATE_ATTR(model, CSR_MODEL),
	TEXT_LEAF_ATTR(vendor_name, CSR_VENDOR),
	TEXT_LEAF_ATTR(model_name, CSR_MODEL),
	TEXT_LEAF_ATTR(hardware_version_name, CSR_HARDWARE_VERSION),
};

static void
293 294 295
init_fw_attribute_group(struct device *dev,
			struct device_attribute *attrs,
			struct fw_attribute_group *group)
296 297
{
	struct device_attribute *attr;
298 299 300 301
	int i, j;

	for (j = 0; attrs[j].attr.name != NULL; j++)
		group->attrs[j] = &attrs[j].attr;
302 303 304 305 306

	for (i = 0; i < ARRAY_SIZE(config_rom_attributes); i++) {
		attr = &config_rom_attributes[i].attr;
		if (attr->show(dev, attr, NULL) < 0)
			continue;
307
		group->attrs[j++] = &attr->attr;
308 309
	}

310 311 312 313 314 315
	BUG_ON(j >= ARRAY_SIZE(group->attrs));
	group->attrs[j++] = NULL;
	group->groups[0] = &group->group;
	group->groups[1] = NULL;
	group->group.attrs = group->attrs;
	dev->groups = group->groups;
316 317
}

318
static ssize_t
319 320
modalias_show(struct device *dev,
	      struct device_attribute *attr, char *buf)
321 322 323 324 325 326 327 328 329 330 331
{
	struct fw_unit *unit = fw_unit(dev);
	int length;

	length = get_modalias(unit, buf, PAGE_SIZE);
	strcpy(buf + length, "\n");

	return length + 1;
}

static ssize_t
332 333
rom_index_show(struct device *dev,
	       struct device_attribute *attr, char *buf)
334
{
335 336
	struct fw_device *device = fw_device(dev->parent);
	struct fw_unit *unit = fw_unit(dev);
337

338 339
	return snprintf(buf, PAGE_SIZE, "%d\n",
			(int)(unit->directory - device->config_rom));
340 341
}

342 343 344 345
static struct device_attribute fw_unit_attributes[] = {
	__ATTR_RO(modalias),
	__ATTR_RO(rom_index),
	__ATTR_NULL,
346 347
};

348
static ssize_t
349
config_rom_show(struct device *dev, struct device_attribute *attr, char *buf)
350
{
351
	struct fw_device *device = fw_device(dev);
352

353 354 355
	memcpy(buf, device->config_rom, device->config_rom_length * 4);

	return device->config_rom_length * 4;
356 357
}

358 359 360 361 362 363 364 365
static ssize_t
guid_show(struct device *dev, struct device_attribute *attr, char *buf)
{
	struct fw_device *device = fw_device(dev);
	u64 guid;

	guid = ((u64)device->config_rom[3] << 32) | device->config_rom[4];

A
Andrew Morton 已提交
366 367
	return snprintf(buf, PAGE_SIZE, "0x%016llx\n",
			(unsigned long long)guid);
368 369
}

370 371
static struct device_attribute fw_device_attributes[] = {
	__ATTR_RO(config_rom),
372
	__ATTR_RO(guid),
373
	__ATTR_NULL,
374 375
};

376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403
struct read_quadlet_callback_data {
	struct completion done;
	int rcode;
	u32 data;
};

static void
complete_transaction(struct fw_card *card, int rcode,
		     void *payload, size_t length, void *data)
{
	struct read_quadlet_callback_data *callback_data = data;

	if (rcode == RCODE_COMPLETE)
		callback_data->data = be32_to_cpu(*(__be32 *)payload);
	callback_data->rcode = rcode;
	complete(&callback_data->done);
}

static int read_rom(struct fw_device *device, int index, u32 * data)
{
	struct read_quadlet_callback_data callback_data;
	struct fw_transaction t;
	u64 offset;

	init_completion(&callback_data.done);

	offset = 0xfffff0000400ULL + index * 4;
	fw_send_request(device->card, &t, TCODE_READ_QUADLET_REQUEST,
404
			device->node_id,
405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424
			device->generation, SCODE_100,
			offset, NULL, 4, complete_transaction, &callback_data);

	wait_for_completion(&callback_data.done);

	*data = callback_data.data;

	return callback_data.rcode;
}

static int read_bus_info_block(struct fw_device *device)
{
	static u32 rom[256];
	u32 stack[16], sp, key;
	int i, end, length;

	/* First read the bus info block. */
	for (i = 0; i < 5; i++) {
		if (read_rom(device, i, &rom[i]) != RCODE_COMPLETE)
			return -1;
425 426
		/*
		 * As per IEEE1212 7.2, during power-up, devices can
427 428 429 430
		 * reply with a 0 for the first quadlet of the config
		 * rom to indicate that they are booting (for example,
		 * if the firmware is on the disk of a external
		 * harddisk).  In that case we just fail, and the
431 432
		 * retry mechanism will try again later.
		 */
433 434 435 436
		if (i == 0 && rom[i] == 0)
			return -1;
	}

437 438
	/*
	 * Now parse the config rom.  The config rom is a recursive
439 440 441
	 * directory structure so we parse it using a stack of
	 * references to the blocks that make up the structure.  We
	 * push a reference to the root directory on the stack to
442 443
	 * start things off.
	 */
444 445 446 447
	length = i;
	sp = 0;
	stack[sp++] = 0xc0000005;
	while (sp > 0) {
448 449
		/*
		 * Pop the next block reference of the stack.  The
450 451
		 * lower 24 bits is the offset into the config rom,
		 * the upper 8 bits are the type of the reference the
452 453
		 * block.
		 */
454 455 456
		key = stack[--sp];
		i = key & 0xffffff;
		if (i >= ARRAY_SIZE(rom))
457 458 459 460
			/*
			 * The reference points outside the standard
			 * config rom area, something's fishy.
			 */
461 462 463 464 465 466 467 468
			return -1;

		/* Read header quadlet for the block to get the length. */
		if (read_rom(device, i, &rom[i]) != RCODE_COMPLETE)
			return -1;
		end = i + (rom[i] >> 16) + 1;
		i++;
		if (end > ARRAY_SIZE(rom))
469 470
			/*
			 * This block extends outside standard config
471 472
			 * area (and the array we're reading it
			 * into).  That's broken, so ignore this
473 474
			 * device.
			 */
475 476
			return -1;

477 478
		/*
		 * Now read in the block.  If this is a directory
479
		 * block, check the entries as we read them to see if
480 481
		 * it references another block, and push it in that case.
		 */
482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509
		while (i < end) {
			if (read_rom(device, i, &rom[i]) != RCODE_COMPLETE)
				return -1;
			if ((key >> 30) == 3 && (rom[i] >> 30) > 1 &&
			    sp < ARRAY_SIZE(stack))
				stack[sp++] = i + rom[i];
			i++;
		}
		if (length < i)
			length = i;
	}

	device->config_rom = kmalloc(length * 4, GFP_KERNEL);
	if (device->config_rom == NULL)
		return -1;
	memcpy(device->config_rom, rom, length * 4);
	device->config_rom_length = length;

	return 0;
}

static void fw_unit_release(struct device *dev)
{
	struct fw_unit *unit = fw_unit(dev);

	kfree(unit);
}

510 511 512 513 514
static struct device_type fw_unit_type = {
	.uevent		= fw_unit_uevent,
	.release	= fw_unit_release,
};

515 516
static int is_fw_unit(struct device *dev)
{
517
	return dev->type == &fw_unit_type;
518 519 520 521 522 523 524 525 526 527 528 529 530 531
}

static void create_units(struct fw_device *device)
{
	struct fw_csr_iterator ci;
	struct fw_unit *unit;
	int key, value, i;

	i = 0;
	fw_csr_iterator_init(&ci, &device->config_rom[5]);
	while (fw_csr_iterator_next(&ci, &key, &value)) {
		if (key != (CSR_UNIT | CSR_DIRECTORY))
			continue;

532 533 534 535
		/*
		 * Get the address of the unit directory and try to
		 * match the drivers id_tables against it.
		 */
536 537 538 539 540 541 542 543
		unit = kzalloc(sizeof *unit, GFP_KERNEL);
		if (unit == NULL) {
			fw_error("failed to allocate memory for unit\n");
			continue;
		}

		unit->directory = ci.p + value - 1;
		unit->device.bus = &fw_bus_type;
544
		unit->device.type = &fw_unit_type;
545 546 547 548
		unit->device.parent = &device->device;
		snprintf(unit->device.bus_id, sizeof unit->device.bus_id,
			 "%s.%d", device->device.bus_id, i++);

549 550 551
		init_fw_attribute_group(&unit->device,
					fw_unit_attributes,
					&unit->attribute_group);
552 553 554 555 556 557 558
		if (device_register(&unit->device) < 0)
			goto skip_unit;

		continue;

	skip_unit:
		kfree(unit);
559 560 561 562 563
	}
}

static int shutdown_unit(struct device *device, void *data)
{
564
	device_unregister(device);
565 566 567 568

	return 0;
}

569
static DECLARE_RWSEM(idr_rwsem);
570 571 572 573 574 575 576
static DEFINE_IDR(fw_device_idr);
int fw_cdev_major;

struct fw_device *fw_device_from_devt(dev_t devt)
{
	struct fw_device *device;

577
	down_read(&idr_rwsem);
578
	device = idr_find(&fw_device_idr, MINOR(devt));
579
	up_read(&idr_rwsem);
580 581 582 583

	return device;
}

584 585 586 587
static void fw_device_shutdown(struct work_struct *work)
{
	struct fw_device *device =
		container_of(work, struct fw_device, work.work);
588 589
	int minor = MINOR(device->device.devt);

590
	down_write(&idr_rwsem);
591
	idr_remove(&fw_device_idr, minor);
592
	up_write(&idr_rwsem);
593

594
	fw_device_cdev_remove(device);
595 596 597 598
	device_for_each_child(&device->device, NULL, shutdown_unit);
	device_unregister(&device->device);
}

599 600 601 602
static struct device_type fw_device_type = {
	.release	= fw_device_release,
};

603 604
/*
 * These defines control the retry behavior for reading the config
605 606 607 608 609 610
 * rom.  It shouldn't be necessary to tweak these; if the device
 * doesn't respond to a config rom read within 10 seconds, it's not
 * going to respond at all.  As for the initial delay, a lot of
 * devices will be able to respond within half a second after bus
 * reset.  On the other hand, it's not really worth being more
 * aggressive than that, since it scales pretty well; if 10 devices
611 612
 * are plugged in, they're all getting read within one second.
 */
613

614 615
#define MAX_RETRIES	10
#define RETRY_DELAY	(3 * HZ)
616 617 618 619 620 621
#define INITIAL_DELAY	(HZ / 2)

static void fw_device_init(struct work_struct *work)
{
	struct fw_device *device =
		container_of(work, struct fw_device, work.work);
622
	int minor, err;
623

624 625
	/*
	 * All failure paths here set node->data to NULL, so that we
626
	 * don't try to do device_for_each_child() on a kfree()'d
627 628
	 * device.
	 */
629 630 631 632 633 634

	if (read_bus_info_block(device) < 0) {
		if (device->config_rom_retries < MAX_RETRIES) {
			device->config_rom_retries++;
			schedule_delayed_work(&device->work, RETRY_DELAY);
		} else {
635
			fw_notify("giving up on config rom for node id %x\n",
636
				  device->node_id);
637 638
			if (device->node == device->card->root_node)
				schedule_delayed_work(&device->card->work, 0);
639 640 641 642 643
			fw_device_release(&device->device);
		}
		return;
	}

644
	err = -ENOMEM;
645
	down_write(&idr_rwsem);
646 647
	if (idr_pre_get(&fw_device_idr, GFP_KERNEL))
		err = idr_get_new(&fw_device_idr, device, &minor);
648
	up_write(&idr_rwsem);
649 650 651
	if (err < 0)
		goto error;

652
	device->device.bus = &fw_bus_type;
653
	device->device.type = &fw_device_type;
654
	device->device.parent = device->card->device;
655
	device->device.devt = MKDEV(fw_cdev_major, minor);
656
	snprintf(device->device.bus_id, sizeof device->device.bus_id,
657
		 "fw%d", minor);
658

659 660 661
	init_fw_attribute_group(&device->device,
				fw_device_attributes,
				&device->attribute_group);
662 663
	if (device_add(&device->device)) {
		fw_error("Failed to add device.\n");
664
		goto error_with_cdev;
665 666 667 668
	}

	create_units(device);

669 670
	/*
	 * Transition the device to running state.  If it got pulled
671 672 673 674 675
	 * out from under us while we did the intialization work, we
	 * have to shut down the device again here.  Normally, though,
	 * fw_node_event will be responsible for shutting it down when
	 * necessary.  We have to use the atomic cmpxchg here to avoid
	 * racing with the FW_NODE_DESTROYED case in
676 677
	 * fw_node_event().
	 */
678
	if (atomic_cmpxchg(&device->state,
679 680 681 682 683 684 685
		    FW_DEVICE_INITIALIZING,
		    FW_DEVICE_RUNNING) == FW_DEVICE_SHUTDOWN)
		fw_device_shutdown(&device->work.work);
	else
		fw_notify("created new fw device %s (%d config rom retries)\n",
			  device->device.bus_id, device->config_rom_retries);

686 687
	/*
	 * Reschedule the IRM work if we just finished reading the
688 689
	 * root node config rom.  If this races with a bus reset we
	 * just end up running the IRM work a couple of extra times -
690 691
	 * pretty harmless.
	 */
692 693 694 695 696
	if (device->node == device->card->root_node)
		schedule_delayed_work(&device->card->work, 0);

	return;

697
 error_with_cdev:
698
	down_write(&idr_rwsem);
699
	idr_remove(&fw_device_idr, minor);
700
	up_write(&idr_rwsem);
S
Stefan Richter 已提交
701
 error:
702 703 704 705 706 707 708 709
	put_device(&device->device);
}

static int update_unit(struct device *dev, void *data)
{
	struct fw_unit *unit = fw_unit(dev);
	struct fw_driver *driver = (struct fw_driver *)dev->driver;

710 711
	if (is_fw_unit(dev) && driver != NULL && driver->update != NULL) {
		down(&dev->sem);
712
		driver->update(unit);
713 714
		up(&dev->sem);
	}
715 716 717 718

	return 0;
}

719 720 721 722 723
static void fw_device_update(struct work_struct *work)
{
	struct fw_device *device =
		container_of(work, struct fw_device, work.work);

724
	fw_device_cdev_update(device);
725 726 727
	device_for_each_child(&device->device, NULL, update_unit);
}

728 729 730 731 732 733 734 735 736 737 738 739 740 741
void fw_node_event(struct fw_card *card, struct fw_node *node, int event)
{
	struct fw_device *device;

	switch (event) {
	case FW_NODE_CREATED:
	case FW_NODE_LINK_ON:
		if (!node->link_on)
			break;

		device = kzalloc(sizeof(*device), GFP_ATOMIC);
		if (device == NULL)
			break;

742 743
		/*
		 * Do minimal intialization of the device here, the
744 745 746 747
		 * rest will happen in fw_device_init().  We need the
		 * card and node so we can read the config rom and we
		 * need to do device_initialize() now so
		 * device_for_each_child() in FW_NODE_UPDATED is
748 749
		 * doesn't freak out.
		 */
750
		device_initialize(&device->device);
751
		atomic_set(&device->state, FW_DEVICE_INITIALIZING);
752 753 754 755
		device->card = fw_card_get(card);
		device->node = fw_node_get(node);
		device->node_id = node->node_id;
		device->generation = card->generation;
756
		INIT_LIST_HEAD(&device->client_list);
757

758 759
		/*
		 * Set the node data to point back to this device so
760
		 * FW_NODE_UPDATED callbacks can update the node_id
761 762
		 * and generation for the device.
		 */
763 764
		node->data = device;

765 766
		/*
		 * Many devices are slow to respond after bus resets,
767 768
		 * especially if they are bus powered and go through
		 * power-up after getting plugged in.  We schedule the
769 770
		 * first config rom scan half a second after bus reset.
		 */
771 772 773 774 775 776 777 778 779 780 781
		INIT_DELAYED_WORK(&device->work, fw_device_init);
		schedule_delayed_work(&device->work, INITIAL_DELAY);
		break;

	case FW_NODE_UPDATED:
		if (!node->link_on || node->data == NULL)
			break;

		device = node->data;
		device->node_id = node->node_id;
		device->generation = card->generation;
782 783 784 785
		if (atomic_read(&device->state) == FW_DEVICE_RUNNING) {
			PREPARE_DELAYED_WORK(&device->work, fw_device_update);
			schedule_delayed_work(&device->work, 0);
		}
786 787 788 789 790 791 792
		break;

	case FW_NODE_DESTROYED:
	case FW_NODE_LINK_OFF:
		if (!node->data)
			break;

793 794
		/*
		 * Destroy the device associated with the node.  There
795 796 797 798 799 800 801 802
		 * are two cases here: either the device is fully
		 * initialized (FW_DEVICE_RUNNING) or we're in the
		 * process of reading its config rom
		 * (FW_DEVICE_INITIALIZING).  If it is fully
		 * initialized we can reuse device->work to schedule a
		 * full fw_device_shutdown().  If not, there's work
		 * scheduled to read it's config rom, and we just put
		 * the device in shutdown state to have that code fail
803 804
		 * to create the device.
		 */
805
		device = node->data;
806
		if (atomic_xchg(&device->state,
807 808
				FW_DEVICE_SHUTDOWN) == FW_DEVICE_RUNNING) {
			PREPARE_DELAYED_WORK(&device->work, fw_device_shutdown);
809 810 811 812 813
			schedule_delayed_work(&device->work, 0);
		}
		break;
	}
}