ALSA: wavefront: Use guard() for spin locks

Clean up the code using guard() for spin locks.

Merely code refactoring, and no behavior change.

Signed-off-by: Takashi Iwai <tiwai@suse.de>
Link: https://patch.msgid.link/20250829145300.5460-19-tiwai@suse.de

diff --git a/sound/isa/wavefront/wavefront_midi.c b/sound/isa/wavefront/wavefront_midi.c
index 494b21be665c8aa6dbe7d2de1cc57efae3b24322..1250ecba659a059a800320d86211de130276e35e 100644 (file)
--- a/sound/isa/wavefront/wavefront_midi.c
+++ b/sound/isa/wavefront/wavefront_midi.c
@@ -113,7 +113,6 @@ static void snd_wavefront_midi_output_write(snd_wavefront_card_t *card)
 {
        snd_wavefront_midi_t *midi = &card->wavefront.midi;
        snd_wavefront_mpu_id  mpu;
-       unsigned long flags;
        unsigned char midi_byte;
        int max = 256, mask = 1;
        int timeout;
@@ -142,11 +141,9 @@ static void snd_wavefront_midi_output_write(snd_wavefront_card_t *card)
                                break;
                }
        
-               spin_lock_irqsave (&midi->virtual, flags);
-               if ((midi->mode[midi->output_mpu] & MPU401_MODE_OUTPUT) == 0) {
-                       spin_unlock_irqrestore (&midi->virtual, flags);
+               guard(spinlock_irqsave)(&midi->virtual);
+               if ((midi->mode[midi->output_mpu] & MPU401_MODE_OUTPUT) == 0)
                        goto __second;
-               }
                if (output_ready (midi)) {
                        if (snd_rawmidi_transmit(midi->substream_output[midi->output_mpu], &midi_byte, 1) == 1) {
                                if (!midi->isvirtual ||
@@ -160,14 +157,11 @@ static void snd_wavefront_midi_output_write(snd_wavefront_card_t *card)
                                                timer_delete(&midi->timer);
                                }
                                midi->mode[midi->output_mpu] &= ~MPU401_MODE_OUTPUT_TRIGGER;
-                               spin_unlock_irqrestore (&midi->virtual, flags);
                                goto __second;
                        }
                } else {
-                       spin_unlock_irqrestore (&midi->virtual, flags);
                        return;
                }
-               spin_unlock_irqrestore (&midi->virtual, flags);
        }
 
       __second:
@@ -185,15 +179,13 @@ static void snd_wavefront_midi_output_write(snd_wavefront_card_t *card)
                                break;
                }
        
-               spin_lock_irqsave (&midi->virtual, flags);
+               guard(spinlock_irqsave)(&midi->virtual);
                if (!midi->isvirtual)
                        mask = 0;
                mpu = midi->output_mpu ^ mask;
                mask = 0;       /* don't invert the value from now */
-               if ((midi->mode[mpu] & MPU401_MODE_OUTPUT) == 0) {
-                       spin_unlock_irqrestore (&midi->virtual, flags);
+               if ((midi->mode[mpu] & MPU401_MODE_OUTPUT) == 0)
                        return;
-               }
                if (snd_rawmidi_transmit_empty(midi->substream_output[mpu]))
                        goto __timer;
                if (output_ready (midi)) {
@@ -215,20 +207,16 @@ static void snd_wavefront_midi_output_write(snd_wavefront_card_t *card)
                                                timer_delete(&midi->timer);
                                }
                                midi->mode[mpu] &= ~MPU401_MODE_OUTPUT_TRIGGER;
-                               spin_unlock_irqrestore (&midi->virtual, flags);
                                return;
                        }
                } else {
-                       spin_unlock_irqrestore (&midi->virtual, flags);
                        return;
                }
-               spin_unlock_irqrestore (&midi->virtual, flags);
        }
 }
 
 static int snd_wavefront_midi_input_open(struct snd_rawmidi_substream *substream)
 {
-       unsigned long flags;
        snd_wavefront_midi_t *midi;
        snd_wavefront_mpu_id mpu;
 
@@ -243,17 +231,15 @@ static int snd_wavefront_midi_input_open(struct snd_rawmidi_substream *substream
        if (!midi)
                return -EIO;
 
-       spin_lock_irqsave (&midi->open, flags);
+       guard(spinlock_irqsave)(&midi->open);
        midi->mode[mpu] |= MPU401_MODE_INPUT;
        midi->substream_input[mpu] = substream;
-       spin_unlock_irqrestore (&midi->open, flags);
 
        return 0;
 }
 
 static int snd_wavefront_midi_output_open(struct snd_rawmidi_substream *substream)
 {
-       unsigned long flags;
        snd_wavefront_midi_t *midi;
        snd_wavefront_mpu_id mpu;
 
@@ -268,17 +254,15 @@ static int snd_wavefront_midi_output_open(struct snd_rawmidi_substream *substrea
        if (!midi)
                return -EIO;
 
-       spin_lock_irqsave (&midi->open, flags);
+       guard(spinlock_irqsave)(&midi->open);
        midi->mode[mpu] |= MPU401_MODE_OUTPUT;
        midi->substream_output[mpu] = substream;
-       spin_unlock_irqrestore (&midi->open, flags);
 
        return 0;
 }
 
 static int snd_wavefront_midi_input_close(struct snd_rawmidi_substream *substream)
 {
-       unsigned long flags;
        snd_wavefront_midi_t *midi;
        snd_wavefront_mpu_id mpu;
 
@@ -293,16 +277,14 @@ static int snd_wavefront_midi_input_close(struct snd_rawmidi_substream *substrea
        if (!midi)
                return -EIO;
 
-       spin_lock_irqsave (&midi->open, flags);
+       guard(spinlock_irqsave)(&midi->open);
        midi->mode[mpu] &= ~MPU401_MODE_INPUT;
-       spin_unlock_irqrestore (&midi->open, flags);
 
        return 0;
 }
 
 static int snd_wavefront_midi_output_close(struct snd_rawmidi_substream *substream)
 {
-       unsigned long flags;
        snd_wavefront_midi_t *midi;
        snd_wavefront_mpu_id mpu;
 
@@ -317,15 +299,13 @@ static int snd_wavefront_midi_output_close(struct snd_rawmidi_substream *substre
        if (!midi)
                return -EIO;
 
-       spin_lock_irqsave (&midi->open, flags);
+       guard(spinlock_irqsave)(&midi->open);
        midi->mode[mpu] &= ~MPU401_MODE_OUTPUT;
-       spin_unlock_irqrestore (&midi->open, flags);
        return 0;
 }
 
 static void snd_wavefront_midi_input_trigger(struct snd_rawmidi_substream *substream, int up)
 {
-       unsigned long flags;
        snd_wavefront_midi_t *midi;
        snd_wavefront_mpu_id mpu;
 
@@ -341,30 +321,27 @@ static void snd_wavefront_midi_input_trigger(struct snd_rawmidi_substream *subst
        if (!midi)
                return;
 
-       spin_lock_irqsave (&midi->virtual, flags);
+       guard(spinlock_irqsave)(&midi->virtual);
        if (up) {
                midi->mode[mpu] |= MPU401_MODE_INPUT_TRIGGER;
        } else {
                midi->mode[mpu] &= ~MPU401_MODE_INPUT_TRIGGER;
        }
-       spin_unlock_irqrestore (&midi->virtual, flags);
 }
 
 static void snd_wavefront_midi_output_timer(struct timer_list *t)
 {
        snd_wavefront_midi_t *midi = timer_container_of(midi, t, timer);
        snd_wavefront_card_t *card = midi->timer_card;
-       unsigned long flags;
        
-       spin_lock_irqsave (&midi->virtual, flags);
-       mod_timer(&midi->timer, 1 + jiffies);
-       spin_unlock_irqrestore (&midi->virtual, flags);
+       scoped_guard(spinlock_irqsave, &midi->virtual) {
+               mod_timer(&midi->timer, 1 + jiffies);
+       }
        snd_wavefront_midi_output_write(card);
 }
 
 static void snd_wavefront_midi_output_trigger(struct snd_rawmidi_substream *substream, int up)
 {
-       unsigned long flags;
        snd_wavefront_midi_t *midi;
        snd_wavefront_mpu_id mpu;
 
@@ -380,22 +357,22 @@ static void snd_wavefront_midi_output_trigger(struct snd_rawmidi_substream *subs
        if (!midi)
                return;
 
-       spin_lock_irqsave (&midi->virtual, flags);
-       if (up) {
-               if ((midi->mode[mpu] & MPU401_MODE_OUTPUT_TRIGGER) == 0) {
-                       if (!midi->istimer) {
-                               timer_setup(&midi->timer,
-                                           snd_wavefront_midi_output_timer,
-                                           0);
-                               mod_timer(&midi->timer, 1 + jiffies);
+       scoped_guard(spinlock_irqsave, &midi->virtual) {
+               if (up) {
+                       if ((midi->mode[mpu] & MPU401_MODE_OUTPUT_TRIGGER) == 0) {
+                               if (!midi->istimer) {
+                                       timer_setup(&midi->timer,
+                                                   snd_wavefront_midi_output_timer,
+                                                   0);
+                                       mod_timer(&midi->timer, 1 + jiffies);
+                               }
+                               midi->istimer++;
+                               midi->mode[mpu] |= MPU401_MODE_OUTPUT_TRIGGER;
                        }
-                       midi->istimer++;
-                       midi->mode[mpu] |= MPU401_MODE_OUTPUT_TRIGGER;
+               } else {
+                       midi->mode[mpu] &= ~MPU401_MODE_OUTPUT_TRIGGER;
                }
-       } else {
-               midi->mode[mpu] &= ~MPU401_MODE_OUTPUT_TRIGGER;
        }
-       spin_unlock_irqrestore (&midi->virtual, flags);
 
        if (up)
                snd_wavefront_midi_output_write((snd_wavefront_card_t *)substream->rmidi->card->private_data);
@@ -405,7 +382,6 @@ void
 snd_wavefront_midi_interrupt (snd_wavefront_card_t *card)
 
 {
-       unsigned long flags;
        snd_wavefront_midi_t *midi;
        static struct snd_rawmidi_substream *substream = NULL;
        static int mpu = external_mpu; 
@@ -419,37 +395,37 @@ snd_wavefront_midi_interrupt (snd_wavefront_card_t *card)
                return;
        }
 
-       spin_lock_irqsave (&midi->virtual, flags);
-       while (--max) {
-
-               if (input_avail (midi)) {
-                       byte = read_data (midi);
-
-                       if (midi->isvirtual) {                          
-                               if (byte == WF_EXTERNAL_SWITCH) {
-                                       substream = midi->substream_input[external_mpu];
-                                       mpu = external_mpu;
-                               } else if (byte == WF_INTERNAL_SWITCH) { 
-                                       substream = midi->substream_output[internal_mpu];
+       scoped_guard(spinlock_irqsave, &midi->virtual) {
+               while (--max) {
+
+                       if (input_avail(midi)) {
+                               byte = read_data(midi);
+
+                               if (midi->isvirtual) {
+                                       if (byte == WF_EXTERNAL_SWITCH) {
+                                               substream = midi->substream_input[external_mpu];
+                                               mpu = external_mpu;
+                                       } else if (byte == WF_INTERNAL_SWITCH) {
+                                               substream = midi->substream_output[internal_mpu];
+                                               mpu = internal_mpu;
+                                       } /* else just leave it as it is */
+                               } else {
+                                       substream = midi->substream_input[internal_mpu];
                                        mpu = internal_mpu;
-                               } /* else just leave it as it is */
-                       } else {
-                               substream = midi->substream_input[internal_mpu];
-                               mpu = internal_mpu;
-                       }
+                               }
 
-                       if (substream == NULL) {
-                               continue;
-                       }
+                               if (substream == NULL) {
+                                       continue;
+                               }
 
-                       if (midi->mode[mpu] & MPU401_MODE_INPUT_TRIGGER) {
-                               snd_rawmidi_receive(substream, &byte, 1);
+                               if (midi->mode[mpu] & MPU401_MODE_INPUT_TRIGGER) {
+                                       snd_rawmidi_receive(substream, &byte, 1);
+                               }
+                       } else {
+                               break;
                        }
-               } else {
-                       break;
                }
-       } 
-       spin_unlock_irqrestore (&midi->virtual, flags);
+       }
 
        snd_wavefront_midi_output_write(card);
 }
@@ -471,13 +447,10 @@ void
 snd_wavefront_midi_disable_virtual (snd_wavefront_card_t *card)
 
 {
-       unsigned long flags;
-
-       spin_lock_irqsave (&card->wavefront.midi.virtual, flags);
+       guard(spinlock_irqsave)(&card->wavefront.midi.virtual);
        // snd_wavefront_midi_input_close (card->ics2115_external_rmidi);
        // snd_wavefront_midi_output_close (card->ics2115_external_rmidi);
        card->wavefront.midi.isvirtual = 0;
-       spin_unlock_irqrestore (&card->wavefront.midi.virtual, flags);
 }
 
 int

diff --git a/sound/isa/wavefront/wavefront_synth.c b/sound/isa/wavefront/wavefront_synth.c
index bd679e2da154e2a25eea522c2e3205ecb660caf1..cd5c177943aa0d77c6177c21049d7d0cd301661e 100644 (file)
--- a/sound/isa/wavefront/wavefront_synth.c
+++ b/sound/isa/wavefront/wavefront_synth.c
@@ -1741,10 +1741,10 @@ snd_wavefront_internal_interrupt (snd_wavefront_card_t *card)
                return;
        }
 
-       spin_lock(&dev->irq_lock);
-       dev->irq_ok = 1;
-       dev->irq_cnt++;
-       spin_unlock(&dev->irq_lock);
+       scoped_guard(spinlock, &dev->irq_lock) {
+               dev->irq_ok = 1;
+               dev->irq_cnt++;
+       }
        wake_up(&dev->interrupt_sleeper);
 }
 
@@ -1796,11 +1796,11 @@ wavefront_should_cause_interrupt (snd_wavefront_t *dev,
        wait_queue_entry_t wait;
 
        init_waitqueue_entry(&wait, current);
-       spin_lock_irq(&dev->irq_lock);
-       add_wait_queue(&dev->interrupt_sleeper, &wait);
-       dev->irq_ok = 0;
-       outb (val,port);
-       spin_unlock_irq(&dev->irq_lock);
+       scoped_guard(spinlock_irq, &dev->irq_lock) {
+               add_wait_queue(&dev->interrupt_sleeper, &wait);
+               dev->irq_ok = 0;
+               outb(val, port);
+       }
        while (!dev->irq_ok && time_before(jiffies, timeout)) {
                schedule_timeout_uninterruptible(1);
                barrier();