fw-device.c 26.1 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
#include <linux/string.h>
29 30
#include <linux/rwsem.h>
#include <linux/semaphore.h>
31
#include <asm/system.h>
32
#include <linux/ctype.h>
33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54
#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);

55
static int match_unit_directory(u32 * directory, const struct fw_device_id *id)
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
{
	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
135
fw_unit_uevent(struct device *dev, struct kobj_uevent_env *env)
136 137 138 139
{
	struct fw_unit *unit = fw_unit(dev);
	char modalias[64];

140
	get_modalias(unit, modalias, sizeof(modalias));
141

142
	if (add_uevent_var(env, "MODALIAS=%s", modalias))
143 144 145 146 147 148
		return -ENOMEM;

	return 0;
}

struct bus_type fw_bus_type = {
149
	.name = "firewire",
150 151 152 153 154 155 156
	.match = fw_unit_match,
};
EXPORT_SYMBOL(fw_bus_type);

static void fw_device_release(struct device *dev)
{
	struct fw_device *device = fw_device(dev);
157
	struct fw_card *card = device->card;
158 159
	unsigned long flags;

160 161 162 163
	/*
	 * Take the card lock so we don't set this to NULL while a
	 * FW_NODE_UPDATED callback is being handled.
	 */
164
	spin_lock_irqsave(&card->lock, flags);
165
	device->node->data = NULL;
166
	spin_unlock_irqrestore(&card->lock, flags);
167 168 169 170

	fw_node_put(device->node);
	kfree(device->config_rom);
	kfree(device);
171
	atomic_dec(&card->device_count);
172 173 174 175
}

int fw_device_enable_phys_dma(struct fw_device *device)
{
176 177 178 179 180
	int generation = device->generation;

	/* device->node_id, accessed below, must not be older than generation */
	smp_rmb();

181 182
	return device->card->driver->enable_phys_dma(device->card,
						     device->node_id,
183
						     generation);
184 185 186
}
EXPORT_SYMBOL(fw_device_enable_phys_dma);

187 188 189 190 191 192 193 194 195 196 197 198
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;
199 200 201
	int key, value, ret = -ENOENT;

	down_read(&fw_device_rwsem);
202 203 204 205 206 207 208 209

	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))
210 211 212 213 214 215 216
		if (attr->key == key) {
			ret = snprintf(buf, buf ? PAGE_SIZE : 0,
				       "0x%06x\n", value);
			break;
		}

	up_read(&fw_device_rwsem);
217

218
	return ret;
219 220 221 222 223 224 225 226 227 228 229 230
}

#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;
231
	int length, key, value, last_key = 0, ret = -ENOENT;
232 233
	char *b;

234 235
	down_read(&fw_device_rwsem);

236 237 238 239 240 241 242 243 244 245 246 247 248 249
	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)
250
		goto out;
251 252 253

	length = min(block[0] >> 16, 256U);
	if (length < 3)
254
		goto out;
255 256 257

	if (block[1] != 0 || block[2] != 0)
		/* Unknown encoding. */
258
		goto out;
259

260 261 262 263
	if (buf == NULL) {
		ret = length * 4;
		goto out;
	}
264 265 266 267 268 269 270 271 272

	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");
273 274 275
	ret = b + 2 - buf;
 out:
	up_read(&fw_device_rwsem);
276

277
	return ret;
278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294
}

#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
295 296 297
init_fw_attribute_group(struct device *dev,
			struct device_attribute *attrs,
			struct fw_attribute_group *group)
298 299
{
	struct device_attribute *attr;
300 301 302 303
	int i, j;

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

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

312 313 314 315 316 317
	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;
318 319
}

320
static ssize_t
321 322
modalias_show(struct device *dev,
	      struct device_attribute *attr, char *buf)
323 324 325 326 327 328 329 330 331 332 333
{
	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
334 335
rom_index_show(struct device *dev,
	       struct device_attribute *attr, char *buf)
336
{
337 338
	struct fw_device *device = fw_device(dev->parent);
	struct fw_unit *unit = fw_unit(dev);
339

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

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

350
static ssize_t
351
config_rom_show(struct device *dev, struct device_attribute *attr, char *buf)
352
{
353
	struct fw_device *device = fw_device(dev);
354
	size_t length;
355

356 357 358 359
	down_read(&fw_device_rwsem);
	length = device->config_rom_length * 4;
	memcpy(buf, device->config_rom, length);
	up_read(&fw_device_rwsem);
360

361
	return length;
362 363
}

364 365 366 367
static ssize_t
guid_show(struct device *dev, struct device_attribute *attr, char *buf)
{
	struct fw_device *device = fw_device(dev);
368 369 370 371 372 373
	int ret;

	down_read(&fw_device_rwsem);
	ret = snprintf(buf, PAGE_SIZE, "0x%08x%08x\n",
		       device->config_rom[3], device->config_rom[4]);
	up_read(&fw_device_rwsem);
374

375
	return ret;
376 377
}

378 379
static struct device_attribute fw_device_attributes[] = {
	__ATTR_RO(config_rom),
380
	__ATTR_RO(guid),
381
	__ATTR_NULL,
382 383
};

384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401
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);
}

402 403
static int
read_rom(struct fw_device *device, int generation, int index, u32 *data)
404 405 406 407
{
	struct read_quadlet_callback_data callback_data;
	struct fw_transaction t;
	u64 offset;
408 409 410

	/* device->node_id, accessed below, must not be older than generation */
	smp_rmb();
411 412 413

	init_completion(&callback_data.done);

414
	offset = (CSR_REGISTER_BASE | CSR_CONFIG_ROM) + index * 4;
415
	fw_send_request(device->card, &t, TCODE_READ_QUADLET_REQUEST,
416
			device->node_id, generation, device->max_speed,
417 418 419 420 421 422 423 424 425
			offset, NULL, 4, complete_transaction, &callback_data);

	wait_for_completion(&callback_data.done);

	*data = callback_data.data;

	return callback_data.rcode;
}

426 427 428
#define READ_BIB_ROM_SIZE	256
#define READ_BIB_STACK_SIZE	16

429 430 431 432 433 434 435 436
/*
 * Read the bus info block, perform a speed probe, and read all of the rest of
 * the config ROM.  We do all this with a cached bus generation.  If the bus
 * generation changes under us, read_bus_info_block will fail and get retried.
 * It's better to start all over in this case because the node from which we
 * are reading the ROM may have changed the ROM during the reset.
 */
static int read_bus_info_block(struct fw_device *device, int generation)
437
{
438
	u32 *rom, *stack, *old_rom, *new_rom;
439 440 441 442 443 444 445 446 447
	u32 sp, key;
	int i, end, length, ret = -1;

	rom = kmalloc(sizeof(*rom) * READ_BIB_ROM_SIZE +
		      sizeof(*stack) * READ_BIB_STACK_SIZE, GFP_KERNEL);
	if (rom == NULL)
		return -ENOMEM;

	stack = &rom[READ_BIB_ROM_SIZE];
448

449 450
	device->max_speed = SCODE_100;

451 452
	/* First read the bus info block. */
	for (i = 0; i < 5; i++) {
453
		if (read_rom(device, generation, i, &rom[i]) != RCODE_COMPLETE)
454
			goto out;
455 456
		/*
		 * As per IEEE1212 7.2, during power-up, devices can
457 458 459 460
		 * 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
461 462
		 * retry mechanism will try again later.
		 */
463
		if (i == 0 && rom[i] == 0)
464
			goto out;
465 466
	}

467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487
	device->max_speed = device->node->max_speed;

	/*
	 * Determine the speed of
	 *   - devices with link speed less than PHY speed,
	 *   - devices with 1394b PHY (unless only connected to 1394a PHYs),
	 *   - all devices if there are 1394b repeaters.
	 * Note, we cannot use the bus info block's link_spd as starting point
	 * because some buggy firmwares set it lower than necessary and because
	 * 1394-1995 nodes do not have the field.
	 */
	if ((rom[2] & 0x7) < device->max_speed ||
	    device->max_speed == SCODE_BETA ||
	    device->card->beta_repeaters_present) {
		u32 dummy;

		/* for S1600 and S3200 */
		if (device->max_speed == SCODE_BETA)
			device->max_speed = device->card->link_speed;

		while (device->max_speed > SCODE_100) {
488 489
			if (read_rom(device, generation, 0, &dummy) ==
			    RCODE_COMPLETE)
490 491 492 493 494
				break;
			device->max_speed--;
		}
	}

495 496
	/*
	 * Now parse the config rom.  The config rom is a recursive
497 498 499
	 * 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
500 501
	 * start things off.
	 */
502 503 504 505
	length = i;
	sp = 0;
	stack[sp++] = 0xc0000005;
	while (sp > 0) {
506 507
		/*
		 * Pop the next block reference of the stack.  The
508 509
		 * lower 24 bits is the offset into the config rom,
		 * the upper 8 bits are the type of the reference the
510 511
		 * block.
		 */
512 513
		key = stack[--sp];
		i = key & 0xffffff;
514
		if (i >= READ_BIB_ROM_SIZE)
515 516 517 518
			/*
			 * The reference points outside the standard
			 * config rom area, something's fishy.
			 */
519
			goto out;
520 521

		/* Read header quadlet for the block to get the length. */
522
		if (read_rom(device, generation, i, &rom[i]) != RCODE_COMPLETE)
523
			goto out;
524 525
		end = i + (rom[i] >> 16) + 1;
		i++;
526
		if (end > READ_BIB_ROM_SIZE)
527 528
			/*
			 * This block extends outside standard config
529 530
			 * area (and the array we're reading it
			 * into).  That's broken, so ignore this
531 532
			 * device.
			 */
533
			goto out;
534

535 536
		/*
		 * Now read in the block.  If this is a directory
537
		 * block, check the entries as we read them to see if
538 539
		 * it references another block, and push it in that case.
		 */
540
		while (i < end) {
541 542
			if (read_rom(device, generation, i, &rom[i]) !=
			    RCODE_COMPLETE)
543
				goto out;
544
			if ((key >> 30) == 3 && (rom[i] >> 30) > 1 &&
545
			    sp < READ_BIB_STACK_SIZE)
546 547 548 549 550 551 552
				stack[sp++] = i + rom[i];
			i++;
		}
		if (length < i)
			length = i;
	}

553 554 555
	old_rom = device->config_rom;
	new_rom = kmemdup(rom, length * 4, GFP_KERNEL);
	if (new_rom == NULL)
556
		goto out;
557 558 559

	down_write(&fw_device_rwsem);
	device->config_rom = new_rom;
560
	device->config_rom_length = length;
561 562 563
	up_write(&fw_device_rwsem);

	kfree(old_rom);
564
	ret = 0;
565
	device->cmc = rom[2] & 1 << 30;
566 567
 out:
	kfree(rom);
568

569
	return ret;
570 571 572 573 574 575 576 577 578
}

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

	kfree(unit);
}

579 580 581 582 583
static struct device_type fw_unit_type = {
	.uevent		= fw_unit_uevent,
	.release	= fw_unit_release,
};

584 585
static int is_fw_unit(struct device *dev)
{
586
	return dev->type == &fw_unit_type;
587 588 589 590 591 592 593 594 595 596 597 598 599 600
}

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;

601 602 603 604
		/*
		 * Get the address of the unit directory and try to
		 * match the drivers id_tables against it.
		 */
605
		unit = kzalloc(sizeof(*unit), GFP_KERNEL);
606 607 608 609 610 611 612
		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;
613
		unit->device.type = &fw_unit_type;
614
		unit->device.parent = &device->device;
615
		snprintf(unit->device.bus_id, sizeof(unit->device.bus_id),
616 617
			 "%s.%d", device->device.bus_id, i++);

618 619 620
		init_fw_attribute_group(&unit->device,
					fw_unit_attributes,
					&unit->attribute_group);
621 622 623 624 625 626 627
		if (device_register(&unit->device) < 0)
			goto skip_unit;

		continue;

	skip_unit:
		kfree(unit);
628 629 630 631 632
	}
}

static int shutdown_unit(struct device *device, void *data)
{
633
	device_unregister(device);
634 635 636 637

	return 0;
}

638 639 640 641 642 643 644 645
/*
 * fw_device_rwsem acts as dual purpose mutex:
 *   - serializes accesses to fw_device_idr,
 *   - serializes accesses to fw_device.config_rom/.config_rom_length and
 *     fw_unit.directory, unless those accesses happen at safe occasions
 */
DECLARE_RWSEM(fw_device_rwsem);

646 647 648
static DEFINE_IDR(fw_device_idr);
int fw_cdev_major;

649
struct fw_device *fw_device_get_by_devt(dev_t devt)
650 651 652
{
	struct fw_device *device;

653
	down_read(&fw_device_rwsem);
654
	device = idr_find(&fw_device_idr, MINOR(devt));
655 656
	if (device)
		fw_device_get(device);
657
	up_read(&fw_device_rwsem);
658 659 660 661

	return device;
}

662 663 664 665
static void fw_device_shutdown(struct work_struct *work)
{
	struct fw_device *device =
		container_of(work, struct fw_device, work.work);
666 667
	int minor = MINOR(device->device.devt);

668
	fw_device_cdev_remove(device);
669 670
	device_for_each_child(&device->device, NULL, shutdown_unit);
	device_unregister(&device->device);
671

672
	down_write(&fw_device_rwsem);
673
	idr_remove(&fw_device_idr, minor);
674
	up_write(&fw_device_rwsem);
675
	fw_device_put(device);
676 677
}

678 679 680 681
static struct device_type fw_device_type = {
	.release	= fw_device_release,
};

682 683
/*
 * These defines control the retry behavior for reading the config
684 685 686 687 688 689
 * 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
690 691
 * are plugged in, they're all getting read within one second.
 */
692

693 694
#define MAX_RETRIES	10
#define RETRY_DELAY	(3 * HZ)
695 696 697 698 699 700
#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);
701
	int minor, err;
702

703 704
	/*
	 * All failure paths here set node->data to NULL, so that we
705
	 * don't try to do device_for_each_child() on a kfree()'d
706 707
	 * device.
	 */
708

709
	if (read_bus_info_block(device, device->generation) < 0) {
710 711
		if (device->config_rom_retries < MAX_RETRIES &&
		    atomic_read(&device->state) == FW_DEVICE_INITIALIZING) {
712 713 714
			device->config_rom_retries++;
			schedule_delayed_work(&device->work, RETRY_DELAY);
		} else {
715
			fw_notify("giving up on config rom for node id %x\n",
716
				  device->node_id);
717 718
			if (device->node == device->card->root_node)
				schedule_delayed_work(&device->card->work, 0);
719 720 721 722 723
			fw_device_release(&device->device);
		}
		return;
	}

724
	err = -ENOMEM;
725 726

	fw_device_get(device);
727
	down_write(&fw_device_rwsem);
728 729
	if (idr_pre_get(&fw_device_idr, GFP_KERNEL))
		err = idr_get_new(&fw_device_idr, device, &minor);
730
	up_write(&fw_device_rwsem);
731

732 733 734
	if (err < 0)
		goto error;

735
	device->device.bus = &fw_bus_type;
736
	device->device.type = &fw_device_type;
737
	device->device.parent = device->card->device;
738
	device->device.devt = MKDEV(fw_cdev_major, minor);
739
	snprintf(device->device.bus_id, sizeof(device->device.bus_id),
740
		 "fw%d", minor);
741

742 743 744
	init_fw_attribute_group(&device->device,
				fw_device_attributes,
				&device->attribute_group);
745 746
	if (device_add(&device->device)) {
		fw_error("Failed to add device.\n");
747
		goto error_with_cdev;
748 749 750 751
	}

	create_units(device);

752 753
	/*
	 * Transition the device to running state.  If it got pulled
754 755 756 757 758
	 * 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
759 760
	 * fw_node_event().
	 */
761
	if (atomic_cmpxchg(&device->state,
762
		    FW_DEVICE_INITIALIZING,
763
		    FW_DEVICE_RUNNING) == FW_DEVICE_SHUTDOWN) {
764
		fw_device_shutdown(work);
765 766 767 768 769 770 771 772 773 774 775 776 777
	} else {
		if (device->config_rom_retries)
			fw_notify("created device %s: GUID %08x%08x, S%d00, "
				  "%d config ROM retries\n",
				  device->device.bus_id,
				  device->config_rom[3], device->config_rom[4],
				  1 << device->max_speed,
				  device->config_rom_retries);
		else
			fw_notify("created device %s: GUID %08x%08x, S%d00\n",
				  device->device.bus_id,
				  device->config_rom[3], device->config_rom[4],
				  1 << device->max_speed);
778
		device->config_rom_retries = 0;
779
	}
780

781 782
	/*
	 * Reschedule the IRM work if we just finished reading the
783 784
	 * root node config rom.  If this races with a bus reset we
	 * just end up running the IRM work a couple of extra times -
785 786
	 * pretty harmless.
	 */
787 788 789 790 791
	if (device->node == device->card->root_node)
		schedule_delayed_work(&device->card->work, 0);

	return;

792
 error_with_cdev:
793
	down_write(&fw_device_rwsem);
794
	idr_remove(&fw_device_idr, minor);
795
	up_write(&fw_device_rwsem);
S
Stefan Richter 已提交
796
 error:
797 798 799
	fw_device_put(device);		/* fw_device_idr's reference */

	put_device(&device->device);	/* our reference */
800 801 802 803 804 805 806
}

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;

807 808
	if (is_fw_unit(dev) && driver != NULL && driver->update != NULL) {
		down(&dev->sem);
809
		driver->update(unit);
810 811
		up(&dev->sem);
	}
812 813 814 815

	return 0;
}

816 817 818 819 820
static void fw_device_update(struct work_struct *work)
{
	struct fw_device *device =
		container_of(work, struct fw_device, work.work);

821
	fw_device_cdev_update(device);
822 823 824
	device_for_each_child(&device->device, NULL, update_unit);
}

825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924
enum {
	REREAD_BIB_ERROR,
	REREAD_BIB_GONE,
	REREAD_BIB_UNCHANGED,
	REREAD_BIB_CHANGED,
};

/* Reread and compare bus info block and header of root directory */
static int reread_bus_info_block(struct fw_device *device, int generation)
{
	u32 q;
	int i;

	for (i = 0; i < 6; i++) {
		if (read_rom(device, generation, i, &q) != RCODE_COMPLETE)
			return REREAD_BIB_ERROR;

		if (i == 0 && q == 0)
			return REREAD_BIB_GONE;

		if (i > device->config_rom_length || q != device->config_rom[i])
			return REREAD_BIB_CHANGED;
	}

	return REREAD_BIB_UNCHANGED;
}

static void fw_device_refresh(struct work_struct *work)
{
	struct fw_device *device =
		container_of(work, struct fw_device, work.work);
	struct fw_card *card = device->card;
	int node_id = device->node_id;

	switch (reread_bus_info_block(device, device->generation)) {
	case REREAD_BIB_ERROR:
		if (device->config_rom_retries < MAX_RETRIES / 2 &&
		    atomic_read(&device->state) == FW_DEVICE_INITIALIZING) {
			device->config_rom_retries++;
			schedule_delayed_work(&device->work, RETRY_DELAY / 2);

			return;
		}
		goto give_up;

	case REREAD_BIB_GONE:
		goto gone;

	case REREAD_BIB_UNCHANGED:
		if (atomic_cmpxchg(&device->state,
			    FW_DEVICE_INITIALIZING,
			    FW_DEVICE_RUNNING) == FW_DEVICE_SHUTDOWN)
			goto gone;

		fw_device_update(work);
		device->config_rom_retries = 0;
		goto out;

	case REREAD_BIB_CHANGED:
		break;
	}

	/*
	 * Something changed.  We keep things simple and don't investigate
	 * further.  We just destroy all previous units and create new ones.
	 */
	device_for_each_child(&device->device, NULL, shutdown_unit);

	if (read_bus_info_block(device, device->generation) < 0) {
		if (device->config_rom_retries < MAX_RETRIES &&
		    atomic_read(&device->state) == FW_DEVICE_INITIALIZING) {
			device->config_rom_retries++;
			schedule_delayed_work(&device->work, RETRY_DELAY);

			return;
		}
		goto give_up;
	}

	create_units(device);

	if (atomic_cmpxchg(&device->state,
		    FW_DEVICE_INITIALIZING,
		    FW_DEVICE_RUNNING) == FW_DEVICE_SHUTDOWN)
		goto gone;

	fw_notify("refreshed device %s\n", device->device.bus_id);
	device->config_rom_retries = 0;
	goto out;

 give_up:
	fw_notify("giving up on refresh of device %s\n", device->device.bus_id);
 gone:
	atomic_set(&device->state, FW_DEVICE_SHUTDOWN);
	fw_device_shutdown(work);
 out:
	if (node_id == card->root_node->node_id)
		schedule_delayed_work(&card->work, 0);
}

925 926 927 928 929 930 931 932 933
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;
934
 create:
935 936 937 938
		device = kzalloc(sizeof(*device), GFP_ATOMIC);
		if (device == NULL)
			break;

939 940
		/*
		 * Do minimal intialization of the device here, the
941 942 943 944
		 * 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
945 946
		 * doesn't freak out.
		 */
947
		device_initialize(&device->device);
948
		atomic_set(&device->state, FW_DEVICE_INITIALIZING);
949 950
		atomic_inc(&card->device_count);
		device->card = card;
951 952 953
		device->node = fw_node_get(node);
		device->node_id = node->node_id;
		device->generation = card->generation;
954
		INIT_LIST_HEAD(&device->client_list);
955

956 957
		/*
		 * Set the node data to point back to this device so
958
		 * FW_NODE_UPDATED callbacks can update the node_id
959 960
		 * and generation for the device.
		 */
961 962
		node->data = device;

963 964
		/*
		 * Many devices are slow to respond after bus resets,
965 966
		 * especially if they are bus powered and go through
		 * power-up after getting plugged in.  We schedule the
967 968
		 * first config rom scan half a second after bus reset.
		 */
969 970 971 972
		INIT_DELAYED_WORK(&device->work, fw_device_init);
		schedule_delayed_work(&device->work, INITIAL_DELAY);
		break;

973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989
	case FW_NODE_INITIATED_RESET:
		device = node->data;
		if (device == NULL)
			goto create;

		device->node_id = node->node_id;
		smp_wmb();  /* update node_id before generation */
		device->generation = card->generation;
		if (atomic_cmpxchg(&device->state,
			    FW_DEVICE_RUNNING,
			    FW_DEVICE_INITIALIZING) == FW_DEVICE_RUNNING) {
			PREPARE_DELAYED_WORK(&device->work, fw_device_refresh);
			schedule_delayed_work(&device->work,
				node == card->local_node ? 0 : INITIAL_DELAY);
		}
		break;

990 991 992 993 994 995
	case FW_NODE_UPDATED:
		if (!node->link_on || node->data == NULL)
			break;

		device = node->data;
		device->node_id = node->node_id;
996
		smp_wmb();  /* update node_id before generation */
997
		device->generation = card->generation;
998 999 1000 1001
		if (atomic_read(&device->state) == FW_DEVICE_RUNNING) {
			PREPARE_DELAYED_WORK(&device->work, fw_device_update);
			schedule_delayed_work(&device->work, 0);
		}
1002 1003 1004 1005 1006 1007 1008
		break;

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

1009 1010
		/*
		 * Destroy the device associated with the node.  There
1011 1012 1013 1014 1015 1016 1017 1018
		 * 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
1019 1020
		 * to create the device.
		 */
1021
		device = node->data;
1022
		if (atomic_xchg(&device->state,
1023 1024
				FW_DEVICE_SHUTDOWN) == FW_DEVICE_RUNNING) {
			PREPARE_DELAYED_WORK(&device->work, fw_device_shutdown);
1025 1026 1027 1028 1029
			schedule_delayed_work(&device->work, 0);
		}
		break;
	}
}