firewire: octlet AT payloads can be stack-allocated

We do not need slab allocations anymore in order to satisfy
streaming DMA mapping constraints, thanks to commit da28947e7e36
"firewire: ohci: avoid separate DMA mapping for small AT payloads".

(Besides, the slab-allocated buffers that firewire-core, firewire-sbp2,
and firedtv used to provide for 8-byte write and lock requests were
still not fully portable since they crossed cacheline boundaries or
shared a cacheline with unrelated CPU-accessed data.  snd-firewire-lib
got this aspect right by using an extra kmalloc/ kfree just for the
8-byte transaction buffer.)

This change replaces kmalloc'ed lock transaction scratch buffers in
firewire-core, firedtv, and snd-firewire-lib by local stack allocations.
Perhaps the most notable result of the change is simpler locking because
there is no need to serialize usages of preallocated per-device buffers
anymore.  Also, allocations and deallocations are simpler.

Signed-off-by: Stefan Richter <stefanr@s5r6.in-berlin.de>
Acked-by: Clemens Ladisch <clemens@ladisch.de>

1 files changed, 8 insertions, 8 deletions

diff --git a/drivers/firewire/core-card.c b/drivers/firewire/core-card.c
index 3c44fbc81acb..e119f1e6ba47 100644
--- a/drivers/firewire/core-card.c
+++ b/drivers/firewire/core-card.c
@@ -258,8 +258,7 @@ static void allocate_broadcast_channel(struct fw_card *card, int generation)
 
         if (!card->broadcast_channel_allocated) {
                 fw_iso_resource_manage(card, generation, 1ULL << 31,
-                                       &channel, &bandwidth, true,
-                                       card->bm_transaction_data);
+                                       &channel, &bandwidth, true);
                 if (channel != 31) {
                         fw_notify("failed to allocate broadcast channel\n");
                         return;
@@ -294,6 +293,7 @@ static void bm_work(struct work_struct *work)
         bool root_device_is_cmc;
         bool irm_is_1394_1995_only;
         bool keep_this_irm;
+        __be32 transaction_data[2];
 
         spin_lock_irq(&card->lock);
 
@@ -355,21 +355,21 @@ static void bm_work(struct work_struct *work)
                         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_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, 8);
+                                transaction_data, 8);
 
                 if (rcode == RCODE_GENERATION)
                         /* Another bus reset, BM work has been rescheduled. */
                         goto out;
 
-                bm_id = be32_to_cpu(card->bm_transaction_data[0]);
+                bm_id = be32_to_cpu(transaction_data[0]);
 
                 spin_lock_irq(&card->lock);
                 if (rcode == RCODE_COMPLETE && generation == card->generation)
@@ -490,11 +490,11 @@ static void bm_work(struct work_struct *work)
                 /*
                  * Make sure that the cycle master sends cycle start packets.
                  */
-                card->bm_transaction_data[0] = cpu_to_be32(CSR_STATE_BIT_CMSTR);
+                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,
-                                card->bm_transaction_data, 4);
+                                transaction_data, 4);
                 if (rcode == RCODE_GENERATION)
                         goto out;
         }