1/* 2 * Copyright (C) 2005-2007 Kristian Hoegsberg <krh@bitplanet.net> 3 * 4 * This program is free software; you can redistribute it and/or modify 5 * it under the terms of the GNU General Public License as published by 6 * the Free Software Foundation; either version 2 of the License, or 7 * (at your option) any later version. 8 * 9 * This program is distributed in the hope that it will be useful, 10 * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 * GNU General Public License for more details. 13 * 14 * You should have received a copy of the GNU General Public License 15 * along with this program; if not, write to the Free Software Foundation, 16 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 17 */ 18 19#include <linux/bug.h> 20#include <linux/completion.h> 21#include <linux/crc-itu-t.h> 22#include <linux/device.h> 23#include <linux/errno.h> 24#include <linux/firewire.h> 25#include <linux/firewire-constants.h> 26#include <linux/jiffies.h> 27#include <linux/kernel.h> 28#include <linux/kref.h> 29#include <linux/list.h> 30#include <linux/module.h> 31#include <linux/mutex.h> 32#include <linux/spinlock.h> 33#include <linux/workqueue.h> 34 35#include <linux/atomic.h> 36#include <asm/byteorder.h> 37 38#include "core.h" 39 40#define define_fw_printk_level(func, kern_level) \ 41void func(const struct fw_card *card, const char *fmt, ...) \ 42{ \ 43 struct va_format vaf; \ 44 va_list args; \ 45 \ 46 va_start(args, fmt); \ 47 vaf.fmt = fmt; \ 48 vaf.va = &args; \ 49 printk(kern_level KBUILD_MODNAME " %s: %pV", \ 50 dev_name(card->device), &vaf); \ 51 va_end(args); \ 52} 53define_fw_printk_level(fw_err, KERN_ERR); 54define_fw_printk_level(fw_notice, KERN_NOTICE); 55 56int fw_compute_block_crc(__be32 *block) 57{ 58 int length; 59 u16 crc; 60 61 length = (be32_to_cpu(block[0]) >> 16) & 0xff; 62 crc = crc_itu_t(0, (u8 *)&block[1], length * 4); 63 *block |= cpu_to_be32(crc); 64 65 return length; 66} 67 68static DEFINE_MUTEX(card_mutex); 69static LIST_HEAD(card_list); 70 71static LIST_HEAD(descriptor_list); 72static int descriptor_count; 73 74static __be32 tmp_config_rom[256]; 75/* ROM header, bus info block, root dir header, capabilities = 7 quadlets */ 76static size_t config_rom_length = 1 + 4 + 1 + 1; 77 78#define BIB_CRC(v) ((v) << 0) 79#define BIB_CRC_LENGTH(v) ((v) << 16) 80#define BIB_INFO_LENGTH(v) ((v) << 24) 81#define BIB_BUS_NAME 0x31333934 /* "1394" */ 82#define BIB_LINK_SPEED(v) ((v) << 0) 83#define BIB_GENERATION(v) ((v) << 4) 84#define BIB_MAX_ROM(v) ((v) << 8) 85#define BIB_MAX_RECEIVE(v) ((v) << 12) 86#define BIB_CYC_CLK_ACC(v) ((v) << 16) 87#define BIB_PMC ((1) << 27) 88#define BIB_BMC ((1) << 28) 89#define BIB_ISC ((1) << 29) 90#define BIB_CMC ((1) << 30) 91#define BIB_IRMC ((1) << 31) 92#define NODE_CAPABILITIES 0x0c0083c0 /* per IEEE 1394 clause 8.3.2.6.5.2 */ 93 94/* 95 * IEEE-1394 specifies a default SPLIT_TIMEOUT value of 800 cycles (100 ms), 96 * but we have to make it longer because there are many devices whose firmware 97 * is just too slow for that. 98 */ 99#define DEFAULT_SPLIT_TIMEOUT (2 * 8000) 100 101#define CANON_OUI 0x000085 102 103static void generate_config_rom(struct fw_card *card, __be32 *config_rom) 104{ 105 struct fw_descriptor *desc; 106 int i, j, k, length; 107 108 /* 109 * Initialize contents of config rom buffer. On the OHCI 110 * controller, block reads to the config rom accesses the host 111 * memory, but quadlet read access the hardware bus info block 112 * registers. That's just crack, but it means we should make 113 * sure the contents of bus info block in host memory matches 114 * the version stored in the OHCI registers. 115 */ 116 117 config_rom[0] = cpu_to_be32( 118 BIB_CRC_LENGTH(4) | BIB_INFO_LENGTH(4) | BIB_CRC(0)); 119 config_rom[1] = cpu_to_be32(BIB_BUS_NAME); 120 config_rom[2] = cpu_to_be32( 121 BIB_LINK_SPEED(card->link_speed) | 122 BIB_GENERATION(card->config_rom_generation++ % 14 + 2) | 123 BIB_MAX_ROM(2) | 124 BIB_MAX_RECEIVE(card->max_receive) | 125 BIB_BMC | BIB_ISC | BIB_CMC | BIB_IRMC); 126 config_rom[3] = cpu_to_be32(card->guid >> 32); 127 config_rom[4] = cpu_to_be32(card->guid); 128 129 /* Generate root directory. */ 130 config_rom[6] = cpu_to_be32(NODE_CAPABILITIES); 131 i = 7; 132 j = 7 + descriptor_count; 133 134 /* Generate root directory entries for descriptors. */ 135 list_for_each_entry (desc, &descriptor_list, link) { 136 if (desc->immediate > 0) 137 config_rom[i++] = cpu_to_be32(desc->immediate); 138 config_rom[i] = cpu_to_be32(desc->key | (j - i)); 139 i++; 140 j += desc->length; 141 } 142 143 /* Update root directory length. */ 144 config_rom[5] = cpu_to_be32((i - 5 - 1) << 16); 145 146 /* End of root directory, now copy in descriptors. */ 147 list_for_each_entry (desc, &descriptor_list, link) { 148 for (k = 0; k < desc->length; k++) 149 config_rom[i + k] = cpu_to_be32(desc->data[k]); 150 i += desc->length; 151 } 152 153 /* Calculate CRCs for all blocks in the config rom. This 154 * assumes that CRC length and info length are identical for 155 * the bus info block, which is always the case for this 156 * implementation. */ 157 for (i = 0; i < j; i += length + 1) 158 length = fw_compute_block_crc(config_rom + i); 159 160 WARN_ON(j != config_rom_length); 161} 162 163static void update_config_roms(void) 164{ 165 struct fw_card *card; 166 167 list_for_each_entry (card, &card_list, link) { 168 generate_config_rom(card, tmp_config_rom); 169 card->driver->set_config_rom(card, tmp_config_rom, 170 config_rom_length); 171 } 172} 173 174static size_t required_space(struct fw_descriptor *desc) 175{ 176 /* descriptor + entry into root dir + optional immediate entry */ 177 return desc->length + 1 + (desc->immediate > 0 ? 1 : 0); 178} 179 180int fw_core_add_descriptor(struct fw_descriptor *desc) 181{ 182 size_t i; 183 int ret; 184 185 /* 186 * Check descriptor is valid; the length of all blocks in the 187 * descriptor has to add up to exactly the length of the 188 * block. 189 */ 190 i = 0; 191 while (i < desc->length) 192 i += (desc->data[i] >> 16) + 1; 193 194 if (i != desc->length) 195 return -EINVAL; 196 197 mutex_lock(&card_mutex); 198 199 if (config_rom_length + required_space(desc) > 256) { 200 ret = -EBUSY; 201 } else { 202 list_add_tail(&desc->link, &descriptor_list); 203 config_rom_length += required_space(desc); 204 descriptor_count++; 205 if (desc->immediate > 0) 206 descriptor_count++; 207 update_config_roms(); 208 ret = 0; 209 } 210 211 mutex_unlock(&card_mutex); 212 213 return ret; 214} 215EXPORT_SYMBOL(fw_core_add_descriptor); 216 217void fw_core_remove_descriptor(struct fw_descriptor *desc) 218{ 219 mutex_lock(&card_mutex); 220 221 list_del(&desc->link); 222 config_rom_length -= required_space(desc); 223 descriptor_count--; 224 if (desc->immediate > 0) 225 descriptor_count--; 226 update_config_roms(); 227 228 mutex_unlock(&card_mutex); 229} 230EXPORT_SYMBOL(fw_core_remove_descriptor); 231 232static int reset_bus(struct fw_card *card, bool short_reset) 233{ 234 int reg = short_reset ? 5 : 1; 235 int bit = short_reset ? PHY_BUS_SHORT_RESET : PHY_BUS_RESET; 236 237 return card->driver->update_phy_reg(card, reg, 0, bit); 238} 239 240void fw_schedule_bus_reset(struct fw_card *card, bool delayed, bool short_reset) 241{ 242 /* We don't try hard to sort out requests of long vs. short resets. */ 243 card->br_short = short_reset; 244 245 /* Use an arbitrary short delay to combine multiple reset requests. */ 246 fw_card_get(card); 247 if (!queue_delayed_work(fw_workqueue, &card->br_work, 248 delayed ? DIV_ROUND_UP(HZ, 100) : 0)) 249 fw_card_put(card); 250} 251EXPORT_SYMBOL(fw_schedule_bus_reset); 252 253static void br_work(struct work_struct *work) 254{ 255 struct fw_card *card = container_of(work, struct fw_card, br_work.work); 256 257 /* Delay for 2s after last reset per IEEE 1394 clause 8.2.1. */ 258 if (card->reset_jiffies != 0 && 259 time_before64(get_jiffies_64(), card->reset_jiffies + 2 * HZ)) { 260 if (!queue_delayed_work(fw_workqueue, &card->br_work, 2 * HZ)) 261 fw_card_put(card); 262 return; 263 } 264 265 fw_send_phy_config(card, FW_PHY_CONFIG_NO_NODE_ID, card->generation, 266 FW_PHY_CONFIG_CURRENT_GAP_COUNT); 267 reset_bus(card, card->br_short); 268 fw_card_put(card); 269} 270 271static void allocate_broadcast_channel(struct fw_card *card, int generation) 272{ 273 int channel, bandwidth = 0; 274 275 if (!card->broadcast_channel_allocated) { 276 fw_iso_resource_manage(card, generation, 1ULL << 31, 277 &channel, &bandwidth, true); 278 if (channel != 31) { 279 fw_notice(card, "failed to allocate broadcast channel\n"); 280 return; 281 } 282 card->broadcast_channel_allocated = true; 283 } 284 285 device_for_each_child(card->device, (void *)(long)generation, 286 fw_device_set_broadcast_channel); 287} 288 289static const char gap_count_table[] = { 290 63, 5, 7, 8, 10, 13, 16, 18, 21, 24, 26, 29, 32, 35, 37, 40 291}; 292 293void fw_schedule_bm_work(struct fw_card *card, unsigned long delay) 294{ 295 fw_card_get(card); 296 if (!schedule_delayed_work(&card->bm_work, delay)) 297 fw_card_put(card); 298} 299 300static void bm_work(struct work_struct *work) 301{ 302 struct fw_card *card = container_of(work, struct fw_card, bm_work.work); 303 struct fw_device *root_device, *irm_device; 304 struct fw_node *root_node; 305 int root_id, new_root_id, irm_id, bm_id, local_id; 306 int gap_count, generation, grace, rcode; 307 bool do_reset = false; 308 bool root_device_is_running; 309 bool root_device_is_cmc; 310 bool irm_is_1394_1995_only; 311 bool keep_this_irm; 312 __be32 transaction_data[2]; 313 314 spin_lock_irq(&card->lock); 315 316 if (card->local_node == NULL) { 317 spin_unlock_irq(&card->lock); 318 goto out_put_card; 319 } 320 321 generation = card->generation; 322 323 root_node = card->root_node; 324 fw_node_get(root_node); 325 root_device = root_node->data; 326 root_device_is_running = root_device && 327 atomic_read(&root_device->state) == FW_DEVICE_RUNNING; 328 root_device_is_cmc = root_device && root_device->cmc; 329 330 irm_device = card->irm_node->data; 331 irm_is_1394_1995_only = irm_device && irm_device->config_rom && 332 (irm_device->config_rom[2] & 0x000000f0) == 0; 333 334 /* Canon MV5i works unreliably if it is not root node. */ 335 keep_this_irm = irm_device && irm_device->config_rom && 336 irm_device->config_rom[3] >> 8 == CANON_OUI; 337 338 root_id = root_node->node_id; 339 irm_id = card->irm_node->node_id; 340 local_id = card->local_node->node_id; 341 342 grace = time_after64(get_jiffies_64(), 343 card->reset_jiffies + DIV_ROUND_UP(HZ, 8)); 344 345 if ((is_next_generation(generation, card->bm_generation) && 346 !card->bm_abdicate) || 347 (card->bm_generation != generation && grace)) { 348 /* 349 * This first step is to figure out who is IRM and 350 * then try to become bus manager. If the IRM is not 351 * well defined (e.g. does not have an active link 352 * layer or does not responds to our lock request, we 353 * will have to do a little vigilante bus management. 354 * In that case, we do a goto into the gap count logic 355 * so that when we do the reset, we still optimize the 356 * gap count. That could well save a reset in the 357 * next generation. 358 */ 359 360 if (!card->irm_node->link_on) { 361 new_root_id = local_id; 362 fw_notice(card, "%s, making local node (%02x) root\n", 363 "IRM has link off", new_root_id); 364 goto pick_me; 365 } 366 367 if (irm_is_1394_1995_only && !keep_this_irm) { 368 new_root_id = local_id; 369 fw_notice(card, "%s, making local node (%02x) root\n", 370 "IRM is not 1394a compliant", new_root_id); 371 goto pick_me; 372 } 373 374 transaction_data[0] = cpu_to_be32(0x3f); 375 transaction_data[1] = cpu_to_be32(local_id); 376 377 spin_unlock_irq(&card->lock); 378 379 rcode = fw_run_transaction(card, TCODE_LOCK_COMPARE_SWAP, 380 irm_id, generation, SCODE_100, 381 CSR_REGISTER_BASE + CSR_BUS_MANAGER_ID, 382 transaction_data, 8); 383 384 if (rcode == RCODE_GENERATION) 385 /* Another bus reset, BM work has been rescheduled. */ 386 goto out; 387 388 bm_id = be32_to_cpu(transaction_data[0]); 389 390 spin_lock_irq(&card->lock); 391 if (rcode == RCODE_COMPLETE && generation == card->generation) 392 card->bm_node_id = 393 bm_id == 0x3f ? local_id : 0xffc0 | bm_id; 394 spin_unlock_irq(&card->lock); 395 396 if (rcode == RCODE_COMPLETE && bm_id != 0x3f) { 397 /* Somebody else is BM. Only act as IRM. */ 398 if (local_id == irm_id) 399 allocate_broadcast_channel(card, generation); 400 401 goto out; 402 } 403 404 if (rcode == RCODE_SEND_ERROR) { 405 /* 406 * We have been unable to send the lock request due to 407 * some local problem. Let's try again later and hope 408 * that the problem has gone away by then. 409 */ 410 fw_schedule_bm_work(card, DIV_ROUND_UP(HZ, 8)); 411 goto out; 412 } 413 414 spin_lock_irq(&card->lock); 415 416 if (rcode != RCODE_COMPLETE && !keep_this_irm) { 417 /* 418 * The lock request failed, maybe the IRM 419 * isn't really IRM capable after all. Let's 420 * do a bus reset and pick the local node as 421 * root, and thus, IRM. 422 */ 423 new_root_id = local_id; 424 fw_notice(card, "%s, making local node (%02x) root\n", 425 "BM lock failed", new_root_id); 426 goto pick_me; 427 } 428 } else if (card->bm_generation != generation) { 429 /* 430 * We weren't BM in the last generation, and the last 431 * bus reset is less than 125ms ago. Reschedule this job. 432 */ 433 spin_unlock_irq(&card->lock); 434 fw_schedule_bm_work(card, DIV_ROUND_UP(HZ, 8)); 435 goto out; 436 } 437 438 /* 439 * We're bus manager for this generation, so next step is to 440 * make sure we have an active cycle master and do gap count 441 * optimization. 442 */ 443 card->bm_generation = generation; 444 445 if (root_device == NULL) { 446 /* 447 * Either link_on is false, or we failed to read the 448 * config rom. In either case, pick another root. 449 */ 450 new_root_id = local_id; 451 } else if (!root_device_is_running) { 452 /* 453 * If we haven't probed this device yet, bail out now 454 * and let's try again once that's done. 455 */ 456 spin_unlock_irq(&card->lock); 457 goto out; 458 } else if (root_device_is_cmc) { 459 /* 460 * We will send out a force root packet for this 461 * node as part of the gap count optimization. 462 */ 463 new_root_id = root_id; 464 } else { 465 /* 466 * Current root has an active link layer and we 467 * successfully read the config rom, but it's not 468 * cycle master capable. 469 */ 470 new_root_id = local_id; 471 } 472 473 pick_me: 474 /* 475 * Pick a gap count from 1394a table E-1. The table doesn't cover 476 * the typically much larger 1394b beta repeater delays though. 477 */ 478 if (!card->beta_repeaters_present && 479 root_node->max_hops < ARRAY_SIZE(gap_count_table)) 480 gap_count = gap_count_table[root_node->max_hops]; 481 else 482 gap_count = 63; 483 484 /* 485 * Finally, figure out if we should do a reset or not. If we have 486 * done less than 5 resets with the same physical topology and we 487 * have either a new root or a new gap count setting, let's do it. 488 */ 489 490 if (card->bm_retries++ < 5 && 491 (card->gap_count != gap_count || new_root_id != root_id)) 492 do_reset = true; 493 494 spin_unlock_irq(&card->lock); 495 496 if (do_reset) { 497 fw_notice(card, "phy config: new root=%x, gap_count=%d\n", 498 new_root_id, gap_count); 499 fw_send_phy_config(card, new_root_id, generation, gap_count); 500 reset_bus(card, true); 501 /* Will allocate broadcast channel after the reset. */ 502 goto out; 503 } 504 505 if (root_device_is_cmc) { 506 /* 507 * Make sure that the cycle master sends cycle start packets. 508 */ 509 transaction_data[0] = cpu_to_be32(CSR_STATE_BIT_CMSTR); 510 rcode = fw_run_transaction(card, TCODE_WRITE_QUADLET_REQUEST, 511 root_id, generation, SCODE_100, 512 CSR_REGISTER_BASE + CSR_STATE_SET, 513 transaction_data, 4); 514 if (rcode == RCODE_GENERATION) 515 goto out; 516 } 517 518 if (local_id == irm_id) 519 allocate_broadcast_channel(card, generation); 520 521 out: 522 fw_node_put(root_node); 523 out_put_card: 524 fw_card_put(card); 525} 526 527void fw_card_initialize(struct fw_card *card, 528 const struct fw_card_driver *driver, 529 struct device *device) 530{ 531 static atomic_t index = ATOMIC_INIT(-1); 532 533 card->index = atomic_inc_return(&index); 534 card->driver = driver; 535 card->device = device; 536 card->current_tlabel = 0; 537 card->tlabel_mask = 0; 538 card->split_timeout_hi = DEFAULT_SPLIT_TIMEOUT / 8000; 539 card->split_timeout_lo = (DEFAULT_SPLIT_TIMEOUT % 8000) << 19; 540 card->split_timeout_cycles = DEFAULT_SPLIT_TIMEOUT; 541 card->split_timeout_jiffies = 542 DIV_ROUND_UP(DEFAULT_SPLIT_TIMEOUT * HZ, 8000); 543 card->color = 0; 544 card->broadcast_channel = BROADCAST_CHANNEL_INITIAL; 545 546 kref_init(&card->kref); 547 init_completion(&card->done); 548 INIT_LIST_HEAD(&card->transaction_list); 549 INIT_LIST_HEAD(&card->phy_receiver_list); 550 spin_lock_init(&card->lock); 551 552 card->local_node = NULL; 553 554 INIT_DELAYED_WORK(&card->br_work, br_work); 555 INIT_DELAYED_WORK(&card->bm_work, bm_work); 556} 557EXPORT_SYMBOL(fw_card_initialize); 558 559int fw_card_add(struct fw_card *card, 560 u32 max_receive, u32 link_speed, u64 guid) 561{ 562 int ret; 563 564 card->max_receive = max_receive; 565 card->link_speed = link_speed; 566 card->guid = guid; 567 568 mutex_lock(&card_mutex); 569 570 generate_config_rom(card, tmp_config_rom); 571 ret = card->driver->enable(card, tmp_config_rom, config_rom_length); 572 if (ret == 0) 573 list_add_tail(&card->link, &card_list); 574 575 mutex_unlock(&card_mutex); 576 577 return ret; 578} 579EXPORT_SYMBOL(fw_card_add); 580 581/* 582 * The next few functions implement a dummy driver that is used once a card 583 * driver shuts down an fw_card. This allows the driver to cleanly unload, 584 * as all IO to the card will be handled (and failed) by the dummy driver 585 * instead of calling into the module. Only functions for iso context 586 * shutdown still need to be provided by the card driver. 587 * 588 * .read/write_csr() should never be called anymore after the dummy driver 589 * was bound since they are only used within request handler context. 590 * .set_config_rom() is never called since the card is taken out of card_list 591 * before switching to the dummy driver. 592 */ 593 594static int dummy_read_phy_reg(struct fw_card *card, int address) 595{ 596 return -ENODEV; 597} 598 599static int dummy_update_phy_reg(struct fw_card *card, int address, 600 int clear_bits, int set_bits) 601{ 602 return -ENODEV; 603} 604 605static void dummy_send_request(struct fw_card *card, struct fw_packet *packet) 606{ 607 packet->callback(packet, card, RCODE_CANCELLED); 608} 609 610static void dummy_send_response(struct fw_card *card, struct fw_packet *packet) 611{ 612 packet->callback(packet, card, RCODE_CANCELLED); 613} 614 615static int dummy_cancel_packet(struct fw_card *card, struct fw_packet *packet) 616{ 617 return -ENOENT; 618} 619 620static int dummy_enable_phys_dma(struct fw_card *card, 621 int node_id, int generation) 622{ 623 return -ENODEV; 624} 625 626static struct fw_iso_context *dummy_allocate_iso_context(struct fw_card *card, 627 int type, int channel, size_t header_size) 628{ 629 return ERR_PTR(-ENODEV); 630} 631 632static int dummy_start_iso(struct fw_iso_context *ctx, 633 s32 cycle, u32 sync, u32 tags) 634{ 635 return -ENODEV; 636} 637 638static int dummy_set_iso_channels(struct fw_iso_context *ctx, u64 *channels) 639{ 640 return -ENODEV; 641} 642 643static int dummy_queue_iso(struct fw_iso_context *ctx, struct fw_iso_packet *p, 644 struct fw_iso_buffer *buffer, unsigned long payload) 645{ 646 return -ENODEV; 647} 648 649static void dummy_flush_queue_iso(struct fw_iso_context *ctx) 650{ 651} 652 653static int dummy_flush_iso_completions(struct fw_iso_context *ctx) 654{ 655 return -ENODEV; 656} 657 658static const struct fw_card_driver dummy_driver_template = { 659 .read_phy_reg = dummy_read_phy_reg, 660 .update_phy_reg = dummy_update_phy_reg, 661 .send_request = dummy_send_request, 662 .send_response = dummy_send_response, 663 .cancel_packet = dummy_cancel_packet, 664 .enable_phys_dma = dummy_enable_phys_dma, 665 .allocate_iso_context = dummy_allocate_iso_context, 666 .start_iso = dummy_start_iso, 667 .set_iso_channels = dummy_set_iso_channels, 668 .queue_iso = dummy_queue_iso, 669 .flush_queue_iso = dummy_flush_queue_iso, 670 .flush_iso_completions = dummy_flush_iso_completions, 671}; 672 673void fw_card_release(struct kref *kref) 674{ 675 struct fw_card *card = container_of(kref, struct fw_card, kref); 676 677 complete(&card->done); 678} 679 680void fw_core_remove_card(struct fw_card *card) 681{ 682 struct fw_card_driver dummy_driver = dummy_driver_template; 683 684 card->driver->update_phy_reg(card, 4, 685 PHY_LINK_ACTIVE | PHY_CONTENDER, 0); 686 fw_schedule_bus_reset(card, false, true); 687 688 mutex_lock(&card_mutex); 689 list_del_init(&card->link); 690 mutex_unlock(&card_mutex); 691 692 /* Switch off most of the card driver interface. */ 693 dummy_driver.free_iso_context = card->driver->free_iso_context; 694 dummy_driver.stop_iso = card->driver->stop_iso; 695 card->driver = &dummy_driver; 696 697 fw_destroy_nodes(card); 698 699 /* Wait for all users, especially device workqueue jobs, to finish. */ 700 fw_card_put(card); 701 wait_for_completion(&card->done); 702 703 WARN_ON(!list_empty(&card->transaction_list)); 704} 705EXPORT_SYMBOL(fw_core_remove_card); 706