3 files changed, 64 insertions, 10 deletions

diff --git a/drivers/ieee1394/hosts.h b/drivers/ieee1394/hosts.h
index 38f42112dff0..ae9b02cc013f 100644
--- a/drivers/ieee1394/hosts.h
+++ b/drivers/ieee1394/hosts.h
@@ -41,6 +41,7 @@ struct hpsb_host {
         /* this nodes state */
         unsigned in_bus_reset:1;
         unsigned is_shutdown:1;
+        unsigned resume_packet_sent:1;
 
         /* this nodes' duties on the bus */
         unsigned is_root:1;
diff --git a/drivers/ieee1394/nodemgr.c b/drivers/ieee1394/nodemgr.c
index 7fff5a1d2ea4..0ea37b1bccb2 100644
--- a/drivers/ieee1394/nodemgr.c
+++ b/drivers/ieee1394/nodemgr.c
@@ -1349,6 +1349,33 @@ static void nodemgr_update_pdrv(struct node_entry *ne)
 }
 
 
+/* Write the BROADCAST_CHANNEL as per IEEE1394a 8.3.2.3.11 and 8.4.2.3.  This
+ * seems like an optional service but in the end it is practically mandatory
+ * as a consequence of these clauses.
+ *
+ * Note that we cannot do a broadcast write to all nodes at once because some
+ * pre-1394a devices would hang. */
+static void nodemgr_irm_write_bc(struct node_entry *ne, int generation)
+{
+        const u64 bc_addr = (CSR_REGISTER_BASE | CSR_BROADCAST_CHANNEL);
+        quadlet_t bc_remote, bc_local;
+        int ret;
+
+        if (!ne->host->is_irm || ne->generation != generation ||
+            ne->nodeid == ne->host->node_id)
+                return;
+
+        bc_local = cpu_to_be32(ne->host->csr.broadcast_channel);
+
+        /* Check if the register is implemented and 1394a compliant. */
+        ret = hpsb_read(ne->host, ne->nodeid, generation, bc_addr, &bc_remote,
+                        sizeof(bc_remote));
+        if (!ret && bc_remote & cpu_to_be32(0x80000000) &&
+            bc_remote != bc_local)
+                hpsb_node_write(ne, bc_addr, &bc_local, sizeof(bc_local));
+}
+
+
 static void nodemgr_probe_ne(struct host_info *hi, struct node_entry *ne, int generation)
 {
         struct device *dev;
@@ -1360,6 +1387,8 @@ static void nodemgr_probe_ne(struct host_info *hi, struct node_entry *ne, int ge
         if (!dev)
                 return;
 
+        nodemgr_irm_write_bc(ne, generation);
+
         /* If "needs_probe", then this is either a new or changed node we
          * rescan totally. If the generation matches for an existing node
          * (one that existed prior to the bus reset) we send update calls
@@ -1413,9 +1442,25 @@ static void nodemgr_node_probe(struct host_info *hi, int generation)
         return;
 }
 
-/* Because we are a 1394a-2000 compliant IRM, we need to inform all the other
- * nodes of the broadcast channel.  (Really we're only setting the validity
- * bit). Other IRM responsibilities go in here as well. */
+static int nodemgr_send_resume_packet(struct hpsb_host *host)
+{
+        struct hpsb_packet *packet;
+        int ret = 1;
+
+        packet = hpsb_make_phypacket(host,
+                        0x003c0000 | NODEID_TO_NODE(host->node_id) << 24);
+        if (packet) {
+                packet->no_waiter = 1;
+                packet->generation = get_hpsb_generation(host);
+                ret = hpsb_send_packet(packet);
+        }
+        if (ret)
+                HPSB_WARN("fw-host%d: Failed to broadcast resume packet",
+                          host->id);
+        return ret;
+}
+
+/* Perform a few high-level IRM responsibilities. */
 static int nodemgr_do_irm_duties(struct hpsb_host *host, int cycles)
 {
         quadlet_t bc;
@@ -1424,13 +1469,8 @@ static int nodemgr_do_irm_duties(struct hpsb_host *host, int cycles)
         if (!host->is_irm || host->irm_id == (nodeid_t)-1)
                 return 1;
 
-        host->csr.broadcast_channel |= 0x40000000;  /* set validity bit */
-
-        bc = cpu_to_be32(host->csr.broadcast_channel);
-
-        hpsb_write(host, LOCAL_BUS | ALL_NODES, get_hpsb_generation(host),
-                   (CSR_REGISTER_BASE | CSR_BROADCAST_CHANNEL),
-                   &bc, sizeof(quadlet_t));
+        /* We are a 1394a-2000 compliant IRM. Set the validity bit. */
+        host->csr.broadcast_channel |= 0x40000000;
 
         /* If there is no bus manager then we should set the root node's
          * force_root bit to promote bus stability per the 1394
@@ -1463,6 +1503,13 @@ static int nodemgr_do_irm_duties(struct hpsb_host *host, int cycles)
                 }
         }
 
+        /* Some devices suspend their ports while being connected to an inactive
+         * host adapter, i.e. if connected before the low-level driver is
+         * loaded.  They become visible either when physically unplugged and
+         * replugged, or when receiving a resume packet.  Send one once. */
+        if (!host->resume_packet_sent && !nodemgr_send_resume_packet(host))
+                host->resume_packet_sent = 1;
+
         return 1;
 }
 
diff --git a/drivers/ieee1394/sbp2.c b/drivers/ieee1394/sbp2.c
index 12cec7c4a342..f7e18ccc5c0a 100644
--- a/drivers/ieee1394/sbp2.c
+++ b/drivers/ieee1394/sbp2.c
@@ -2350,6 +2350,7 @@ static int sbp2_handle_status_write(struct hpsb_host *host, int nodeid, int dest
         struct scsi_cmnd *SCpnt = NULL;
         u32 scsi_status = SBP2_SCSI_STATUS_GOOD;
         struct sbp2_command_info *command;
+        unsigned long flags;
 
         SBP2_DEBUG("sbp2_handle_status_write");
 
@@ -2451,9 +2452,11 @@ static int sbp2_handle_status_write(struct hpsb_host *host, int nodeid, int dest
                  * null out last orb so that next time around we write directly to the orb pointer...
                  * Quick start saves one 1394 bus transaction.
                  */
+                spin_lock_irqsave(&scsi_id->sbp2_command_orb_lock, flags);
                 if (list_empty(&scsi_id->sbp2_command_orb_inuse)) {
                         scsi_id->last_orb = NULL;
                 }
+                spin_unlock_irqrestore(&scsi_id->sbp2_command_orb_lock, flags);
 
         } else {
 
@@ -2563,9 +2566,11 @@ static void sbp2scsi_complete_all_commands(struct scsi_id_instance_data *scsi_id
         struct sbp2scsi_host_info *hi = scsi_id->hi;
         struct list_head *lh;
         struct sbp2_command_info *command;
+        unsigned long flags;
 
         SBP2_DEBUG("sbp2scsi_complete_all_commands");
 
+        spin_lock_irqsave(&scsi_id->sbp2_command_orb_lock, flags);
         while (!list_empty(&scsi_id->sbp2_command_orb_inuse)) {
                 SBP2_DEBUG("Found pending command to complete");
                 lh = scsi_id->sbp2_command_orb_inuse.next;
@@ -2582,6 +2587,7 @@ static void sbp2scsi_complete_all_commands(struct scsi_id_instance_data *scsi_id
                         command->Current_done(command->Current_SCpnt);
                 }
         }
+        spin_unlock_irqrestore(&scsi_id->sbp2_command_orb_lock, flags);
 
         return;
 }