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: opl4: 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/20250829150026.6379-7-tiwai@suse.de

Takashi Iwai 72a30170 45451eb5

+39 -60
+2 -8
sound/drivers/opl4/opl4_lib.c
··· 47 47 48 48 void snd_opl4_read_memory(struct snd_opl4 *opl4, char *buf, int offset, int size) 49 49 { 50 - unsigned long flags; 51 50 u8 memcfg; 52 51 53 - spin_lock_irqsave(&opl4->reg_lock, flags); 52 + guard(spinlock_irqsave)(&opl4->reg_lock); 54 53 55 54 memcfg = snd_opl4_read(opl4, OPL4_REG_MEMORY_CONFIGURATION); 56 55 snd_opl4_write(opl4, OPL4_REG_MEMORY_CONFIGURATION, memcfg | OPL4_MODE_BIT); ··· 64 65 insb(opl4->pcm_port + 1, buf, size); 65 66 66 67 snd_opl4_write(opl4, OPL4_REG_MEMORY_CONFIGURATION, memcfg); 67 - 68 - spin_unlock_irqrestore(&opl4->reg_lock, flags); 69 68 } 70 69 71 70 EXPORT_SYMBOL(snd_opl4_read_memory); 72 71 73 72 void snd_opl4_write_memory(struct snd_opl4 *opl4, const char *buf, int offset, int size) 74 73 { 75 - unsigned long flags; 76 74 u8 memcfg; 77 75 78 - spin_lock_irqsave(&opl4->reg_lock, flags); 76 + guard(spinlock_irqsave)(&opl4->reg_lock); 79 77 80 78 memcfg = snd_opl4_read(opl4, OPL4_REG_MEMORY_CONFIGURATION); 81 79 snd_opl4_write(opl4, OPL4_REG_MEMORY_CONFIGURATION, memcfg | OPL4_MODE_BIT); ··· 87 91 outsb(opl4->pcm_port + 1, buf, size); 88 92 89 93 snd_opl4_write(opl4, OPL4_REG_MEMORY_CONFIGURATION, memcfg); 90 - 91 - spin_unlock_irqrestore(&opl4->reg_lock, flags); 92 94 } 93 95 94 96 EXPORT_SYMBOL(snd_opl4_write_memory);
+2 -6
sound/drivers/opl4/opl4_mixer.c
··· 19 19 static int snd_opl4_ctl_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 20 20 { 21 21 struct snd_opl4 *opl4 = snd_kcontrol_chip(kcontrol); 22 - unsigned long flags; 23 22 u8 reg = kcontrol->private_value; 24 23 u8 value; 25 24 26 - spin_lock_irqsave(&opl4->reg_lock, flags); 25 + guard(spinlock_irqsave)(&opl4->reg_lock); 27 26 value = snd_opl4_read(opl4, reg); 28 - spin_unlock_irqrestore(&opl4->reg_lock, flags); 29 27 ucontrol->value.integer.value[0] = 7 - (value & 7); 30 28 ucontrol->value.integer.value[1] = 7 - ((value >> 3) & 7); 31 29 return 0; ··· 32 34 static int snd_opl4_ctl_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 33 35 { 34 36 struct snd_opl4 *opl4 = snd_kcontrol_chip(kcontrol); 35 - unsigned long flags; 36 37 u8 reg = kcontrol->private_value; 37 38 u8 value, old_value; 38 39 39 40 value = (7 - (ucontrol->value.integer.value[0] & 7)) | 40 41 ((7 - (ucontrol->value.integer.value[1] & 7)) << 3); 41 - spin_lock_irqsave(&opl4->reg_lock, flags); 42 + guard(spinlock_irqsave)(&opl4->reg_lock); 42 43 old_value = snd_opl4_read(opl4, reg); 43 44 snd_opl4_write(opl4, reg, value); 44 - spin_unlock_irqrestore(&opl4->reg_lock, flags); 45 45 return value != old_value; 46 46 } 47 47
+35 -46
sound/drivers/opl4/opl4_synth.c
··· 272 272 */ 273 273 void snd_opl4_synth_reset(struct snd_opl4 *opl4) 274 274 { 275 - unsigned long flags; 276 275 int i; 277 276 278 - spin_lock_irqsave(&opl4->reg_lock, flags); 279 - for (i = 0; i < OPL4_MAX_VOICES; i++) 280 - snd_opl4_write(opl4, OPL4_REG_MISC + i, OPL4_DAMP_BIT); 281 - spin_unlock_irqrestore(&opl4->reg_lock, flags); 277 + scoped_guard(spinlock_irqsave, &opl4->reg_lock) { 278 + for (i = 0; i < OPL4_MAX_VOICES; i++) 279 + snd_opl4_write(opl4, OPL4_REG_MISC + i, OPL4_DAMP_BIT); 280 + } 282 281 283 282 INIT_LIST_HEAD(&opl4->off_voices); 284 283 INIT_LIST_HEAD(&opl4->on_voices); ··· 295 296 */ 296 297 void snd_opl4_synth_shutdown(struct snd_opl4 *opl4) 297 298 { 298 - unsigned long flags; 299 299 int i; 300 300 301 - spin_lock_irqsave(&opl4->reg_lock, flags); 301 + guard(spinlock_irqsave)(&opl4->reg_lock); 302 302 for (i = 0; i < OPL4_MAX_VOICES; i++) 303 303 snd_opl4_write(opl4, OPL4_REG_MISC + i, 304 304 opl4->voices[i].reg_misc & ~OPL4_KEY_ON_BIT); 305 - spin_unlock_irqrestore(&opl4->reg_lock, flags); 306 305 } 307 306 308 307 /* ··· 310 313 void (*func)(struct snd_opl4 *opl4, struct opl4_voice *voice)) 311 314 { 312 315 int i; 313 - unsigned long flags; 314 316 struct opl4_voice *voice; 315 317 316 - spin_lock_irqsave(&opl4->reg_lock, flags); 318 + guard(spinlock_irqsave)(&opl4->reg_lock); 317 319 for (i = 0; i < OPL4_MAX_VOICES; i++) { 318 320 voice = &opl4->voices[i]; 319 321 if (voice->chan == chan && voice->note == note) { 320 322 func(opl4, voice); 321 323 } 322 324 } 323 - spin_unlock_irqrestore(&opl4->reg_lock, flags); 324 325 } 325 326 326 327 /* ··· 329 334 void (*func)(struct snd_opl4 *opl4, struct opl4_voice *voice)) 330 335 { 331 336 int i; 332 - unsigned long flags; 333 337 struct opl4_voice *voice; 334 338 335 - spin_lock_irqsave(&opl4->reg_lock, flags); 339 + guard(spinlock_irqsave)(&opl4->reg_lock); 336 340 for (i = 0; i < OPL4_MAX_VOICES; i++) { 337 341 voice = &opl4->voices[i]; 338 342 if (voice->chan == chan) { 339 343 func(opl4, voice); 340 344 } 341 345 } 342 - spin_unlock_irqrestore(&opl4->reg_lock, flags); 343 346 } 344 347 345 348 /* ··· 347 354 void (*func)(struct snd_opl4 *opl4, struct opl4_voice *voice)) 348 355 { 349 356 int i; 350 - unsigned long flags; 351 357 struct opl4_voice *voice; 352 358 353 - spin_lock_irqsave(&opl4->reg_lock, flags); 359 + guard(spinlock_irqsave)(&opl4->reg_lock); 354 360 for (i = 0; i < OPL4_MAX_VOICES; i++) { 355 361 voice = &opl4->voices[i]; 356 362 if (voice->chan) 357 363 func(opl4, voice); 358 364 } 359 - spin_unlock_irqrestore(&opl4->reg_lock, flags); 360 365 } 361 366 362 367 static void snd_opl4_update_volume(struct snd_opl4 *opl4, struct opl4_voice *voice) ··· 477 486 struct opl4_voice *voice[2]; 478 487 const struct opl4_sound *sound[2]; 479 488 int voices = 0, i; 480 - unsigned long flags; 481 489 482 490 /* determine the number of voices and voice parameters */ 483 491 i = chan->drum_channel ? 0x80 : (chan->midi_program & 0x7f); ··· 491 501 } 492 502 493 503 /* allocate and initialize the needed voices */ 494 - spin_lock_irqsave(&opl4->reg_lock, flags); 495 - for (i = 0; i < voices; i++) { 496 - voice[i] = snd_opl4_get_voice(opl4); 497 - list_move_tail(&voice[i]->list, &opl4->on_voices); 498 - voice[i]->chan = chan; 499 - voice[i]->note = note; 500 - voice[i]->velocity = vel & 0x7f; 501 - voice[i]->sound = sound[i]; 502 - } 504 + scoped_guard(spinlock_irqsave, &opl4->reg_lock) { 505 + for (i = 0; i < voices; i++) { 506 + voice[i] = snd_opl4_get_voice(opl4); 507 + list_move_tail(&voice[i]->list, &opl4->on_voices); 508 + voice[i]->chan = chan; 509 + voice[i]->note = note; 510 + voice[i]->velocity = vel & 0x7f; 511 + voice[i]->sound = sound[i]; 512 + } 503 513 504 - /* set tone number (triggers header loading) */ 505 - for (i = 0; i < voices; i++) { 506 - voice[i]->reg_f_number = 507 - (sound[i]->tone >> 8) & OPL4_TONE_NUMBER_BIT8; 508 - snd_opl4_write(opl4, OPL4_REG_F_NUMBER + voice[i]->number, 509 - voice[i]->reg_f_number); 510 - snd_opl4_write(opl4, OPL4_REG_TONE_NUMBER + voice[i]->number, 511 - sound[i]->tone & 0xff); 512 - } 514 + /* set tone number (triggers header loading) */ 515 + for (i = 0; i < voices; i++) { 516 + voice[i]->reg_f_number = 517 + (sound[i]->tone >> 8) & OPL4_TONE_NUMBER_BIT8; 518 + snd_opl4_write(opl4, OPL4_REG_F_NUMBER + voice[i]->number, 519 + voice[i]->reg_f_number); 520 + snd_opl4_write(opl4, OPL4_REG_TONE_NUMBER + voice[i]->number, 521 + sound[i]->tone & 0xff); 522 + } 513 523 514 - /* set parameters which can be set while loading */ 515 - for (i = 0; i < voices; i++) { 516 - voice[i]->reg_misc = OPL4_LFO_RESET_BIT; 517 - snd_opl4_update_pan(opl4, voice[i]); 518 - snd_opl4_update_pitch(opl4, voice[i]); 519 - voice[i]->level_direct = OPL4_LEVEL_DIRECT_BIT; 520 - snd_opl4_update_volume(opl4, voice[i]); 524 + /* set parameters which can be set while loading */ 525 + for (i = 0; i < voices; i++) { 526 + voice[i]->reg_misc = OPL4_LFO_RESET_BIT; 527 + snd_opl4_update_pan(opl4, voice[i]); 528 + snd_opl4_update_pitch(opl4, voice[i]); 529 + voice[i]->level_direct = OPL4_LEVEL_DIRECT_BIT; 530 + snd_opl4_update_volume(opl4, voice[i]); 531 + } 521 532 } 522 - spin_unlock_irqrestore(&opl4->reg_lock, flags); 523 533 524 534 /* wait for completion of loading */ 525 535 snd_opl4_wait_for_wave_headers(opl4); 526 536 527 537 /* set remaining parameters */ 528 - spin_lock_irqsave(&opl4->reg_lock, flags); 538 + guard(spinlock_irqsave)(&opl4->reg_lock); 529 539 for (i = 0; i < voices; i++) { 530 540 snd_opl4_update_tone_parameters(opl4, voice[i]); 531 541 voice[i]->reg_lfo_vibrato = voice[i]->sound->reg_lfo_vibrato; ··· 539 549 snd_opl4_write(opl4, OPL4_REG_MISC + voice[i]->number, 540 550 voice[i]->reg_misc); 541 551 } 542 - spin_unlock_irqrestore(&opl4->reg_lock, flags); 543 552 } 544 553 545 554 static void snd_opl4_voice_off(struct snd_opl4 *opl4, struct opl4_voice *voice)