Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
ALSA: sparc/amd7930: 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>
+43
-67
+43
-67
sound/sparc/amd7930.c
+43
-67
sound/sparc/amd7930.c
···
346
346
/* Idle the AMD7930 chip. The amd->lock is not held. */
347
347
static __inline__ void amd7930_idle(struct snd_amd7930 *amd)
348
348
{
349
-
unsigned long flags;
350
-
351
-
spin_lock_irqsave(&amd->lock, flags);
349
+
guard(spinlock_irqsave)(&amd->lock);
352
350
sbus_writeb(AMR_INIT, amd->regs + AMD7930_CR);
353
351
sbus_writeb(0, amd->regs + AMD7930_DR);
354
-
spin_unlock_irqrestore(&amd->lock, flags);
355
352
}
356
353
357
354
/* Enable chip interrupts. The amd->lock is not held. */
358
355
static __inline__ void amd7930_enable_ints(struct snd_amd7930 *amd)
359
356
{
360
-
unsigned long flags;
361
-
362
-
spin_lock_irqsave(&amd->lock, flags);
357
+
guard(spinlock_irqsave)(&amd->lock);
363
358
sbus_writeb(AMR_INIT, amd->regs + AMD7930_CR);
364
359
sbus_writeb(AM_INIT_ACTIVE, amd->regs + AMD7930_DR);
365
-
spin_unlock_irqrestore(&amd->lock, flags);
366
360
}
367
361
368
362
/* Disable chip interrupts. The amd->lock is not held. */
369
363
static __inline__ void amd7930_disable_ints(struct snd_amd7930 *amd)
370
364
{
371
-
unsigned long flags;
372
-
373
-
spin_lock_irqsave(&amd->lock, flags);
365
+
guard(spinlock_irqsave)(&amd->lock);
374
366
sbus_writeb(AMR_INIT, amd->regs + AMD7930_CR);
375
367
sbus_writeb(AM_INIT_ACTIVE | AM_INIT_DISABLE_INTS, amd->regs + AMD7930_DR);
376
-
spin_unlock_irqrestore(&amd->lock, flags);
377
368
}
378
369
379
370
/* Commit amd7930_map settings to the hardware.
···
488
497
unsigned int elapsed;
489
498
u8 ir;
490
499
491
-
spin_lock(&amd->lock);
500
+
scoped_guard(spinlock, &amd->lock) {
501
+
elapsed = 0;
492
502
493
-
elapsed = 0;
503
+
ir = sbus_readb(amd->regs + AMD7930_IR);
504
+
if (ir & AMR_IR_BBUF) {
505
+
u8 byte;
494
506
495
-
ir = sbus_readb(amd->regs + AMD7930_IR);
496
-
if (ir & AMR_IR_BBUF) {
497
-
u8 byte;
498
-
499
-
if (amd->flags & AMD7930_FLAG_PLAYBACK) {
500
-
if (amd->p_left > 0) {
501
-
byte = *(amd->p_cur++);
502
-
amd->p_left--;
503
-
sbus_writeb(byte, amd->regs + AMD7930_BBTB);
504
-
if (amd->p_left == 0)
505
-
elapsed |= AMD7930_FLAG_PLAYBACK;
506
-
} else
507
-
sbus_writeb(0, amd->regs + AMD7930_BBTB);
508
-
} else if (amd->flags & AMD7930_FLAG_CAPTURE) {
509
-
byte = sbus_readb(amd->regs + AMD7930_BBRB);
510
-
if (amd->c_left > 0) {
511
-
*(amd->c_cur++) = byte;
512
-
amd->c_left--;
513
-
if (amd->c_left == 0)
514
-
elapsed |= AMD7930_FLAG_CAPTURE;
507
+
if (amd->flags & AMD7930_FLAG_PLAYBACK) {
508
+
if (amd->p_left > 0) {
509
+
byte = *(amd->p_cur++);
510
+
amd->p_left--;
511
+
sbus_writeb(byte, amd->regs + AMD7930_BBTB);
512
+
if (amd->p_left == 0)
513
+
elapsed |= AMD7930_FLAG_PLAYBACK;
514
+
} else
515
+
sbus_writeb(0, amd->regs + AMD7930_BBTB);
516
+
} else if (amd->flags & AMD7930_FLAG_CAPTURE) {
517
+
byte = sbus_readb(amd->regs + AMD7930_BBRB);
518
+
if (amd->c_left > 0) {
519
+
*(amd->c_cur++) = byte;
520
+
amd->c_left--;
521
+
if (amd->c_left == 0)
522
+
elapsed |= AMD7930_FLAG_CAPTURE;
523
+
}
515
524
}
516
525
}
517
526
}
518
-
spin_unlock(&amd->lock);
519
527
520
528
if (elapsed & AMD7930_FLAG_PLAYBACK)
521
529
snd_pcm_period_elapsed(amd->playback_substream);
···
526
536
527
537
static int snd_amd7930_trigger(struct snd_amd7930 *amd, unsigned int flag, int cmd)
528
538
{
529
-
unsigned long flags;
530
539
int result = 0;
531
540
532
-
spin_lock_irqsave(&amd->lock, flags);
541
+
guard(spinlock_irqsave)(&amd->lock);
533
542
if (cmd == SNDRV_PCM_TRIGGER_START) {
534
543
if (!(amd->flags & flag)) {
535
544
amd->flags |= flag;
···
548
559
} else {
549
560
result = -EINVAL;
550
561
}
551
-
spin_unlock_irqrestore(&amd->lock, flags);
552
562
553
563
return result;
554
564
}
···
571
583
struct snd_amd7930 *amd = snd_pcm_substream_chip(substream);
572
584
struct snd_pcm_runtime *runtime = substream->runtime;
573
585
unsigned int size = snd_pcm_lib_buffer_bytes(substream);
574
-
unsigned long flags;
575
586
u8 new_mmr1;
576
587
577
-
spin_lock_irqsave(&amd->lock, flags);
588
+
guard(spinlock_irqsave)(&amd->lock);
578
589
579
590
amd->flags |= AMD7930_FLAG_PLAYBACK;
580
591
···
592
605
__amd7930_update_map(amd);
593
606
}
594
607
595
-
spin_unlock_irqrestore(&amd->lock, flags);
596
-
597
608
return 0;
598
609
}
599
610
···
600
615
struct snd_amd7930 *amd = snd_pcm_substream_chip(substream);
601
616
struct snd_pcm_runtime *runtime = substream->runtime;
602
617
unsigned int size = snd_pcm_lib_buffer_bytes(substream);
603
-
unsigned long flags;
604
618
u8 new_mmr1;
605
619
606
-
spin_lock_irqsave(&amd->lock, flags);
620
+
guard(spinlock_irqsave)(&amd->lock);
607
621
608
622
amd->flags |= AMD7930_FLAG_CAPTURE;
609
623
···
620
636
amd->map.mmr1 = new_mmr1;
621
637
__amd7930_update_map(amd);
622
638
}
623
-
624
-
spin_unlock_irqrestore(&amd->lock, flags);
625
639
626
640
return 0;
627
641
}
···
787
805
static int snd_amd7930_put_volume(struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
788
806
{
789
807
struct snd_amd7930 *amd = snd_kcontrol_chip(kctl);
790
-
unsigned long flags;
791
808
int type = kctl->private_value;
792
809
int *swval, change;
793
810
···
803
822
break;
804
823
}
805
824
806
-
spin_lock_irqsave(&amd->lock, flags);
825
+
guard(spinlock_irqsave)(&amd->lock);
807
826
808
827
if (*swval != ucontrol->value.integer.value[0]) {
809
828
*swval = ucontrol->value.integer.value[0] & 0xff;
···
811
830
change = 1;
812
831
} else
813
832
change = 0;
814
-
815
-
spin_unlock_irqrestore(&amd->lock, flags);
816
833
817
834
return change;
818
835
}
···
900
921
struct snd_amd7930 **ramd)
901
922
{
902
923
struct snd_amd7930 *amd;
903
-
unsigned long flags;
904
924
int err;
905
925
906
926
*ramd = NULL;
···
933
955
934
956
amd7930_enable_ints(amd);
935
957
936
-
spin_lock_irqsave(&amd->lock, flags);
958
+
scoped_guard(spinlock_irqsave, &amd->lock) {
959
+
amd->rgain = 128;
960
+
amd->pgain = 200;
961
+
amd->mgain = 0;
937
962
938
-
amd->rgain = 128;
939
-
amd->pgain = 200;
940
-
amd->mgain = 0;
963
+
memset(&amd->map, 0, sizeof(amd->map));
964
+
amd->map.mmr1 = (AM_MAP_MMR1_GX | AM_MAP_MMR1_GER |
965
+
AM_MAP_MMR1_GR | AM_MAP_MMR1_STG);
966
+
amd->map.mmr2 = (AM_MAP_MMR2_LS | AM_MAP_MMR2_AINB);
941
967
942
-
memset(&amd->map, 0, sizeof(amd->map));
943
-
amd->map.mmr1 = (AM_MAP_MMR1_GX | AM_MAP_MMR1_GER |
944
-
AM_MAP_MMR1_GR | AM_MAP_MMR1_STG);
945
-
amd->map.mmr2 = (AM_MAP_MMR2_LS | AM_MAP_MMR2_AINB);
968
+
__amd7930_update_map(amd);
946
969
947
-
__amd7930_update_map(amd);
948
-
949
-
/* Always MUX audio (Ba) to channel Bb. */
950
-
sbus_writeb(AMR_MUX_MCR1, amd->regs + AMD7930_CR);
951
-
sbus_writeb(AM_MUX_CHANNEL_Ba | (AM_MUX_CHANNEL_Bb << 4),
952
-
amd->regs + AMD7930_DR);
953
-
954
-
spin_unlock_irqrestore(&amd->lock, flags);
970
+
/* Always MUX audio (Ba) to channel Bb. */
971
+
sbus_writeb(AMR_MUX_MCR1, amd->regs + AMD7930_CR);
972
+
sbus_writeb(AM_MUX_CHANNEL_Ba | (AM_MUX_CHANNEL_Bb << 4),
973
+
amd->regs + AMD7930_DR);
974
+
}
955
975
956
976
err = snd_device_new(card, SNDRV_DEV_LOWLEVEL,
957
977
amd, &snd_amd7930_dev_ops);