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);