linux/drivers/firewire/core-card.c
<<
>>
Prefs
   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, "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
 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}
 679EXPORT_SYMBOL_GPL(fw_card_release);
 680
 681void 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}
 706EXPORT_SYMBOL(fw_core_remove_card);
 707
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.