firewire: fix libdc1394/FlyCap2 iso event regression
[linux-3.10.git] / drivers / firewire / core-card.c
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)                \
41 void 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 }
53 define_fw_printk_level(fw_err, KERN_ERR);
54 define_fw_printk_level(fw_notice, KERN_NOTICE);
55
56 int 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
68 static DEFINE_MUTEX(card_mutex);
69 static LIST_HEAD(card_list);
70
71 static LIST_HEAD(descriptor_list);
72 static int descriptor_count;
73
74 static __be32 tmp_config_rom[256];
75 /* ROM header, bus info block, root dir header, capabilities = 7 quadlets */
76 static 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
103 static 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
163 static 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
174 static 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
180 int 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 }
215 EXPORT_SYMBOL(fw_core_add_descriptor);
216
217 void 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 }
230 EXPORT_SYMBOL(fw_core_remove_descriptor);
231
232 static 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
240 void 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 }
251 EXPORT_SYMBOL(fw_schedule_bus_reset);
252
253 static 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
271 static 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
289 static const char gap_count_table[] = {
290         63, 5, 7, 8, 10, 13, 16, 18, 21, 24, 26, 29, 32, 35, 37, 40
291 };
292
293 void 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
300 static 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, "BM lock failed (%s), making local node (%02x) root\n",
425                                   fw_rcode_string(rcode), 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
527 void 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 }
557 EXPORT_SYMBOL(fw_card_initialize);
558
559 int 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 }
579 EXPORT_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
594 static int dummy_read_phy_reg(struct fw_card *card, int address)
595 {
596         return -ENODEV;
597 }
598
599 static int dummy_update_phy_reg(struct fw_card *card, int address,
600                                 int clear_bits, int set_bits)
601 {
602         return -ENODEV;
603 }
604
605 static void dummy_send_request(struct fw_card *card, struct fw_packet *packet)
606 {
607         packet->callback(packet, card, RCODE_CANCELLED);
608 }
609
610 static void dummy_send_response(struct fw_card *card, struct fw_packet *packet)
611 {
612         packet->callback(packet, card, RCODE_CANCELLED);
613 }
614
615 static int dummy_cancel_packet(struct fw_card *card, struct fw_packet *packet)
616 {
617         return -ENOENT;
618 }
619
620 static int dummy_enable_phys_dma(struct fw_card *card,
621                                  int node_id, int generation)
622 {
623         return -ENODEV;
624 }
625
626 static 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
632 static int dummy_start_iso(struct fw_iso_context *ctx,
633                            s32 cycle, u32 sync, u32 tags)
634 {
635         return -ENODEV;
636 }
637
638 static int dummy_set_iso_channels(struct fw_iso_context *ctx, u64 *channels)
639 {
640         return -ENODEV;
641 }
642
643 static 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
649 static void dummy_flush_queue_iso(struct fw_iso_context *ctx)
650 {
651 }
652
653 static int dummy_flush_iso_completions(struct fw_iso_context *ctx)
654 {
655         return -ENODEV;
656 }
657
658 static 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
673 void 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 EXPORT_SYMBOL_GPL(fw_card_release);
680
681 void fw_core_remove_card(struct fw_card *card)
682 {
683         struct fw_card_driver dummy_driver = dummy_driver_template;
684
685         card->driver->update_phy_reg(card, 4,
686                                      PHY_LINK_ACTIVE | PHY_CONTENDER, 0);
687         fw_schedule_bus_reset(card, false, true);
688
689         mutex_lock(&card_mutex);
690         list_del_init(&card->link);
691         mutex_unlock(&card_mutex);
692
693         /* Switch off most of the card driver interface. */
694         dummy_driver.free_iso_context   = card->driver->free_iso_context;
695         dummy_driver.stop_iso           = card->driver->stop_iso;
696         card->driver = &dummy_driver;
697
698         fw_destroy_nodes(card);
699
700         /* Wait for all users, especially device workqueue jobs, to finish. */
701         fw_card_put(card);
702         wait_for_completion(&card->done);
703
704         WARN_ON(!list_empty(&card->transaction_list));
705 }
706 EXPORT_SYMBOL(fw_core_remove_card);