tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

ALSA: atiixp: 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/20250829144342.4290-12-tiwai@suse.de

Takashi Iwai 5f7e725e 9608fe85

+30 -40
+16 -22
sound/pci/atiixp.c
··· 345 345 { 346 346 unsigned int i; 347 347 u32 addr, desc_addr; 348 - unsigned long flags; 349 348 350 349 if (periods > ATI_MAX_DESCRIPTORS) 351 350 return -ENOMEM; ··· 362 363 return 0; 363 364 364 365 /* reset DMA before changing the descriptor table */ 365 - spin_lock_irqsave(&chip->reg_lock, flags); 366 - writel(0, chip->remap_addr + dma->ops->llp_offset); 367 - dma->ops->enable_dma(chip, 0); 368 - dma->ops->enable_dma(chip, 1); 369 - spin_unlock_irqrestore(&chip->reg_lock, flags); 366 + scoped_guard(spinlock_irqsave, &chip->reg_lock) { 367 + writel(0, chip->remap_addr + dma->ops->llp_offset); 368 + dma->ops->enable_dma(chip, 0); 369 + dma->ops->enable_dma(chip, 1); 370 + } 370 371 371 372 /* fill the entries */ 372 373 addr = (u32)substream->runtime->dma_addr; ··· 710 711 !dma->ops->flush_dma)) 711 712 return -EINVAL; 712 713 713 - spin_lock(&chip->reg_lock); 714 + guard(spinlock)(&chip->reg_lock); 714 715 switch (cmd) { 715 716 case SNDRV_PCM_TRIGGER_START: 716 717 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: ··· 744 745 snd_atiixp_check_bus_busy(chip); 745 746 } 746 747 } 747 - spin_unlock(&chip->reg_lock); 748 748 return err; 749 749 } 750 750 ··· 857 859 { 858 860 struct atiixp *chip = snd_pcm_substream_chip(substream); 859 861 860 - spin_lock_irq(&chip->reg_lock); 862 + guard(spinlock_irq)(&chip->reg_lock); 861 863 if (chip->spdif_over_aclink) { 862 864 unsigned int data; 863 865 /* enable slots 10/11 */ ··· 875 877 atiixp_update(chip, CMD, ATI_REG_CMD_SPDF_CONFIG_MASK, 0); 876 878 atiixp_update(chip, CMD, ATI_REG_CMD_INTERLEAVE_SPDF, 0); 877 879 } 878 - spin_unlock_irq(&chip->reg_lock); 879 880 return 0; 880 881 } 881 882 ··· 884 887 struct atiixp *chip = snd_pcm_substream_chip(substream); 885 888 unsigned int data; 886 889 887 - spin_lock_irq(&chip->reg_lock); 890 + guard(spinlock_irq)(&chip->reg_lock); 888 891 data = atiixp_read(chip, OUT_DMA_SLOT) & ~ATI_REG_OUT_DMA_SLOT_MASK; 889 892 switch (substream->runtime->channels) { 890 893 case 8: ··· 919 922 atiixp_update(chip, 6CH_REORDER, ATI_REG_6CH_REORDER_EN, 920 923 substream->runtime->channels >= 6 ? ATI_REG_6CH_REORDER_EN: 0); 921 924 922 - spin_unlock_irq(&chip->reg_lock); 923 925 return 0; 924 926 } 925 927 ··· 927 931 { 928 932 struct atiixp *chip = snd_pcm_substream_chip(substream); 929 933 930 - spin_lock_irq(&chip->reg_lock); 934 + guard(spinlock_irq)(&chip->reg_lock); 931 935 atiixp_update(chip, CMD, ATI_REG_CMD_INTERLEAVE_IN, 932 936 substream->runtime->format == SNDRV_PCM_FORMAT_S16_LE ? 933 937 ATI_REG_CMD_INTERLEAVE_IN : 0); 934 - spin_unlock_irq(&chip->reg_lock); 935 938 return 0; 936 939 } 937 940 ··· 1038 1043 runtime->private_data = dma; 1039 1044 1040 1045 /* enable DMA bits */ 1041 - spin_lock_irq(&chip->reg_lock); 1042 - dma->ops->enable_dma(chip, 1); 1043 - spin_unlock_irq(&chip->reg_lock); 1046 + scoped_guard(spinlock_irq, &chip->reg_lock) { 1047 + dma->ops->enable_dma(chip, 1); 1048 + } 1044 1049 dma->opened = 1; 1045 1050 1046 1051 return 0; ··· 1053 1058 /* disable DMA bits */ 1054 1059 if (snd_BUG_ON(!dma->ops || !dma->ops->enable_dma)) 1055 1060 return -EINVAL; 1056 - spin_lock_irq(&chip->reg_lock); 1057 - dma->ops->enable_dma(chip, 0); 1058 - spin_unlock_irq(&chip->reg_lock); 1061 + scoped_guard(spinlock_irq, &chip->reg_lock) { 1062 + dma->ops->enable_dma(chip, 0); 1063 + } 1059 1064 dma->substream = NULL; 1060 1065 dma->opened = 0; 1061 1066 return 0; ··· 1343 1348 if (status & CODEC_CHECK_BITS) { 1344 1349 unsigned int detected; 1345 1350 detected = status & CODEC_CHECK_BITS; 1346 - spin_lock(&chip->reg_lock); 1351 + guard(spinlock)(&chip->reg_lock); 1347 1352 chip->codec_not_ready_bits |= detected; 1348 1353 atiixp_update(chip, IER, detected, 0); /* disable the detected irqs */ 1349 - spin_unlock(&chip->reg_lock); 1350 1354 } 1351 1355 1352 1356 /* ack */
+14 -18
sound/pci/atiixp_modem.c
··· 314 314 { 315 315 unsigned int i; 316 316 u32 addr, desc_addr; 317 - unsigned long flags; 318 317 319 318 if (periods > ATI_MAX_DESCRIPTORS) 320 319 return -ENOMEM; ··· 329 330 return 0; 330 331 331 332 /* reset DMA before changing the descriptor table */ 332 - spin_lock_irqsave(&chip->reg_lock, flags); 333 - writel(0, chip->remap_addr + dma->ops->llp_offset); 334 - dma->ops->enable_dma(chip, 0); 335 - dma->ops->enable_dma(chip, 1); 336 - spin_unlock_irqrestore(&chip->reg_lock, flags); 333 + scoped_guard(spinlock_irqsave, &chip->reg_lock) { 334 + writel(0, chip->remap_addr + dma->ops->llp_offset); 335 + dma->ops->enable_dma(chip, 0); 336 + dma->ops->enable_dma(chip, 1); 337 + } 337 338 338 339 /* fill the entries */ 339 340 addr = (u32)substream->runtime->dma_addr; ··· 660 661 !dma->ops->flush_dma)) 661 662 return -EINVAL; 662 663 663 - spin_lock(&chip->reg_lock); 664 + guard(spinlock)(&chip->reg_lock); 664 665 switch(cmd) { 665 666 case SNDRV_PCM_TRIGGER_START: 666 667 dma->ops->enable_transfer(chip, 1); ··· 681 682 snd_atiixp_check_bus_busy(chip); 682 683 } 683 684 } 684 - spin_unlock(&chip->reg_lock); 685 685 return err; 686 686 } 687 687 ··· 751 753 struct atiixp_modem *chip = snd_pcm_substream_chip(substream); 752 754 unsigned int data; 753 755 754 - spin_lock_irq(&chip->reg_lock); 756 + guard(spinlock_irq)(&chip->reg_lock); 755 757 /* set output threshold */ 756 758 data = atiixp_read(chip, MODEM_OUT_FIFO); 757 759 data &= ~ATI_REG_MODEM_OUT1_DMA_THRESHOLD_MASK; 758 760 data |= 0x04 << ATI_REG_MODEM_OUT1_DMA_THRESHOLD_SHIFT; 759 761 atiixp_write(chip, MODEM_OUT_FIFO, data); 760 - spin_unlock_irq(&chip->reg_lock); 761 762 return 0; 762 763 } 763 764 ··· 861 864 runtime->private_data = dma; 862 865 863 866 /* enable DMA bits */ 864 - spin_lock_irq(&chip->reg_lock); 865 - dma->ops->enable_dma(chip, 1); 866 - spin_unlock_irq(&chip->reg_lock); 867 + scoped_guard(spinlock_irq, &chip->reg_lock) { 868 + dma->ops->enable_dma(chip, 1); 869 + } 867 870 dma->opened = 1; 868 871 869 872 return 0; ··· 876 879 /* disable DMA bits */ 877 880 if (snd_BUG_ON(!dma->ops || !dma->ops->enable_dma)) 878 881 return -EINVAL; 879 - spin_lock_irq(&chip->reg_lock); 880 - dma->ops->enable_dma(chip, 0); 881 - spin_unlock_irq(&chip->reg_lock); 882 + scoped_guard(spinlock_irq, &chip->reg_lock) { 883 + dma->ops->enable_dma(chip, 0); 884 + } 882 885 dma->substream = NULL; 883 886 dma->opened = 0; 884 887 return 0; ··· 1010 1013 if (status & CODEC_CHECK_BITS) { 1011 1014 unsigned int detected; 1012 1015 detected = status & CODEC_CHECK_BITS; 1013 - spin_lock(&chip->reg_lock); 1016 + guard(spinlock)(&chip->reg_lock); 1014 1017 chip->codec_not_ready_bits |= detected; 1015 1018 atiixp_update(chip, IER, detected, 0); /* disable the detected irqs */ 1016 - spin_unlock(&chip->reg_lock); 1017 1019 } 1018 1020 1019 1021 /* ack */