firewire: Implement gap count optimization.
authorKristian Høgsberg <krh@localhost.localdomain>
Fri, 26 Jan 2007 05:37:50 +0000 (00:37 -0500)
committerStefan Richter <stefanr@s5r6.in-berlin.de>
Fri, 9 Mar 2007 21:02:44 +0000 (22:02 +0100)
Signed-off-by: Kristian Høgsberg <krh@redhat.com>
Signed-off-by: Stefan Richter <stefanr@s5r6.in-berlin.de>
drivers/firewire/fw-card.c
drivers/firewire/fw-topology.c
drivers/firewire/fw-topology.h
drivers/firewire/fw-transaction.c
drivers/firewire/fw-transaction.h

index c8b7d695c81d6f853035076b02b09cd51bd028ce..307c8b851382e25802fb4714dc7d9b31ca90ea03 100644 (file)
@@ -186,14 +186,17 @@ fw_core_remove_descriptor (struct fw_descriptor *desc)
 }
 EXPORT_SYMBOL(fw_core_remove_descriptor);
 
+static const char gap_count_table[] = {
+       63, 5, 7, 8, 10, 13, 16, 18, 21, 24, 26, 29, 32, 35, 37, 40
+};
+
 static void
 fw_card_irm_work(struct work_struct *work)
 {
-       struct fw_card *card =
-               container_of(work, struct fw_card, work.work);
+       struct fw_card *card = container_of(work, struct fw_card, work.work);
        struct fw_device *root;
        unsigned long flags;
-       int new_irm_id, generation;
+       int root_id, new_irm_id, gap_count, generation, do_reset = 0;
 
        /* FIXME: This simple bus management unconditionally picks a
         * cycle master if the current root can't do it.  We need to
@@ -206,35 +209,50 @@ fw_card_irm_work(struct work_struct *work)
 
        generation = card->generation;
        root = card->root_node->data;
+       root_id = card->root_node->node_id;
 
-       if (root == NULL)
+       if (root == NULL) {
                /* Either link_on is false, or we failed to read the
                 * config rom.  In either case, pick another root. */
                new_irm_id = card->local_node->node_id;
-       else if (root->state != FW_DEVICE_RUNNING)
+       } else if (root->state != FW_DEVICE_RUNNING) {
                /* If we haven't probed this device yet, bail out now
                 * and let's try again once that's done. */
-               new_irm_id = -1;
-       else if (root->config_rom[2] & bib_cmc)
+               new_irm_id = root_id;
+       } else if (root->config_rom[2] & bib_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. */
-               new_irm_id = -1;
-       else
+               new_irm_id = root_id;
+       } else {
                /* Current root has an active link layer and we
                 * successfully read the config rom, but it's not
                 * cycle master capable. */
                new_irm_id = card->local_node->node_id;
+       }
+
+       /* Now figure out what gap count to set. */
+       if (card->topology_type == FW_TOPOLOGY_A &&
+           card->root_node->max_hops < ARRAY_SIZE(gap_count_table))
+               gap_count = gap_count_table[card->root_node->max_hops];
+       else
+               gap_count = 63;
+
+       /* Finally, figure out if we should do a reset or not.  If we've
+        * done less that 5 resets with the same physical topology and we
+        * have either a new root or a new gap count setting, let's do it. */
 
-       if (card->irm_retries++ > 5)
-               new_irm_id = -1;
+       if (card->irm_retries++ < 5 &&
+           (card->gap_count != gap_count || new_irm_id != root_id))
+               do_reset = 1;
 
        spin_unlock_irqrestore(&card->lock, flags);
 
-       if (new_irm_id > 0) {
-               fw_notify("Trying to become root (card %d)\n", card->index);
-               fw_send_force_root(card, new_irm_id, generation);
+       if (do_reset) {
+               fw_notify("phy config: card %d, new root=%x, gap_count=%d\n",
+                         card->index, new_irm_id, gap_count);
+               fw_send_phy_config(card, new_irm_id, generation, gap_count);
                fw_core_initiate_bus_reset(card, 1);
        }
 }
index 684d87d9977536f82e73b0e4e96a50ff7410fc6b..d3131e7d52fa339907a9ec7ff37b864b5e44cfc4 100644 (file)
@@ -113,6 +113,44 @@ static struct fw_node *fw_node_create(u32 sid, int port_count, int color)
        return node;
 }
 
+/* Compute the maximum hop count for this node and it's children.  The
+ * maximum hop count is the maximum number of connections between any
+ * two nodes in the subtree rooted at this node.  We need this for
+ * setting the gap count.  As we build the tree bottom up in
+ * build_tree() below, this is fairly easy to do: for each node we
+ * maintain the max hop count and the max depth, ie the number of hops
+ * to the furthest leaf.  Computing the max hop count breaks down into
+ * two cases: either the path goes through this node, in which case
+ * the hop count is the sum of the two biggest child depths plus 2.
+ * Or it could be the case that the max hop path is entirely
+ * containted in a child tree, in which case the max hop count is just
+ * the max hop count of this child.
+ */
+static void update_hop_count(struct fw_node *node)
+{
+       int depths[2] = { -1, -1 };
+       int max_child_hops = 0;
+       int i;
+
+       for (i = 0; i < node->port_count; i++) {
+               if (node->ports[i].node == NULL)
+                       continue;
+
+               if (node->ports[i].node->max_hops > max_child_hops)
+                       max_child_hops = node->ports[i].node->max_hops;
+
+               if (node->ports[i].node->max_depth > depths[0]) {
+                       depths[1] = depths[0];
+                       depths[0] = node->ports[i].node->max_depth;
+               } else if (node->ports[i].node->max_depth > depths[1])
+                       depths[1] = node->ports[i].node->max_depth;
+       }
+
+       node->max_depth = depths[0] + 1;
+       node->max_hops = max(max_child_hops, depths[0] + depths[1] + 2);
+}
+
+
 /**
  * build_tree - Build the tree representation of the topology
  * @self_ids: array of self IDs to create the tree from
@@ -131,6 +169,7 @@ static struct fw_node *build_tree(struct fw_card *card)
        struct list_head stack, *h;
        u32 *sid, *next_sid, *end, q;
        int i, port_count, child_port_count, phy_id, parent_count, stack_depth;
+       int gap_count, topology_type;
 
        local_node = NULL;
        node = NULL;
@@ -140,6 +179,8 @@ static struct fw_node *build_tree(struct fw_card *card)
        end = sid + card->self_id_count;
        phy_id = 0;
        card->irm_node = NULL;
+       gap_count = self_id_gap_count(*sid);
+       topology_type = 0;
 
        while (sid < end) {
                next_sid = count_ports(sid, &port_count, &child_port_count);
@@ -179,6 +220,11 @@ static struct fw_node *build_tree(struct fw_card *card)
                if (self_id_contender(q))
                        card->irm_node = node;
 
+               if (node->phy_speed == SCODE_BETA)
+                       topology_type |= FW_TOPOLOGY_B;
+               else
+                       topology_type |= FW_TOPOLOGY_A;
+
                parent_count = 0;
 
                for (i = 0; i < port_count; i++) {
@@ -223,11 +269,21 @@ static struct fw_node *build_tree(struct fw_card *card)
                list_add_tail(&node->link, &stack);
                stack_depth += 1 - child_port_count;
 
+               /* If all PHYs does not report the same gap count
+                * setting, we fall back to 63 which will force a gap
+                * count reconfiguration and a reset. */
+               if (self_id_gap_count(q) != gap_count)
+                       gap_count = 63;
+
+               update_hop_count(node);
+
                sid = next_sid;
                phy_id++;
        }
 
        card->root_node = node;
+       card->gap_count = gap_count;
+       card->topology_type = topology_type;
 
        return local_node;
 }
@@ -286,7 +342,8 @@ report_found_node(struct fw_card *card,
        int b_path = (node->phy_speed == SCODE_BETA);
 
        if (parent != NULL) {
-               node->max_speed = min(parent->max_speed, node->phy_speed);
+               node->max_speed = min((u8)parent->max_speed,
+                                     (u8)node->phy_speed);
                node->b_path = parent->b_path && b_path;
        } else {
                node->max_speed = node->phy_speed;
@@ -329,7 +386,7 @@ static void move_tree(struct fw_node *node0, struct fw_node *node1, int port)
  * as we go.
  */
 static void
-update_tree(struct fw_card *card, struct fw_node *root, int *changed)
+update_tree(struct fw_card *card, struct fw_node *root)
 {
        struct list_head list0, list1;
        struct fw_node *node0, *node1;
@@ -342,7 +399,6 @@ update_tree(struct fw_card *card, struct fw_node *root, int *changed)
 
        node0 = fw_node(list0.next);
        node1 = fw_node(list1.next);
-       *changed = 0;
 
        while (&node0->link != &list0) {
 
@@ -358,6 +414,7 @@ update_tree(struct fw_card *card, struct fw_node *root, int *changed)
                node0->color = card->color;
                node0->link_on = node1->link_on;
                node0->initiated_reset = node1->initiated_reset;
+               node0->max_hops = node1->max_hops;
                node1->color = card->color;
                fw_node_event(card, node0, event);
 
@@ -386,7 +443,6 @@ update_tree(struct fw_card *card, struct fw_node *root, int *changed)
                                for_each_fw_node(card, node0->ports[i].node,
                                                 report_lost_node);
                                node0->ports[i].node = NULL;
-                               *changed = 1;
                        } else if (node1->ports[i].node) {
                                /* One or more node were connected to
                                 * this port. Move the new nodes into
@@ -395,7 +451,6 @@ update_tree(struct fw_card *card, struct fw_node *root, int *changed)
                                move_tree(node0, node1, i);
                                for_each_fw_node(card, node0->ports[i].node,
                                                 report_found_node);
-                               *changed = 1;
                        }
                }
 
@@ -411,12 +466,17 @@ fw_core_handle_bus_reset(struct fw_card *card,
 {
        struct fw_node *local_node;
        unsigned long flags;
-       int changed;
 
        fw_flush_transactions(card);
 
        spin_lock_irqsave(&card->lock, flags);
 
+       /* If the new topology has a different self_id_count the topology
+        * changed, either nodes were added or removed. In that case we
+        * reset the IRM reset counter. */
+       if (card->self_id_count != self_id_count)
+               card->irm_retries = 0;
+
        card->node_id = node_id;
        card->self_id_count = self_id_count;
        card->generation = generation;
@@ -433,9 +493,7 @@ fw_core_handle_bus_reset(struct fw_card *card,
                card->local_node = local_node;
                for_each_fw_node(card, local_node, report_found_node);
        } else {
-               update_tree(card, local_node, &changed);
-               if (changed)
-                       card->irm_retries = 0;
+               update_tree(card, local_node);
        }
 
        /* If we're not the root node, we may have to do some IRM work. */
index ab03059a0da1b6b3c072de0d55d5971a958e63b3..f2a575e05ae12da762a27e2150e7358c815dbb97 100644 (file)
 #ifndef __fw_topology_h
 #define __fw_topology_h
 
+enum {
+       FW_TOPOLOGY_A =         0x01,
+       FW_TOPOLOGY_B =         0x02,
+       FW_TOPOLOGY_MIXED =     0x03,
+};
+
 enum {
        FW_NODE_CREATED =   0x00,
        FW_NODE_UPDATED =   0x01,
@@ -42,10 +48,11 @@ struct fw_node {
        unsigned link_on : 1;
        unsigned initiated_reset : 1;
        unsigned b_path : 1;
-       u8 phy_speed; /* As in the self ID packet. */
-       u8 max_speed; /* Minimum of all phy-speeds and port speeds on
-                      * the path from the local node to this node. */
-
+       u8 phy_speed : 3; /* As in the self ID packet. */
+       u8 max_speed : 5; /* Minimum of all phy-speeds and port speeds on
+                          * the path from the local node to this node. */
+       u8 max_depth : 4; /* Maximum depth to any leaf node */
+       u8 max_hops : 4;  /* Max hops in this sub tree */
        atomic_t ref_count;
 
        /* For serializing node topology into a list. */
index 439a3e3ee2f0c1fbc1ff6c68275e62ae5d33de86..57ecf95e52710cec8b56775f3a6c91ee0a774281 100644 (file)
@@ -274,11 +274,15 @@ static void send_phy_packet(struct fw_card *card, u32 data, int generation)
        card->driver->send_request(card, packet);
 }
 
-void fw_send_force_root(struct fw_card *card, int node_id, int generation)
+void fw_send_phy_config(struct fw_card *card,
+                       int node_id, int generation, int gap_count)
 {
        u32 q;
 
-       q = phy_identifier(PHY_PACKET_CONFIG) | phy_config_root_id(node_id);
+       q = phy_identifier(PHY_PACKET_CONFIG) |
+               phy_config_root_id(node_id) |
+               phy_config_gap_count(gap_count);
+
        send_phy_packet(card, q, generation);
 }
 
index 22d2871131b177366834fe91e2db0a8e2097b900..df652452bdb5114307ce2b3026ebf1aa0b32359c 100644 (file)
@@ -259,6 +259,8 @@ struct fw_card {
        struct fw_node *root_node;
        struct fw_node *irm_node;
        int color;
+       int gap_count;
+       int topology_type;
 
        int index;
 
@@ -386,8 +388,8 @@ fw_send_request(struct fw_card *card, struct fw_transaction *t,
 
 void fw_flush_transactions(struct fw_card *card);
 
-void
-fw_send_force_root(struct fw_card *card, int node_id, int generation);
+void fw_send_phy_config(struct fw_card *card,
+                       int node_id, int generation, int gap_count);
 
 /* Called by the topology code to inform the device code of node
  * activity; found, lost, or updated nodes */