1/* 2 * Device probing and sysfs code. 3 * 4 * Copyright (C) 2005-2006 Kristian Hoegsberg <krh@bitplanet.net> 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; either version 2 of the License, or 9 * (at your option) any later version. 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program; if not, write to the Free Software Foundation, 18 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 19 */ 20 21#include <linux/module.h> 22#include <linux/wait.h> 23#include <linux/errno.h> 24#include <linux/kthread.h> 25#include <linux/device.h> 26#include <linux/delay.h> 27#include <linux/idr.h> 28#include <linux/rwsem.h> 29#include <asm/semaphore.h> 30#include <linux/ctype.h> 31#include "fw-transaction.h" 32#include "fw-topology.h" 33#include "fw-device.h" 34 35void fw_csr_iterator_init(struct fw_csr_iterator *ci, u32 * p) 36{ 37 ci->p = p + 1; 38 ci->end = ci->p + (p[0] >> 16); 39} 40EXPORT_SYMBOL(fw_csr_iterator_init); 41 42int fw_csr_iterator_next(struct fw_csr_iterator *ci, int *key, int *value) 43{ 44 *key = *ci->p >> 24; 45 *value = *ci->p & 0xffffff; 46 47 return ci->p++ < ci->end; 48} 49EXPORT_SYMBOL(fw_csr_iterator_next); 50 51static int is_fw_unit(struct device *dev); 52 53static int match_unit_directory(u32 * directory, const struct fw_device_id *id) 54{ 55 struct fw_csr_iterator ci; 56 int key, value, match; 57 58 match = 0; 59 fw_csr_iterator_init(&ci, directory); 60 while (fw_csr_iterator_next(&ci, &key, &value)) { 61 if (key == CSR_VENDOR && value == id->vendor) 62 match |= FW_MATCH_VENDOR; 63 if (key == CSR_MODEL && value == id->model) 64 match |= FW_MATCH_MODEL; 65 if (key == CSR_SPECIFIER_ID && value == id->specifier_id) 66 match |= FW_MATCH_SPECIFIER_ID; 67 if (key == CSR_VERSION && value == id->version) 68 match |= FW_MATCH_VERSION; 69 } 70 71 return (match & id->match_flags) == id->match_flags; 72} 73 74static int fw_unit_match(struct device *dev, struct device_driver *drv) 75{ 76 struct fw_unit *unit = fw_unit(dev); 77 struct fw_driver *driver = fw_driver(drv); 78 int i; 79 80 /* We only allow binding to fw_units. */ 81 if (!is_fw_unit(dev)) 82 return 0; 83 84 for (i = 0; driver->id_table[i].match_flags != 0; i++) { 85 if (match_unit_directory(unit->directory, &driver->id_table[i])) 86 return 1; 87 } 88 89 return 0; 90} 91 92static int get_modalias(struct fw_unit *unit, char *buffer, size_t buffer_size) 93{ 94 struct fw_device *device = fw_device(unit->device.parent); 95 struct fw_csr_iterator ci; 96 97 int key, value; 98 int vendor = 0; 99 int model = 0; 100 int specifier_id = 0; 101 int version = 0; 102 103 fw_csr_iterator_init(&ci, &device->config_rom[5]); 104 while (fw_csr_iterator_next(&ci, &key, &value)) { 105 switch (key) { 106 case CSR_VENDOR: 107 vendor = value; 108 break; 109 case CSR_MODEL: 110 model = value; 111 break; 112 } 113 } 114 115 fw_csr_iterator_init(&ci, unit->directory); 116 while (fw_csr_iterator_next(&ci, &key, &value)) { 117 switch (key) { 118 case CSR_SPECIFIER_ID: 119 specifier_id = value; 120 break; 121 case CSR_VERSION: 122 version = value; 123 break; 124 } 125 } 126 127 return snprintf(buffer, buffer_size, 128 "ieee1394:ven%08Xmo%08Xsp%08Xver%08X", 129 vendor, model, specifier_id, version); 130} 131 132static int 133fw_unit_uevent(struct device *dev, char **envp, int num_envp, 134 char *buffer, int buffer_size) 135{ 136 struct fw_unit *unit = fw_unit(dev); 137 char modalias[64]; 138 int length = 0; 139 int i = 0; 140 141 get_modalias(unit, modalias, sizeof(modalias)); 142 143 if (add_uevent_var(envp, num_envp, &i, 144 buffer, buffer_size, &length, 145 "MODALIAS=%s", modalias)) 146 return -ENOMEM; 147 148 envp[i] = NULL; 149 150 return 0; 151} 152 153struct bus_type fw_bus_type = { 154 .name = "firewire", 155 .match = fw_unit_match, 156}; 157EXPORT_SYMBOL(fw_bus_type); 158 159struct fw_device *fw_device_get(struct fw_device *device) 160{ 161 get_device(&device->device); 162 163 return device; 164} 165 166void fw_device_put(struct fw_device *device) 167{ 168 put_device(&device->device); 169} 170 171static void fw_device_release(struct device *dev) 172{ 173 struct fw_device *device = fw_device(dev); 174 unsigned long flags; 175 176 /* 177 * Take the card lock so we don't set this to NULL while a 178 * FW_NODE_UPDATED callback is being handled. 179 */ 180 spin_lock_irqsave(&device->card->lock, flags); 181 device->node->data = NULL; 182 spin_unlock_irqrestore(&device->card->lock, flags); 183 184 fw_node_put(device->node); 185 fw_card_put(device->card); 186 kfree(device->config_rom); 187 kfree(device); 188} 189 190int fw_device_enable_phys_dma(struct fw_device *device) 191{ 192 return device->card->driver->enable_phys_dma(device->card, 193 device->node_id, 194 device->generation); 195} 196EXPORT_SYMBOL(fw_device_enable_phys_dma); 197 198struct config_rom_attribute { 199 struct device_attribute attr; 200 u32 key; 201}; 202 203static ssize_t 204show_immediate(struct device *dev, struct device_attribute *dattr, char *buf) 205{ 206 struct config_rom_attribute *attr = 207 container_of(dattr, struct config_rom_attribute, attr); 208 struct fw_csr_iterator ci; 209 u32 *dir; 210 int key, value; 211 212 if (is_fw_unit(dev)) 213 dir = fw_unit(dev)->directory; 214 else 215 dir = fw_device(dev)->config_rom + 5; 216 217 fw_csr_iterator_init(&ci, dir); 218 while (fw_csr_iterator_next(&ci, &key, &value)) 219 if (attr->key == key) 220 return snprintf(buf, buf ? PAGE_SIZE : 0, 221 "0x%06x\n", value); 222 223 return -ENOENT; 224} 225 226#define IMMEDIATE_ATTR(name, key) \ 227 { __ATTR(name, S_IRUGO, show_immediate, NULL), key } 228 229static ssize_t 230show_text_leaf(struct device *dev, struct device_attribute *dattr, char *buf) 231{ 232 struct config_rom_attribute *attr = 233 container_of(dattr, struct config_rom_attribute, attr); 234 struct fw_csr_iterator ci; 235 u32 *dir, *block = NULL, *p, *end; 236 int length, key, value, last_key = 0; 237 char *b; 238 239 if (is_fw_unit(dev)) 240 dir = fw_unit(dev)->directory; 241 else 242 dir = fw_device(dev)->config_rom + 5; 243 244 fw_csr_iterator_init(&ci, dir); 245 while (fw_csr_iterator_next(&ci, &key, &value)) { 246 if (attr->key == last_key && 247 key == (CSR_DESCRIPTOR | CSR_LEAF)) 248 block = ci.p - 1 + value; 249 last_key = key; 250 } 251 252 if (block == NULL) 253 return -ENOENT; 254 255 length = min(block[0] >> 16, 256U); 256 if (length < 3) 257 return -ENOENT; 258 259 if (block[1] != 0 || block[2] != 0) 260 /* Unknown encoding. */ 261 return -ENOENT; 262 263 if (buf == NULL) 264 return length * 4; 265 266 b = buf; 267 end = &block[length + 1]; 268 for (p = &block[3]; p < end; p++, b += 4) 269 * (u32 *) b = (__force u32) __cpu_to_be32(*p); 270 271 /* Strip trailing whitespace and add newline. */ 272 while (b--, (isspace(*b) || *b == '\0') && b > buf); 273 strcpy(b + 1, "\n"); 274 275 return b + 2 - buf; 276} 277 278#define TEXT_LEAF_ATTR(name, key) \ 279 { __ATTR(name, S_IRUGO, show_text_leaf, NULL), key } 280 281static struct config_rom_attribute config_rom_attributes[] = { 282 IMMEDIATE_ATTR(vendor, CSR_VENDOR), 283 IMMEDIATE_ATTR(hardware_version, CSR_HARDWARE_VERSION), 284 IMMEDIATE_ATTR(specifier_id, CSR_SPECIFIER_ID), 285 IMMEDIATE_ATTR(version, CSR_VERSION), 286 IMMEDIATE_ATTR(model, CSR_MODEL), 287 TEXT_LEAF_ATTR(vendor_name, CSR_VENDOR), 288 TEXT_LEAF_ATTR(model_name, CSR_MODEL), 289 TEXT_LEAF_ATTR(hardware_version_name, CSR_HARDWARE_VERSION), 290}; 291 292static void 293init_fw_attribute_group(struct device *dev, 294 struct device_attribute *attrs, 295 struct fw_attribute_group *group) 296{ 297 struct device_attribute *attr; 298 int i, j; 299 300 for (j = 0; attrs[j].attr.name != NULL; j++) 301 group->attrs[j] = &attrs[j].attr; 302 303 for (i = 0; i < ARRAY_SIZE(config_rom_attributes); i++) { 304 attr = &config_rom_attributes[i].attr; 305 if (attr->show(dev, attr, NULL) < 0) 306 continue; 307 group->attrs[j++] = &attr->attr; 308 } 309 310 BUG_ON(j >= ARRAY_SIZE(group->attrs)); 311 group->attrs[j++] = NULL; 312 group->groups[0] = &group->group; 313 group->groups[1] = NULL; 314 group->group.attrs = group->attrs; 315 dev->groups = group->groups; 316} 317 318static ssize_t 319modalias_show(struct device *dev, 320 struct device_attribute *attr, char *buf) 321{ 322 struct fw_unit *unit = fw_unit(dev); 323 int length; 324 325 length = get_modalias(unit, buf, PAGE_SIZE); 326 strcpy(buf + length, "\n"); 327 328 return length + 1; 329} 330 331static ssize_t 332rom_index_show(struct device *dev, 333 struct device_attribute *attr, char *buf) 334{ 335 struct fw_device *device = fw_device(dev->parent); 336 struct fw_unit *unit = fw_unit(dev); 337 338 return snprintf(buf, PAGE_SIZE, "%d\n", 339 (int)(unit->directory - device->config_rom)); 340} 341 342static struct device_attribute fw_unit_attributes[] = { 343 __ATTR_RO(modalias), 344 __ATTR_RO(rom_index), 345 __ATTR_NULL, 346}; 347 348static ssize_t 349config_rom_show(struct device *dev, struct device_attribute *attr, char *buf) 350{ 351 struct fw_device *device = fw_device(dev); 352 353 memcpy(buf, device->config_rom, device->config_rom_length * 4); 354 355 return device->config_rom_length * 4; 356} 357 358static ssize_t 359guid_show(struct device *dev, struct device_attribute *attr, char *buf) 360{ 361 struct fw_device *device = fw_device(dev); 362 u64 guid; 363 364 guid = ((u64)device->config_rom[3] << 32) | device->config_rom[4]; 365 366 return snprintf(buf, PAGE_SIZE, "0x%016llx\n", 367 (unsigned long long)guid); 368} 369 370static struct device_attribute fw_device_attributes[] = { 371 __ATTR_RO(config_rom), 372 __ATTR_RO(guid), 373 __ATTR_NULL, 374}; 375 376struct read_quadlet_callback_data { 377 struct completion done; 378 int rcode; 379 u32 data; 380}; 381 382static void 383complete_transaction(struct fw_card *card, int rcode, 384 void *payload, size_t length, void *data) 385{ 386 struct read_quadlet_callback_data *callback_data = data; 387 388 if (rcode == RCODE_COMPLETE) 389 callback_data->data = be32_to_cpu(*(__be32 *)payload); 390 callback_data->rcode = rcode; 391 complete(&callback_data->done); 392} 393 394static int read_rom(struct fw_device *device, int index, u32 * data) 395{ 396 struct read_quadlet_callback_data callback_data; 397 struct fw_transaction t; 398 u64 offset; 399 400 init_completion(&callback_data.done); 401 402 offset = 0xfffff0000400ULL + index * 4; 403 fw_send_request(device->card, &t, TCODE_READ_QUADLET_REQUEST, 404 device->node_id, 405 device->generation, SCODE_100, 406 offset, NULL, 4, complete_transaction, &callback_data); 407 408 wait_for_completion(&callback_data.done); 409 410 *data = callback_data.data; 411 412 return callback_data.rcode; 413} 414 415static int read_bus_info_block(struct fw_device *device) 416{ 417 static u32 rom[256]; 418 u32 stack[16], sp, key; 419 int i, end, length; 420 421 /* First read the bus info block. */ 422 for (i = 0; i < 5; i++) { 423 if (read_rom(device, i, &rom[i]) != RCODE_COMPLETE) 424 return -1; 425 /* 426 * As per IEEE1212 7.2, during power-up, devices can 427 * reply with a 0 for the first quadlet of the config 428 * rom to indicate that they are booting (for example, 429 * if the firmware is on the disk of a external 430 * harddisk). In that case we just fail, and the 431 * retry mechanism will try again later. 432 */ 433 if (i == 0 && rom[i] == 0) 434 return -1; 435 } 436 437 /* 438 * Now parse the config rom. The config rom is a recursive 439 * directory structure so we parse it using a stack of 440 * references to the blocks that make up the structure. We 441 * push a reference to the root directory on the stack to 442 * start things off. 443 */ 444 length = i; 445 sp = 0; 446 stack[sp++] = 0xc0000005; 447 while (sp > 0) { 448 /* 449 * Pop the next block reference of the stack. The 450 * lower 24 bits is the offset into the config rom, 451 * the upper 8 bits are the type of the reference the 452 * block. 453 */ 454 key = stack[--sp]; 455 i = key & 0xffffff; 456 if (i >= ARRAY_SIZE(rom)) 457 /* 458 * The reference points outside the standard 459 * config rom area, something's fishy. 460 */ 461 return -1; 462 463 /* Read header quadlet for the block to get the length. */ 464 if (read_rom(device, i, &rom[i]) != RCODE_COMPLETE) 465 return -1; 466 end = i + (rom[i] >> 16) + 1; 467 i++; 468 if (end > ARRAY_SIZE(rom)) 469 /* 470 * This block extends outside standard config 471 * area (and the array we're reading it 472 * into). That's broken, so ignore this 473 * device. 474 */ 475 return -1; 476 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 * it references another block, and push it in that case. 481 */ 482 while (i < end) { 483 if (read_rom(device, i, &rom[i]) != RCODE_COMPLETE) 484 return -1; 485 if ((key >> 30) == 3 && (rom[i] >> 30) > 1 && 486 sp < ARRAY_SIZE(stack)) 487 stack[sp++] = i + rom[i]; 488 i++; 489 } 490 if (length < i) 491 length = i; 492 } 493 494 device->config_rom = kmalloc(length * 4, GFP_KERNEL); 495 if (device->config_rom == NULL) 496 return -1; 497 memcpy(device->config_rom, rom, length * 4); 498 device->config_rom_length = length; 499 500 return 0; 501} 502 503static void fw_unit_release(struct device *dev) 504{ 505 struct fw_unit *unit = fw_unit(dev); 506 507 kfree(unit); 508} 509 510static struct device_type fw_unit_type = { 511 .uevent = fw_unit_uevent, 512 .release = fw_unit_release, 513}; 514 515static int is_fw_unit(struct device *dev) 516{ 517 return dev->type == &fw_unit_type; 518} 519 520static void create_units(struct fw_device *device) 521{ 522 struct fw_csr_iterator ci; 523 struct fw_unit *unit; 524 int key, value, i; 525 526 i = 0; 527 fw_csr_iterator_init(&ci, &device->config_rom[5]); 528 while (fw_csr_iterator_next(&ci, &key, &value)) { 529 if (key != (CSR_UNIT | CSR_DIRECTORY)) 530 continue; 531 532 /* 533 * Get the address of the unit directory and try to 534 * match the drivers id_tables against it. 535 */ 536 unit = kzalloc(sizeof(*unit), GFP_KERNEL); 537 if (unit == NULL) { 538 fw_error("failed to allocate memory for unit\n"); 539 continue; 540 } 541 542 unit->directory = ci.p + value - 1; 543 unit->device.bus = &fw_bus_type; 544 unit->device.type = &fw_unit_type; 545 unit->device.parent = &device->device; 546 snprintf(unit->device.bus_id, sizeof(unit->device.bus_id), 547 "%s.%d", device->device.bus_id, i++); 548 549 init_fw_attribute_group(&unit->device, 550 fw_unit_attributes, 551 &unit->attribute_group); 552 if (device_register(&unit->device) < 0) 553 goto skip_unit; 554 555 continue; 556 557 skip_unit: 558 kfree(unit); 559 } 560} 561 562static int shutdown_unit(struct device *device, void *data) 563{ 564 device_unregister(device); 565 566 return 0; 567} 568 569static DECLARE_RWSEM(idr_rwsem); 570static DEFINE_IDR(fw_device_idr); 571int fw_cdev_major; 572 573struct fw_device *fw_device_from_devt(dev_t devt) 574{ 575 struct fw_device *device; 576 577 down_read(&idr_rwsem); 578 device = idr_find(&fw_device_idr, MINOR(devt)); 579 up_read(&idr_rwsem); 580 581 return device; 582} 583 584static void fw_device_shutdown(struct work_struct *work) 585{ 586 struct fw_device *device = 587 container_of(work, struct fw_device, work.work); 588 int minor = MINOR(device->device.devt); 589 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 device_for_each_child(&device->device, NULL, shutdown_unit); 596 device_unregister(&device->device); 597} 598 599static struct device_type fw_device_type = { 600 .release = fw_device_release, 601}; 602 603/* 604 * These defines control the retry behavior for reading the config 605 * rom. It shouldn't be necessary to tweak these; if the device 606 * doesn't respond to a config rom read within 10 seconds, it's not 607 * going to respond at all. As for the initial delay, a lot of 608 * devices will be able to respond within half a second after bus 609 * reset. On the other hand, it's not really worth being more 610 * aggressive than that, since it scales pretty well; if 10 devices 611 * are plugged in, they're all getting read within one second. 612 */ 613 614#define MAX_RETRIES 10 615#define RETRY_DELAY (3 * HZ) 616#define INITIAL_DELAY (HZ / 2) 617 618static void fw_device_init(struct work_struct *work) 619{ 620 struct fw_device *device = 621 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 * device. 628 */ 629 630 if (read_bus_info_block(device) < 0) { 631 if (device->config_rom_retries < MAX_RETRIES) { 632 device->config_rom_retries++; 633 schedule_delayed_work(&device->work, RETRY_DELAY); 634 } else { 635 fw_notify("giving up on config rom for node id %x\n", 636 device->node_id); 637 if (device->node == device->card->root_node) 638 schedule_delayed_work(&device->card->work, 0); 639 fw_device_release(&device->device); 640 } 641 return; 642 } 643 644 err = -ENOMEM; 645 down_write(&idr_rwsem); 646 if (idr_pre_get(&fw_device_idr, GFP_KERNEL)) 647 err = idr_get_new(&fw_device_idr, device, &minor); 648 up_write(&idr_rwsem); 649 if (err < 0) 650 goto error; 651 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 init_fw_attribute_group(&device->device, 660 fw_device_attributes, 661 &device->attribute_group); 662 if (device_add(&device->device)) { 663 fw_error("Failed to add device.\n"); 664 goto error_with_cdev; 665 } 666 667 create_units(device); 668 669 /* 670 * Transition the device to running state. If it got pulled 671 * out from under us while we did the intialization work, we 672 * have to shut down the device again here. Normally, though, 673 * fw_node_event will be responsible for shutting it down when 674 * necessary. We have to use the atomic cmpxchg here to avoid 675 * racing with the FW_NODE_DESTROYED case in 676 * fw_node_event(). 677 */ 678 if (atomic_cmpxchg(&device->state, 679 FW_DEVICE_INITIALIZING, 680 FW_DEVICE_RUNNING) == FW_DEVICE_SHUTDOWN) 681 fw_device_shutdown(&device->work.work); 682 else 683 fw_notify("created new fw device %s (%d config rom retries)\n", 684 device->device.bus_id, device->config_rom_retries); 685 686 /* 687 * Reschedule the IRM work if we just finished reading the 688 * root node config rom. If this races with a bus reset we 689 * just end up running the IRM work a couple of extra times - 690 * pretty harmless. 691 */ 692 if (device->node == device->card->root_node) 693 schedule_delayed_work(&device->card->work, 0); 694 695 return; 696 697 error_with_cdev: 698 down_write(&idr_rwsem); 699 idr_remove(&fw_device_idr, minor); 700 up_write(&idr_rwsem); 701 error: 702 put_device(&device->device); 703} 704 705static int update_unit(struct device *dev, void *data) 706{ 707 struct fw_unit *unit = fw_unit(dev); 708 struct fw_driver *driver = (struct fw_driver *)dev->driver; 709 710 if (is_fw_unit(dev) && driver != NULL && driver->update != NULL) { 711 down(&dev->sem); 712 driver->update(unit); 713 up(&dev->sem); 714 } 715 716 return 0; 717} 718 719static void fw_device_update(struct work_struct *work) 720{ 721 struct fw_device *device = 722 container_of(work, struct fw_device, work.work); 723 724 fw_device_cdev_update(device); 725 device_for_each_child(&device->device, NULL, update_unit); 726} 727 728void fw_node_event(struct fw_card *card, struct fw_node *node, int event) 729{ 730 struct fw_device *device; 731 732 switch (event) { 733 case FW_NODE_CREATED: 734 case FW_NODE_LINK_ON: 735 if (!node->link_on) 736 break; 737 738 device = kzalloc(sizeof(*device), GFP_ATOMIC); 739 if (device == NULL) 740 break; 741 742 /* 743 * Do minimal intialization of the device here, the 744 * rest will happen in fw_device_init(). We need the 745 * card and node so we can read the config rom and we 746 * need to do device_initialize() now so 747 * device_for_each_child() in FW_NODE_UPDATED is 748 * doesn't freak out. 749 */ 750 device_initialize(&device->device); 751 atomic_set(&device->state, FW_DEVICE_INITIALIZING); 752 device->card = fw_card_get(card); 753 device->node = fw_node_get(node); 754 device->node_id = node->node_id; 755 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 * and generation for the device. 762 */ 763 node->data = device; 764 765 /* 766 * Many devices are slow to respond after bus resets, 767 * especially if they are bus powered and go through 768 * power-up after getting plugged in. We schedule the 769 * first config rom scan half a second after bus reset. 770 */ 771 INIT_DELAYED_WORK(&device->work, fw_device_init); 772 schedule_delayed_work(&device->work, INITIAL_DELAY); 773 break; 774 775 case FW_NODE_UPDATED: 776 if (!node->link_on || node->data == NULL) 777 break; 778 779 device = node->data; 780 device->node_id = node->node_id; 781 device->generation = card->generation; 782 if (atomic_read(&device->state) == FW_DEVICE_RUNNING) { 783 PREPARE_DELAYED_WORK(&device->work, fw_device_update); 784 schedule_delayed_work(&device->work, 0); 785 } 786 break; 787 788 case FW_NODE_DESTROYED: 789 case FW_NODE_LINK_OFF: 790 if (!node->data) 791 break; 792 793 /* 794 * Destroy the device associated with the node. There 795 * are two cases here: either the device is fully 796 * initialized (FW_DEVICE_RUNNING) or we're in the 797 * process of reading its config rom 798 * (FW_DEVICE_INITIALIZING). If it is fully 799 * initialized we can reuse device->work to schedule a 800 * full fw_device_shutdown(). If not, there's work 801 * scheduled to read it's config rom, and we just put 802 * the device in shutdown state to have that code fail 803 * to create the device. 804 */ 805 device = node->data; 806 if (atomic_xchg(&device->state, 807 FW_DEVICE_SHUTDOWN) == FW_DEVICE_RUNNING) { 808 PREPARE_DELAYED_WORK(&device->work, fw_device_shutdown); 809 schedule_delayed_work(&device->work, 0); 810 } 811 break; 812 } 813} 814