atomic: use <linux/atomic.h>
[linux-2.6.git] / drivers / firewire / core-card.c
index f73e3bd..85661b0 100644 (file)
 #include <linux/module.h>
 #include <linux/mutex.h>
 #include <linux/spinlock.h>
-#include <linux/timer.h>
 #include <linux/workqueue.h>
 
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 #include <asm/byteorder.h>
 
 #include "core.h"
 
-static int __compute_block_crc(__be32 *block)
+int fw_compute_block_crc(__be32 *block)
 {
        int length;
        u16 crc;
@@ -50,29 +49,20 @@ static int __compute_block_crc(__be32 *block)
        return length;
 }
 
-int fw_compute_block_crc(u32 *block)
-{
-       __be32 be32_block[256];
-       int i, length;
-
-       length = (*block >> 16) & 0xff;
-       for (i = 0; i < length; i++)
-               be32_block[i] = cpu_to_be32(block[i + 1]);
-       *block |= crc_itu_t(0, (u8 *) be32_block, length * 4);
-
-       return length;
-}
-
 static DEFINE_MUTEX(card_mutex);
 static LIST_HEAD(card_list);
 
 static LIST_HEAD(descriptor_list);
 static int descriptor_count;
 
+static __be32 tmp_config_rom[256];
+/* ROM header, bus info block, root dir header, capabilities = 7 quadlets */
+static size_t config_rom_length = 1 + 4 + 1 + 1;
+
 #define BIB_CRC(v)             ((v) <<  0)
 #define BIB_CRC_LENGTH(v)      ((v) << 16)
 #define BIB_INFO_LENGTH(v)     ((v) << 24)
-
+#define BIB_BUS_NAME           0x31333934 /* "1394" */
 #define BIB_LINK_SPEED(v)      ((v) <<  0)
 #define BIB_GENERATION(v)      ((v) <<  4)
 #define BIB_MAX_ROM(v)         ((v) <<  8)
@@ -82,12 +72,21 @@ static int descriptor_count;
 #define BIB_BMC                        ((1) << 28)
 #define BIB_ISC                        ((1) << 29)
 #define BIB_CMC                        ((1) << 30)
-#define BIB_IMC                        ((1) << 31)
+#define BIB_IRMC               ((1) << 31)
+#define NODE_CAPABILITIES      0x0c0083c0 /* per IEEE 1394 clause 8.3.2.6.5.2 */
+
+/*
+ * IEEE-1394 specifies a default SPLIT_TIMEOUT value of 800 cycles (100 ms),
+ * but we have to make it longer because there are many devices whose firmware
+ * is just too slow for that.
+ */
+#define DEFAULT_SPLIT_TIMEOUT  (2 * 8000)
+
+#define CANON_OUI              0x000085
 
-static __be32 *generate_config_rom(struct fw_card *card, size_t *rom_length)
+static void generate_config_rom(struct fw_card *card, __be32 *config_rom)
 {
        struct fw_descriptor *desc;
-       static __be32 config_rom[256];
        int i, j, k, length;
 
        /*
@@ -101,18 +100,18 @@ static __be32 *generate_config_rom(struct fw_card *card, size_t *rom_length)
 
        config_rom[0] = cpu_to_be32(
                BIB_CRC_LENGTH(4) | BIB_INFO_LENGTH(4) | BIB_CRC(0));
-       config_rom[1] = cpu_to_be32(0x31333934);
+       config_rom[1] = cpu_to_be32(BIB_BUS_NAME);
        config_rom[2] = cpu_to_be32(
                BIB_LINK_SPEED(card->link_speed) |
                BIB_GENERATION(card->config_rom_generation++ % 14 + 2) |
                BIB_MAX_ROM(2) |
                BIB_MAX_RECEIVE(card->max_receive) |
-               BIB_BMC | BIB_ISC | BIB_CMC | BIB_IMC);
+               BIB_BMC | BIB_ISC | BIB_CMC | BIB_IRMC);
        config_rom[3] = cpu_to_be32(card->guid >> 32);
        config_rom[4] = cpu_to_be32(card->guid);
 
        /* Generate root directory. */
-       config_rom[6] = cpu_to_be32(0x0c0083c0); /* node capabilities */
+       config_rom[6] = cpu_to_be32(NODE_CAPABILITIES);
        i = 7;
        j = 7 + descriptor_count;
 
@@ -140,28 +139,32 @@ static __be32 *generate_config_rom(struct fw_card *card, size_t *rom_length)
         * the bus info block, which is always the case for this
         * implementation. */
        for (i = 0; i < j; i += length + 1)
-               length = __compute_block_crc(config_rom + i);
-
-       *rom_length = j;
+               length = fw_compute_block_crc(config_rom + i);
 
-       return config_rom;
+       WARN_ON(j != config_rom_length);
 }
 
 static void update_config_roms(void)
 {
        struct fw_card *card;
-       __be32 *config_rom;
-       size_t length;
 
        list_for_each_entry (card, &card_list, link) {
-               config_rom = generate_config_rom(card, &length);
-               card->driver->set_config_rom(card, config_rom, length);
+               generate_config_rom(card, tmp_config_rom);
+               card->driver->set_config_rom(card, tmp_config_rom,
+                                            config_rom_length);
        }
 }
 
+static size_t required_space(struct fw_descriptor *desc)
+{
+       /* descriptor + entry into root dir + optional immediate entry */
+       return desc->length + 1 + (desc->immediate > 0 ? 1 : 0);
+}
+
 int fw_core_add_descriptor(struct fw_descriptor *desc)
 {
        size_t i;
+       int ret;
 
        /*
         * Check descriptor is valid; the length of all blocks in the
@@ -177,15 +180,21 @@ int fw_core_add_descriptor(struct fw_descriptor *desc)
 
        mutex_lock(&card_mutex);
 
-       list_add_tail(&desc->link, &descriptor_list);
-       descriptor_count++;
-       if (desc->immediate > 0)
+       if (config_rom_length + required_space(desc) > 256) {
+               ret = -EBUSY;
+       } else {
+               list_add_tail(&desc->link, &descriptor_list);
+               config_rom_length += required_space(desc);
                descriptor_count++;
-       update_config_roms();
+               if (desc->immediate > 0)
+                       descriptor_count++;
+               update_config_roms();
+               ret = 0;
+       }
 
        mutex_unlock(&card_mutex);
 
-       return 0;
+       return ret;
 }
 EXPORT_SYMBOL(fw_core_add_descriptor);
 
@@ -194,6 +203,7 @@ void fw_core_remove_descriptor(struct fw_descriptor *desc)
        mutex_lock(&card_mutex);
 
        list_del(&desc->link);
+       config_rom_length -= required_space(desc);
        descriptor_count--;
        if (desc->immediate > 0)
                descriptor_count--;
@@ -203,17 +213,61 @@ void fw_core_remove_descriptor(struct fw_descriptor *desc)
 }
 EXPORT_SYMBOL(fw_core_remove_descriptor);
 
+static int reset_bus(struct fw_card *card, bool short_reset)
+{
+       int reg = short_reset ? 5 : 1;
+       int bit = short_reset ? PHY_BUS_SHORT_RESET : PHY_BUS_RESET;
+
+       return card->driver->update_phy_reg(card, reg, 0, bit);
+}
+
+void fw_schedule_bus_reset(struct fw_card *card, bool delayed, bool short_reset)
+{
+       /* We don't try hard to sort out requests of long vs. short resets. */
+       card->br_short = short_reset;
+
+       /* Use an arbitrary short delay to combine multiple reset requests. */
+       fw_card_get(card);
+       if (!queue_delayed_work(fw_workqueue, &card->br_work,
+                               delayed ? DIV_ROUND_UP(HZ, 100) : 0))
+               fw_card_put(card);
+}
+EXPORT_SYMBOL(fw_schedule_bus_reset);
+
+static void br_work(struct work_struct *work)
+{
+       struct fw_card *card = container_of(work, struct fw_card, br_work.work);
+
+       /* Delay for 2s after last reset per IEEE 1394 clause 8.2.1. */
+       if (card->reset_jiffies != 0 &&
+           time_before64(get_jiffies_64(), card->reset_jiffies + 2 * HZ)) {
+               if (!queue_delayed_work(fw_workqueue, &card->br_work, 2 * HZ))
+                       fw_card_put(card);
+               return;
+       }
+
+       fw_send_phy_config(card, FW_PHY_CONFIG_NO_NODE_ID, card->generation,
+                          FW_PHY_CONFIG_CURRENT_GAP_COUNT);
+       reset_bus(card, card->br_short);
+       fw_card_put(card);
+}
+
 static void allocate_broadcast_channel(struct fw_card *card, int generation)
 {
        int channel, bandwidth = 0;
 
-       fw_iso_resource_manage(card, generation, 1ULL << 31, &channel,
-                              &bandwidth, true, card->bm_transaction_data);
-       if (channel == 31) {
+       if (!card->broadcast_channel_allocated) {
+               fw_iso_resource_manage(card, generation, 1ULL << 31,
+                                      &channel, &bandwidth, true);
+               if (channel != 31) {
+                       fw_notify("failed to allocate broadcast channel\n");
+                       return;
+               }
                card->broadcast_channel_allocated = true;
-               device_for_each_child(card->device, (void *)(long)generation,
-                                     fw_device_set_broadcast_channel);
        }
+
+       device_for_each_child(card->device, (void *)(long)generation,
+                             fw_device_set_broadcast_channel);
 }
 
 static const char gap_count_table[] = {
@@ -223,43 +277,57 @@ static const char gap_count_table[] = {
 void fw_schedule_bm_work(struct fw_card *card, unsigned long delay)
 {
        fw_card_get(card);
-       if (!schedule_delayed_work(&card->work, delay))
+       if (!schedule_delayed_work(&card->bm_work, delay))
                fw_card_put(card);
 }
 
-static void fw_card_bm_work(struct work_struct *work)
+static void bm_work(struct work_struct *work)
 {
-       struct fw_card *card = container_of(work, struct fw_card, work.work);
-       struct fw_device *root_device;
+       struct fw_card *card = container_of(work, struct fw_card, bm_work.work);
+       struct fw_device *root_device, *irm_device;
        struct fw_node *root_node;
-       unsigned long flags;
-       int root_id, new_root_id, irm_id, local_id;
+       int root_id, new_root_id, irm_id, bm_id, local_id;
        int gap_count, generation, grace, rcode;
        bool do_reset = false;
        bool root_device_is_running;
        bool root_device_is_cmc;
+       bool irm_is_1394_1995_only;
+       bool keep_this_irm;
+       __be32 transaction_data[2];
 
-       spin_lock_irqsave(&card->lock, flags);
+       spin_lock_irq(&card->lock);
 
        if (card->local_node == NULL) {
-               spin_unlock_irqrestore(&card->lock, flags);
+               spin_unlock_irq(&card->lock);
                goto out_put_card;
        }
 
        generation = card->generation;
+
        root_node = card->root_node;
        fw_node_get(root_node);
        root_device = root_node->data;
        root_device_is_running = root_device &&
                        atomic_read(&root_device->state) == FW_DEVICE_RUNNING;
        root_device_is_cmc = root_device && root_device->cmc;
+
+       irm_device = card->irm_node->data;
+       irm_is_1394_1995_only = irm_device && irm_device->config_rom &&
+                       (irm_device->config_rom[2] & 0x000000f0) == 0;
+
+       /* Canon MV5i works unreliably if it is not root node. */
+       keep_this_irm = irm_device && irm_device->config_rom &&
+                       irm_device->config_rom[3] >> 8 == CANON_OUI;
+
        root_id  = root_node->node_id;
        irm_id   = card->irm_node->node_id;
        local_id = card->local_node->node_id;
 
-       grace = time_after(jiffies, card->reset_jiffies + DIV_ROUND_UP(HZ, 8));
+       grace = time_after64(get_jiffies_64(),
+                            card->reset_jiffies + DIV_ROUND_UP(HZ, 8));
 
-       if (is_next_generation(generation, card->bm_generation) ||
+       if ((is_next_generation(generation, card->bm_generation) &&
+            !card->bm_abdicate) ||
            (card->bm_generation != generation && grace)) {
                /*
                 * This first step is to figure out who is IRM and
@@ -275,29 +343,41 @@ static void fw_card_bm_work(struct work_struct *work)
 
                if (!card->irm_node->link_on) {
                        new_root_id = local_id;
-                       fw_notify("IRM has link off, making local node (%02x) root.\n",
-                                 new_root_id);
+                       fw_notify("%s, making local node (%02x) root.\n",
+                                 "IRM has link off", new_root_id);
+                       goto pick_me;
+               }
+
+               if (irm_is_1394_1995_only && !keep_this_irm) {
+                       new_root_id = local_id;
+                       fw_notify("%s, making local node (%02x) root.\n",
+                                 "IRM is not 1394a compliant", new_root_id);
                        goto pick_me;
                }
 
-               card->bm_transaction_data[0] = cpu_to_be32(0x3f);
-               card->bm_transaction_data[1] = cpu_to_be32(local_id);
+               transaction_data[0] = cpu_to_be32(0x3f);
+               transaction_data[1] = cpu_to_be32(local_id);
 
-               spin_unlock_irqrestore(&card->lock, flags);
+               spin_unlock_irq(&card->lock);
 
                rcode = fw_run_transaction(card, TCODE_LOCK_COMPARE_SWAP,
                                irm_id, generation, SCODE_100,
                                CSR_REGISTER_BASE + CSR_BUS_MANAGER_ID,
-                               card->bm_transaction_data,
-                               sizeof(card->bm_transaction_data));
+                               transaction_data, 8);
 
                if (rcode == RCODE_GENERATION)
                        /* Another bus reset, BM work has been rescheduled. */
                        goto out;
 
-               if (rcode == RCODE_COMPLETE &&
-                   card->bm_transaction_data[0] != cpu_to_be32(0x3f)) {
+               bm_id = be32_to_cpu(transaction_data[0]);
 
+               spin_lock_irq(&card->lock);
+               if (rcode == RCODE_COMPLETE && generation == card->generation)
+                       card->bm_node_id =
+                           bm_id == 0x3f ? local_id : 0xffc0 | bm_id;
+               spin_unlock_irq(&card->lock);
+
+               if (rcode == RCODE_COMPLETE && bm_id != 0x3f) {
                        /* Somebody else is BM.  Only act as IRM. */
                        if (local_id == irm_id)
                                allocate_broadcast_channel(card, generation);
@@ -305,9 +385,19 @@ static void fw_card_bm_work(struct work_struct *work)
                        goto out;
                }
 
-               spin_lock_irqsave(&card->lock, flags);
+               if (rcode == RCODE_SEND_ERROR) {
+                       /*
+                        * We have been unable to send the lock request due to
+                        * some local problem.  Let's try again later and hope
+                        * that the problem has gone away by then.
+                        */
+                       fw_schedule_bm_work(card, DIV_ROUND_UP(HZ, 8));
+                       goto out;
+               }
+
+               spin_lock_irq(&card->lock);
 
-               if (rcode != RCODE_COMPLETE) {
+               if (rcode != RCODE_COMPLETE && !keep_this_irm) {
                        /*
                         * The lock request failed, maybe the IRM
                         * isn't really IRM capable after all. Let's
@@ -315,8 +405,8 @@ static void fw_card_bm_work(struct work_struct *work)
                         * root, and thus, IRM.
                         */
                        new_root_id = local_id;
-                       fw_notify("BM lock failed, making local node (%02x) root.\n",
-                                 new_root_id);
+                       fw_notify("%s, making local node (%02x) root.\n",
+                                 "BM lock failed", new_root_id);
                        goto pick_me;
                }
        } else if (card->bm_generation != generation) {
@@ -324,7 +414,7 @@ static void fw_card_bm_work(struct work_struct *work)
                 * We weren't BM in the last generation, and the last
                 * bus reset is less than 125ms ago.  Reschedule this job.
                 */
-               spin_unlock_irqrestore(&card->lock, flags);
+               spin_unlock_irq(&card->lock);
                fw_schedule_bm_work(card, DIV_ROUND_UP(HZ, 8));
                goto out;
        }
@@ -347,14 +437,12 @@ static void fw_card_bm_work(struct work_struct *work)
                 * If we haven't probed this device yet, bail out now
                 * and let's try again once that's done.
                 */
-               spin_unlock_irqrestore(&card->lock, flags);
+               spin_unlock_irq(&card->lock);
                goto out;
        } else if (root_device_is_cmc) {
                /*
-                * FIXME: I suppose we should set the cmstr bit in the
-                * STATE_CLEAR register of this node, as described in
-                * 1394-1995, 8.4.2.6.  Also, send out a force root
-                * packet for this node.
+                * We will send out a force root packet for this
+                * node as part of the gap count optimization.
                 */
                new_root_id = root_id;
        } else {
@@ -387,32 +475,39 @@ static void fw_card_bm_work(struct work_struct *work)
            (card->gap_count != gap_count || new_root_id != root_id))
                do_reset = true;
 
-       spin_unlock_irqrestore(&card->lock, flags);
+       spin_unlock_irq(&card->lock);
 
        if (do_reset) {
                fw_notify("phy config: card %d, new root=%x, gap_count=%d\n",
                          card->index, new_root_id, gap_count);
                fw_send_phy_config(card, new_root_id, generation, gap_count);
-               fw_core_initiate_bus_reset(card, 1);
+               reset_bus(card, true);
                /* Will allocate broadcast channel after the reset. */
-       } else {
-               if (local_id == irm_id)
-                       allocate_broadcast_channel(card, generation);
+               goto out;
+       }
+
+       if (root_device_is_cmc) {
+               /*
+                * Make sure that the cycle master sends cycle start packets.
+                */
+               transaction_data[0] = cpu_to_be32(CSR_STATE_BIT_CMSTR);
+               rcode = fw_run_transaction(card, TCODE_WRITE_QUADLET_REQUEST,
+                               root_id, generation, SCODE_100,
+                               CSR_REGISTER_BASE + CSR_STATE_SET,
+                               transaction_data, 4);
+               if (rcode == RCODE_GENERATION)
+                       goto out;
        }
 
+       if (local_id == irm_id)
+               allocate_broadcast_channel(card, generation);
+
  out:
        fw_node_put(root_node);
  out_put_card:
        fw_card_put(card);
 }
 
-static void flush_timer_callback(unsigned long data)
-{
-       struct fw_card *card = (struct fw_card *)data;
-
-       fw_flush_transactions(card);
-}
-
 void fw_card_initialize(struct fw_card *card,
                        const struct fw_card_driver *driver,
                        struct device *device)
@@ -424,27 +519,30 @@ void fw_card_initialize(struct fw_card *card,
        card->device = device;
        card->current_tlabel = 0;
        card->tlabel_mask = 0;
+       card->split_timeout_hi = DEFAULT_SPLIT_TIMEOUT / 8000;
+       card->split_timeout_lo = (DEFAULT_SPLIT_TIMEOUT % 8000) << 19;
+       card->split_timeout_cycles = DEFAULT_SPLIT_TIMEOUT;
+       card->split_timeout_jiffies =
+                       DIV_ROUND_UP(DEFAULT_SPLIT_TIMEOUT * HZ, 8000);
        card->color = 0;
        card->broadcast_channel = BROADCAST_CHANNEL_INITIAL;
 
        kref_init(&card->kref);
        init_completion(&card->done);
        INIT_LIST_HEAD(&card->transaction_list);
+       INIT_LIST_HEAD(&card->phy_receiver_list);
        spin_lock_init(&card->lock);
-       setup_timer(&card->flush_timer,
-                   flush_timer_callback, (unsigned long)card);
 
        card->local_node = NULL;
 
-       INIT_DELAYED_WORK(&card->work, fw_card_bm_work);
+       INIT_DELAYED_WORK(&card->br_work, br_work);
+       INIT_DELAYED_WORK(&card->bm_work, bm_work);
 }
 EXPORT_SYMBOL(fw_card_initialize);
 
 int fw_card_add(struct fw_card *card,
                u32 max_receive, u32 link_speed, u64 guid)
 {
-       __be32 *config_rom;
-       size_t length;
        int ret;
 
        card->max_receive = max_receive;
@@ -453,8 +551,8 @@ int fw_card_add(struct fw_card *card,
 
        mutex_lock(&card_mutex);
 
-       config_rom = generate_config_rom(card, &length);
-       ret = card->driver->enable(card, config_rom, length);
+       generate_config_rom(card, tmp_config_rom);
+       ret = card->driver->enable(card, tmp_config_rom, config_rom_length);
        if (ret == 0)
                list_add_tail(&card->link, &card_list);
 
@@ -464,20 +562,22 @@ int fw_card_add(struct fw_card *card,
 }
 EXPORT_SYMBOL(fw_card_add);
 
-
 /*
  * The next few functions implement a dummy driver that is used once a card
  * driver shuts down an fw_card.  This allows the driver to cleanly unload,
  * as all IO to the card will be handled (and failed) by the dummy driver
  * instead of calling into the module.  Only functions for iso context
  * shutdown still need to be provided by the card driver.
+ *
+ * .read/write_csr() should never be called anymore after the dummy driver
+ * was bound since they are only used within request handler context.
+ * .set_config_rom() is never called since the card is taken out of card_list
+ * before switching to the dummy driver.
  */
 
-static int dummy_enable(struct fw_card *card,
-                       const __be32 *config_rom, size_t length)
+static int dummy_read_phy_reg(struct fw_card *card, int address)
 {
-       BUG();
-       return -1;
+       return -ENODEV;
 }
 
 static int dummy_update_phy_reg(struct fw_card *card, int address,
@@ -486,25 +586,14 @@ static int dummy_update_phy_reg(struct fw_card *card, int address,
        return -ENODEV;
 }
 
-static int dummy_set_config_rom(struct fw_card *card,
-                               const __be32 *config_rom, size_t length)
-{
-       /*
-        * We take the card out of card_list before setting the dummy
-        * driver, so this should never get called.
-        */
-       BUG();
-       return -1;
-}
-
 static void dummy_send_request(struct fw_card *card, struct fw_packet *packet)
 {
-       packet->callback(packet, card, -ENODEV);
+       packet->callback(packet, card, RCODE_CANCELLED);
 }
 
 static void dummy_send_response(struct fw_card *card, struct fw_packet *packet)
 {
-       packet->callback(packet, card, -ENODEV);
+       packet->callback(packet, card, RCODE_CANCELLED);
 }
 
 static int dummy_cancel_packet(struct fw_card *card, struct fw_packet *packet)
@@ -518,14 +607,45 @@ static int dummy_enable_phys_dma(struct fw_card *card,
        return -ENODEV;
 }
 
+static struct fw_iso_context *dummy_allocate_iso_context(struct fw_card *card,
+                               int type, int channel, size_t header_size)
+{
+       return ERR_PTR(-ENODEV);
+}
+
+static int dummy_start_iso(struct fw_iso_context *ctx,
+                          s32 cycle, u32 sync, u32 tags)
+{
+       return -ENODEV;
+}
+
+static int dummy_set_iso_channels(struct fw_iso_context *ctx, u64 *channels)
+{
+       return -ENODEV;
+}
+
+static int dummy_queue_iso(struct fw_iso_context *ctx, struct fw_iso_packet *p,
+                          struct fw_iso_buffer *buffer, unsigned long payload)
+{
+       return -ENODEV;
+}
+
+static void dummy_flush_queue_iso(struct fw_iso_context *ctx)
+{
+}
+
 static const struct fw_card_driver dummy_driver_template = {
-       .enable          = dummy_enable,
-       .update_phy_reg  = dummy_update_phy_reg,
-       .set_config_rom  = dummy_set_config_rom,
-       .send_request    = dummy_send_request,
-       .cancel_packet   = dummy_cancel_packet,
-       .send_response   = dummy_send_response,
-       .enable_phys_dma = dummy_enable_phys_dma,
+       .read_phy_reg           = dummy_read_phy_reg,
+       .update_phy_reg         = dummy_update_phy_reg,
+       .send_request           = dummy_send_request,
+       .send_response          = dummy_send_response,
+       .cancel_packet          = dummy_cancel_packet,
+       .enable_phys_dma        = dummy_enable_phys_dma,
+       .allocate_iso_context   = dummy_allocate_iso_context,
+       .start_iso              = dummy_start_iso,
+       .set_iso_channels       = dummy_set_iso_channels,
+       .queue_iso              = dummy_queue_iso,
+       .flush_queue_iso        = dummy_flush_queue_iso,
 };
 
 void fw_card_release(struct kref *kref)
@@ -541,7 +661,7 @@ void fw_core_remove_card(struct fw_card *card)
 
        card->driver->update_phy_reg(card, 4,
                                     PHY_LINK_ACTIVE | PHY_CONTENDER, 0);
-       fw_core_initiate_bus_reset(card, 1);
+       fw_schedule_bus_reset(card, false, true);
 
        mutex_lock(&card_mutex);
        list_del_init(&card->link);
@@ -559,15 +679,5 @@ void fw_core_remove_card(struct fw_card *card)
        wait_for_completion(&card->done);
 
        WARN_ON(!list_empty(&card->transaction_list));
-       del_timer_sync(&card->flush_timer);
 }
 EXPORT_SYMBOL(fw_core_remove_card);
-
-int fw_core_initiate_bus_reset(struct fw_card *card, int short_reset)
-{
-       int reg = short_reset ? 5 : 1;
-       int bit = short_reset ? PHY_BUS_SHORT_RESET : PHY_BUS_RESET;
-
-       return card->driver->update_phy_reg(card, reg, 0, bit);
-}
-EXPORT_SYMBOL(fw_core_initiate_bus_reset);