From nobody Sat Apr 11 13:38:35 2026 Received: from mail-vs1-f49.google.com (mail-vs1-f49.google.com [209.85.217.49]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 11D0C2F12C6 for ; Mon, 6 Apr 2026 03:20:16 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.217.49 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1775445618; cv=none; b=AKVMswB5//RuZh7O86OGJOeFLv8kaCPN4FE+iyziLCEmzTiM7lfqmajN+EdGo+1hSgADa0wf3QsbUEvgEeg1CUZxtTCnqfq4sU0S7Qs3/zUiLA8IROwBE4FfTAsFwWrhVW6jNbfvZYFTUTSHgI36zBA03FKfrIDxcx4niZ34LMY= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1775445618; c=relaxed/simple; bh=ZJsXuAOnzKe7VNcjOOvgpbIj4nvUPV0wpNzyd65c2Xo=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=uNNjLED9pNjSf7NCdh7+epwyiamJ+lFadSL7C0CUAoEi1huC30l1dM4nTjZgdn0dXMAYFJlfIQDrnyADAlW+lg03ye2ooQDmOuGgTtI5jjzo87ekFa0OsrSFkd0g9EIySbyLP4sQFlXuWe+Py2f0jGquoeNMtmm0VFc6gwkp03U= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=sEXRkMuu; arc=none smtp.client-ip=209.85.217.49 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="sEXRkMuu" Received: by mail-vs1-f49.google.com with SMTP id ada2fe7eead31-605a8c4ebc6so1834511137.2 for ; Sun, 05 Apr 2026 20:20:16 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20251104; t=1775445616; x=1776050416; darn=vger.kernel.org; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:from:to:cc:subject:date:message-id :reply-to; bh=HQXVPyJKbYWfAKG1sfpIlUyWhhnLyrzOHWVzvosbwME=; b=sEXRkMuuE1HoqEj2QIbKWiLsLfGcBWli8/CnYQQITVH71kiWfxjnVLSUTFqM8G0nkL U+xEG8fBSccEJl4oSKNOUL+FS1kthfgY+wtvomAByCq0rNqUMJO0/8qX5KoEgH/3fljC jNYG8HE1JL71ZfPa27lKhqYClsV0xywUhyrZZJIYeAU14xp+7bUhQ57wb7WLzt6omesR agjFe9aMmpNwiC6bB0FfafVv4yvLt1UQuW15dlJ6hA96SeZdvH9og7jw1RZ0vabV62rI R1fLh5+zIzbW5c2SwtwE6h7GD1I5cgRqzSAImgs6B4rJN8XS0bEwTffiY7AMTB07C51d +AAQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1775445616; x=1776050416; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-gg:x-gm-message-state:from:to :cc:subject:date:message-id:reply-to; bh=HQXVPyJKbYWfAKG1sfpIlUyWhhnLyrzOHWVzvosbwME=; b=Lndv1JSHFq76UGQhb3VjR691ilaRMwLjrL6F5n1YiW8PnXJ9Ccgn/0kfcRpb4nXTca Qd17lrLGiuvZS3xHg4IVb5dN+H8AVNezhSbF3eg1ckOxYSBv+pZtvRTW0OZHA8qqPwmv aIroeeiSq/f+vv3xezUeaIamvtlA5AHZLddJQrs3GAix5BOUoGsZbu+8g10BqKcsyhvF Q9yxHxWRcXfUvs4VIC/a58NvLwh58XHSryqB/SgILLPhPbqLqXe5RMPKLmJv2VumFgsm xzW3UFzkVWwI3g60SouEpmE2IkMByQ/xRYFaFbRHDkDvSs1ttJ3hHm1QYkOp9p1c/XEc 9ogA== X-Forwarded-Encrypted: i=1; AJvYcCVhP9nrc3tTBize+TIeVSmQjMdpTnqXw+yCrua6shhxXrFc5MzJVpO3S9nMLVSQp4sYLdEudTjine/jLeg=@vger.kernel.org X-Gm-Message-State: AOJu0YxZcTxiEQfXDxJjzLaGqiMJ4coCDyIsZV+TF/KwSsx6fgoQhRRa CWIp4RwOFZfzmfcNlUgoN6SEe+D3ylfcmcFPiR1PEPDWUb9s4k5wv9NT X-Gm-Gg: AeBDiespc6ZDEDx5TOJKFY8j/Aweuc1J37O1Zdr5nMpTy3oS0z3HTNyzeTC3jOeecy3 IYuil4kbao1GT12gxNNp6G0kgwzVEwtFAd5UkImbC+wEbt/HshxqqrUmgObas6Ii58yhpAWr8Yc 5XrHK+B7DSyP0WpHkjU9BfgGjNN7heXW/v810WZgmn1v6s29VLARR3e/prmt1k4GJSTpo1EK7L7 5yFXVQGAot+ApOBL9xNKGMPdXEapUXixFucLDrSBG0jm7B6DiE3dTcDQk5RBXac62ihyewDU6Y1 UBVAQSqG1rVttVIhyRq1V0wqCBCmHBgF4zNF7wF1iqCQMDBBvKf7SU/Om1DpIB6N6XJ20Z+ZCZg If24VgpL6vJYCY/D/4lUz3J4QneMwTwq0t61F5w4yrs4Cq75iIVDUVRzzagzmIjCeTOW6eKBUVD LQdUrI1iShxoVes9oj5Y/wVhEAmzZbsqALZK1xL3/lBVtq0Sduf+aa66mGI7MoIXMdlZoLmCbtt CtjAOegZcMGqGA= X-Received: by 2002:a05:6102:83cb:b0:5ff:bd9d:b1f2 with SMTP id ada2fe7eead31-605a4d819d8mr3529193137.3.1775445615885; Sun, 05 Apr 2026 20:20:15 -0700 (PDT) Received: from [192.168.1.18] (177-4-161-167.user3p.v-tal.net.br. [177.4.161.167]) by smtp.gmail.com with ESMTPSA id ada2fe7eead31-605b214b45fsm9162146137.5.2026.04.05.20.20.14 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 05 Apr 2026 20:20:15 -0700 (PDT) From: =?utf-8?q?C=C3=A1ssio_Gabriel?= Date: Mon, 06 Apr 2026 00:20:03 -0300 Subject: [PATCH 1/4] ALSA: gus: add shared GF1 suspend and resume helpers Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20260406-b4-alsa-gus-isa-pm-v1-1-b6829a7457cd@gmail.com> References: <20260406-b4-alsa-gus-isa-pm-v1-0-b6829a7457cd@gmail.com> In-Reply-To: <20260406-b4-alsa-gus-isa-pm-v1-0-b6829a7457cd@gmail.com> To: Takashi Iwai , Jaroslav Kysela Cc: linux-sound@vger.kernel.org, linux-kernel@vger.kernel.org, =?utf-8?q?C=C3=A1ssio_Gabriel?= X-Mailer: b4 0.15.1 X-Developer-Signature: v=1; a=openpgp-sha256; l=12535; i=cassiogabrielcontato@gmail.com; h=from:subject:message-id; bh=ZJsXuAOnzKe7VNcjOOvgpbIj4nvUPV0wpNzyd65c2Xo=; b=owGbwMvMwCV2IdZeKur/u2bG02pJDJmX1bLflm1ckLBOzeFZpetjheOpv9rWXPnxNFf0nAjb3 QMbgg3md5SyMIhxMciKKbKsTlpkuafrwdX6uBUeMHNYmUCGMHBxCsBEdngxMmx77isQevD+Zck7 a1YLLDjulfUm6pPQpEPRE9d7lP601pnCyLBZ3dc1+OWmKVNPy7bu32v+2OB5WEhvV01i/WGVT1m T7vACAA== X-Developer-Key: i=cassiogabrielcontato@gmail.com; a=openpgp; fpr=AB62A239BC8AE0D57F5EA848D05D3F1A5AFFEE83 gusclassic and gusextreme still leave their ISA PM callbacks disabled because the shared GF1 core only provides probe-time startup and full shutdown paths. Those helpers are not suitable for suspend and resume. They reset software handlers and tear down runtime state such as the DRAM allocator, timer state, DMA queues, PCM state and UART setup. Resume instead needs a narrower recovery path that rebuilds the GF1 hardware state without rerunning probe-only detection or discarding the bookkeeping kept by the card instance. Add shared GF1 suspend and resume helpers for that recovery path. Suspend now quiesces GF1 PCM, aborts queued GF1 DMA work, resets the UART and powers the chip down without tearing down allocator, timer or rawmidi bookkeeping. Resume rebuilds the GF1 hardware state, restores timer and UART handlers, and brings the chip back to a usable post-resume state for the ISA front-ends. The scope is limited to restoring post-resume usability. It does not attempt transparent continuation of active GF1 PCM or synth state across suspend, and userspace may still need to reprepare streams or reload onboard sample data after resume. Open rawmidi substreams are restored only to a usable post-resume state. Signed-off-by: C=C3=A1ssio Gabriel --- include/sound/gus.h | 8 ++++++ sound/isa/gus/gus_dma.c | 33 +++++++++++++++++++++++++ sound/isa/gus/gus_main.c | 36 +++++++++++++++++++++++++++ sound/isa/gus/gus_pcm.c | 7 +++--- sound/isa/gus/gus_reset.c | 62 +++++++++++++++++++++++++++++++++++++++----= ---- sound/isa/gus/gus_timer.c | 14 +++++++++++ sound/isa/gus/gus_uart.c | 47 +++++++++++++++++++++++++++++++++++ 7 files changed, 194 insertions(+), 13 deletions(-) diff --git a/include/sound/gus.h b/include/sound/gus.h index 321ae93625eb..3feb42627de1 100644 --- a/include/sound/gus.h +++ b/include/sound/gus.h @@ -536,6 +536,7 @@ int snd_gf1_dma_transfer_block(struct snd_gus_card * gu= s, struct snd_gf1_dma_block * block, int atomic, int synth); +void snd_gf1_dma_suspend(struct snd_gus_card *gus); =20 /* gus_volume.c */ =20 @@ -552,6 +553,8 @@ struct snd_gus_voice *snd_gf1_alloc_voice(struct snd_gu= s_card * gus, int type, i void snd_gf1_free_voice(struct snd_gus_card * gus, struct snd_gus_voice *v= oice); int snd_gf1_start(struct snd_gus_card * gus); int snd_gf1_stop(struct snd_gus_card * gus); +int snd_gf1_suspend(struct snd_gus_card *gus); +int snd_gf1_resume(struct snd_gus_card *gus); =20 /* gus_mixer.c */ =20 @@ -572,6 +575,8 @@ int snd_gus_create(struct snd_card *card, int effect, struct snd_gus_card ** rgus); int snd_gus_initialize(struct snd_gus_card * gus); +int snd_gus_suspend(struct snd_gus_card *gus); +int snd_gus_resume(struct snd_gus_card *gus); =20 /* gus_irq.c */ =20 @@ -583,6 +588,8 @@ void snd_gus_irq_profile_init(struct snd_gus_card *gus); /* gus_uart.c */ =20 int snd_gf1_rawmidi_new(struct snd_gus_card *gus, int device); +void snd_gf1_uart_suspend(struct snd_gus_card *gus); +void snd_gf1_uart_resume(struct snd_gus_card *gus); =20 /* gus_dram.c */ int snd_gus_dram_write(struct snd_gus_card *gus, char __user *ptr, @@ -593,5 +600,6 @@ int snd_gus_dram_read(struct snd_gus_card *gus, char __= user *ptr, /* gus_timer.c */ void snd_gf1_timers_init(struct snd_gus_card *gus); void snd_gf1_timers_done(struct snd_gus_card *gus); +void snd_gf1_timers_resume(struct snd_gus_card *gus); =20 #endif /* __SOUND_GUS_H */ diff --git a/sound/isa/gus/gus_dma.c b/sound/isa/gus/gus_dma.c index ffc69e26227e..30bd76eee96e 100644 --- a/sound/isa/gus/gus_dma.c +++ b/sound/isa/gus/gus_dma.c @@ -173,6 +173,39 @@ int snd_gf1_dma_done(struct snd_gus_card * gus) return 0; } =20 +void snd_gf1_dma_suspend(struct snd_gus_card *gus) +{ + struct snd_gf1_dma_block *block; + + guard(mutex)(&gus->dma_mutex); + if (!gus->gf1.dma_shared) + return; + + snd_dma_disable(gus->gf1.dma1); + snd_gf1_dma_ack(gus); + if (gus->gf1.dma_ack) + gus->gf1.dma_ack(gus, gus->gf1.dma_private_data); + gus->gf1.dma_ack =3D NULL; + gus->gf1.dma_private_data =3D NULL; + + while ((block =3D gus->gf1.dma_data_pcm)) { + gus->gf1.dma_data_pcm =3D block->next; + if (block->ack) + block->ack(gus, block->private_data); + kfree(block); + } + while ((block =3D gus->gf1.dma_data_synth)) { + gus->gf1.dma_data_synth =3D block->next; + if (block->ack) + block->ack(gus, block->private_data); + kfree(block); + } + + gus->gf1.dma_data_pcm_last =3D NULL; + gus->gf1.dma_data_synth_last =3D NULL; + gus->gf1.dma_flags &=3D ~SNDRV_GF1_DMA_TRIGGER; +} + int snd_gf1_dma_transfer_block(struct snd_gus_card * gus, struct snd_gf1_dma_block * __block, int atomic, diff --git a/sound/isa/gus/gus_main.c b/sound/isa/gus/gus_main.c index b2b189c83569..6adf8b698e2b 100644 --- a/sound/isa/gus/gus_main.c +++ b/sound/isa/gus/gus_main.c @@ -404,6 +404,42 @@ int snd_gus_initialize(struct snd_gus_card *gus) return 0; } =20 +int snd_gus_suspend(struct snd_gus_card *gus) +{ + int err; + + if (gus->pcm) { + err =3D snd_pcm_suspend_all(gus->pcm); + if (err < 0) + return err; + } + + err =3D snd_gf1_suspend(gus); + if (err < 0) + return err; + + snd_power_change_state(gus->card, SNDRV_CTL_POWER_D3hot); + return 0; +} +EXPORT_SYMBOL(snd_gus_suspend); + +int snd_gus_resume(struct snd_gus_card *gus) +{ + int err; + + err =3D snd_gus_init_dma_irq(gus, 1); + if (err < 0) + return err; + + err =3D snd_gf1_resume(gus); + if (err < 0) + return err; + + snd_power_change_state(gus->card, SNDRV_CTL_POWER_D0); + return 0; +} +EXPORT_SYMBOL(snd_gus_resume); + /* gus_io.c */ EXPORT_SYMBOL(snd_gf1_delay); EXPORT_SYMBOL(snd_gf1_write8); diff --git a/sound/isa/gus/gus_pcm.c b/sound/isa/gus/gus_pcm.c index caf371897b78..a0757e1ede46 100644 --- a/sound/isa/gus/gus_pcm.c +++ b/sound/isa/gus/gus_pcm.c @@ -471,7 +471,8 @@ static int snd_gf1_pcm_playback_trigger(struct snd_pcm_= substream *substream, =20 if (cmd =3D=3D SNDRV_PCM_TRIGGER_START) { snd_gf1_pcm_trigger_up(substream); - } else if (cmd =3D=3D SNDRV_PCM_TRIGGER_STOP) { + } else if (cmd =3D=3D SNDRV_PCM_TRIGGER_STOP || + cmd =3D=3D SNDRV_PCM_TRIGGER_SUSPEND) { scoped_guard(spinlock, &pcmp->lock) { pcmp->flags &=3D ~SNDRV_GF1_PCM_PFLG_ACTIVE; } @@ -558,7 +559,8 @@ static int snd_gf1_pcm_capture_trigger(struct snd_pcm_s= ubstream *substream, =09 if (cmd =3D=3D SNDRV_PCM_TRIGGER_START) { val =3D gus->gf1.pcm_rcntrl_reg; - } else if (cmd =3D=3D SNDRV_PCM_TRIGGER_STOP) { + } else if (cmd =3D=3D SNDRV_PCM_TRIGGER_STOP || + cmd =3D=3D SNDRV_PCM_TRIGGER_SUSPEND) { val =3D 0; } else { return -EINVAL; @@ -856,4 +858,3 @@ int snd_gf1_pcm_new(struct snd_gus_card *gus, int pcm_d= ev, int control_index) =20 return 0; } - diff --git a/sound/isa/gus/gus_reset.c b/sound/isa/gus/gus_reset.c index a7a3e764bb77..998fa245708c 100644 --- a/sound/isa/gus/gus_reset.c +++ b/sound/isa/gus/gus_reset.c @@ -6,6 +6,7 @@ #include #include #include +#include #include #include =20 @@ -263,11 +264,18 @@ void snd_gf1_free_voice(struct snd_gus_card * gus, st= ruct snd_gus_voice *voice) private_free(voice); } =20 -/* - * call this function only by start of driver - */ +static void snd_gf1_init_software_state(struct snd_gus_card *gus) +{ + unsigned int i; =20 -int snd_gf1_start(struct snd_gus_card * gus) + snd_gf1_set_default_handlers(gus, SNDRV_GF1_HANDLER_ALL); + for (i =3D 0; i < 32; i++) { + gus->gf1.voices[i].number =3D i; + snd_gf1_set_default_handlers(gus, SNDRV_GF1_HANDLER_VOICE | i); + } +} + +static void snd_gf1_hw_start(struct snd_gus_card *gus, bool initial) { unsigned int i; =20 @@ -277,14 +285,14 @@ int snd_gf1_start(struct snd_gus_card * gus) udelay(160); snd_gf1_i_write8(gus, SNDRV_GF1_GB_JOYSTICK_DAC_LEVEL, gus->joystick_dac); =20 - snd_gf1_set_default_handlers(gus, SNDRV_GF1_HANDLER_ALL); - for (i =3D 0; i < 32; i++) { - gus->gf1.voices[i].number =3D i; - snd_gf1_set_default_handlers(gus, SNDRV_GF1_HANDLER_VOICE | i); + if (initial) { + snd_gf1_init_software_state(gus); + snd_gf1_uart_cmd(gus, 0x03); + } else { + guard(spinlock_irqsave)(&gus->uart_cmd_lock); + outb(0x03, GUSP(gus, MIDICTRL)); } =20 - snd_gf1_uart_cmd(gus, 0x03); /* huh.. this cleanup took me some time... */ - if (gus->gf1.enh_mode) { /* enhanced mode !!!! */ snd_gf1_i_write8(gus, SNDRV_GF1_GB_GLOBAL_MODE, snd_gf1_i_look8(gus, SND= RV_GF1_GB_GLOBAL_MODE) | 0x01); snd_gf1_i_write8(gus, SNDRV_GF1_GB_MEMORY_CONTROL, 0x01); @@ -293,6 +301,8 @@ int snd_gf1_start(struct snd_gus_card * gus) snd_gf1_select_active_voices(gus); snd_gf1_delay(gus); gus->gf1.default_voice_address =3D gus->gf1.memory > 0 ? 0 : 512 - 8; + gus->gf1.hw_lfo =3D 0; + gus->gf1.sw_lfo =3D 0; /* initialize LFOs & clear LFOs memory */ if (gus->gf1.enh_mode && gus->gf1.memory) { gus->gf1.hw_lfo =3D 1; @@ -321,7 +331,15 @@ int snd_gf1_start(struct snd_gus_card * gus) outb(gus->gf1.active_voice =3D 0, GUSP(gus, GF1PAGE)); outb(gus->mix_cntrl_reg, GUSP(gus, MIXCNTRLREG)); } +} =20 +int snd_gf1_start(struct snd_gus_card *gus) +{ + /* + * Probe-time startup initializes both GF1 hardware and the + * software state that suspend/resume keeps across PM cycles. + */ + snd_gf1_hw_start(gus, true); snd_gf1_timers_init(gus); snd_gf1_look_regs(gus); snd_gf1_mem_init(gus); @@ -357,3 +375,27 @@ int snd_gf1_stop(struct snd_gus_card * gus) =20 return 0; } + +int snd_gf1_suspend(struct snd_gus_card *gus) +{ + snd_gf1_dma_suspend(gus); + snd_gf1_uart_suspend(gus); + + snd_gf1_i_write8(gus, SNDRV_GF1_GB_SOUND_BLASTER_CONTROL, 0); + snd_gf1_i_write8(gus, SNDRV_GF1_GB_REC_DMA_CONTROL, 0); + snd_gf1_i_look8(gus, SNDRV_GF1_GB_REC_DMA_CONTROL); + snd_gf1_stop_voices(gus, 0, 31); + snd_gf1_i_write8(gus, SNDRV_GF1_GB_RESET, 1); + snd_dma_disable(gus->gf1.dma2); + + return 0; +} + +int snd_gf1_resume(struct snd_gus_card *gus) +{ + snd_gf1_hw_start(gus, false); + snd_gf1_timers_resume(gus); + snd_gf1_uart_resume(gus); + + return 0; +} diff --git a/sound/isa/gus/gus_timer.c b/sound/isa/gus/gus_timer.c index e3a8847e02cf..14dcde138bc7 100644 --- a/sound/isa/gus/gus_timer.c +++ b/sound/isa/gus/gus_timer.c @@ -178,3 +178,17 @@ void snd_gf1_timers_done(struct snd_gus_card * gus) gus->gf1.timer2 =3D NULL; } } + +void snd_gf1_timers_resume(struct snd_gus_card *gus) +{ + if (gus->gf1.timer1) { + gus->gf1.interrupt_handler_timer1 =3D snd_gf1_interrupt_timer1; + if (gus->gf1.timer_enabled & 4) + snd_gf1_timer1_start(gus->gf1.timer1); + } + if (gus->gf1.timer2) { + gus->gf1.interrupt_handler_timer2 =3D snd_gf1_interrupt_timer2; + if (gus->gf1.timer_enabled & 8) + snd_gf1_timer2_start(gus->gf1.timer2); + } +} diff --git a/sound/isa/gus/gus_uart.c b/sound/isa/gus/gus_uart.c index 770d8f3e4cff..25057a5a81b0 100644 --- a/sound/isa/gus/gus_uart.c +++ b/sound/isa/gus/gus_uart.c @@ -232,3 +232,50 @@ int snd_gf1_rawmidi_new(struct snd_gus_card *gus, int = device) gus->midi_uart =3D rmidi; return err; } + +void snd_gf1_uart_suspend(struct snd_gus_card *gus) +{ + guard(spinlock_irqsave)(&gus->uart_cmd_lock); + outb(0x03, GUSP(gus, MIDICTRL)); +} + +void snd_gf1_uart_resume(struct snd_gus_card *gus) +{ + unsigned short uart_cmd; + bool active; + int i; + + scoped_guard(spinlock_irqsave, &gus->uart_cmd_lock) { + active =3D gus->midi_substream_input || gus->midi_substream_output; + } + if (!active) + return; + + /* snd_gf1_hw_start() already left MIDICTRL in reset. */ + usleep_range(160, 200); + + guard(spinlock_irqsave)(&gus->uart_cmd_lock); + if (!gus->midi_substream_input && !gus->midi_substream_output) + return; + + if (gus->midi_substream_output) + gus->gf1.interrupt_handler_midi_out =3D snd_gf1_interrupt_midi_out; + if (gus->midi_substream_input) + gus->gf1.interrupt_handler_midi_in =3D snd_gf1_interrupt_midi_in; + + if (!gus->uart_enable) + return; + + uart_cmd =3D gus->gf1.uart_cmd; + snd_gf1_uart_cmd(gus, 0x00); + + if (gus->midi_substream_input) { + for (i =3D 0; i < 1000 && (snd_gf1_uart_stat(gus) & 0x01); i++) + snd_gf1_uart_get(gus); + if (i >=3D 1000) + dev_err(gus->card->dev, + "gus midi uart resume - cleanup error\n"); + } + + snd_gf1_uart_cmd(gus, uart_cmd); +} --=20 2.53.0 From nobody Sat Apr 11 13:38:35 2026 Received: from mail-vk1-f179.google.com (mail-vk1-f179.google.com [209.85.221.179]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 2B1CE33DEFC for ; Mon, 6 Apr 2026 03:20:19 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.221.179 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1775445620; cv=none; b=oHBGU8JYqi2rgDRFfury0Znm4zq8Vwn2N2geH9EXeDy2C8W8jmxbm57mPuX9Dn6mdDKFhlcVcZqdHHfnw3DqDXjAZ90WcNObwrQVQe64pyfbkwKn2l1MRJ8dRlZCxHILRknGOZeDwElm+Of+Yd4+vID5ZkAdF462PcwZoFS/BW0= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1775445620; c=relaxed/simple; bh=nPo/kjyyZRkBlCq8myr47QLdwjb5HP5ssuD5hqCZ2yk=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=Cql6Zk5WdU3g7pr6ijkn/sZQq53mpKK+AmFXfDxrbl+SLpPmM0AvjXTac6P0yaF3fZ13AZCzSWknTli4taZ+8cWvQELfErAiAszrPdc7gDNyYk8KlX87C2ffz+O6ULepri5IPOKUtYm0AHDk/z+YM++H5waI2LcV43kgne0hFnU= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=SemLeNPi; arc=none smtp.client-ip=209.85.221.179 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="SemLeNPi" Received: by mail-vk1-f179.google.com with SMTP id 71dfb90a1353d-56a857578a8so1311173e0c.3 for ; Sun, 05 Apr 2026 20:20:18 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20251104; t=1775445618; x=1776050418; darn=vger.kernel.org; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:from:to:cc:subject:date:message-id :reply-to; bh=at+4HFvLiy7DCVXrWuZymI/850oW2s4mdcUHo/q9/rk=; b=SemLeNPiIJFyTMJI222BQmokUxgyXDUVKS0xuKVOEbaePNhOHqu5yUcevRDs8AzKRG XIj6ayg2YBZawFeYn1iCSggv5uc3k12kpJBI7X/OVDTAVdGlU7RT9u9HJq2L2s4F5d+M NYDlbebKuBjqQb6T7FY5mk+Gs/AzhdI57jmME3/72U8E5ZBBY8tVrmHLsqzz7oK+4tGy Hplx+rN7r67KpBCu0/TkEucPPMgZAJO/WKlvgKGhBDJiJFfaB6ohBxmtRyBnbjUiozcT KBg2jJM7BqWgHtZsZdvB0EbCWsBxAAkxJXpjHeP/S/qb4/6gbV/LwLWgAVA8jNttGy5x 3uxQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1775445618; x=1776050418; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-gg:x-gm-message-state:from:to :cc:subject:date:message-id:reply-to; bh=at+4HFvLiy7DCVXrWuZymI/850oW2s4mdcUHo/q9/rk=; b=XC6uxH0wJFpBr9F4kX6S4dTnraheBGVADMGie6RbpEqhrOn7UcMTJ/B9f9L/IjKbf4 IQmO83MF0/PTUoscbdy/hFsJUPs2Yh6GHC3JtsZZJRlRq16u9pxc1PHcy0T8Y4RHOLPa UGDTGrPwiWWGuBrqAt2jiJOV0zB0pyuevVjFTZuRk1G/f1W5OFSFPm7Mm0lgKLfD4YBf SCYGgydGT+sDEftQgN/5PEHGfBY7llOqYT+oKcPjErUN1AZLajlFqutidRNdZpMaq+xC biWKHFzgeAPgcPCmFop0gK5kmuTc1kM3l+Vq7hqcMIYEqkvSh3G4MCAhK9WsKqlFE8FM g1kg== X-Forwarded-Encrypted: i=1; AJvYcCWjmscV6oFuH2QWOJJ8Wv77SReNilHpSKx0Xl/MzyA8FDmZjKO/Pl2hy82jVmSYxah7rj/VysKdORAHeOQ=@vger.kernel.org X-Gm-Message-State: AOJu0YzhsId+WiL072XKDObuFXVF8eaPXiWd7qibxQw8sOjn51/Q6c3o GzPsFhibLsHJGIeJyKipgiCfs6KYCmb2zwBTC74q6m8+yJ7up5ON+RXHNIShPQ== X-Gm-Gg: AeBDiet4/ozX1ytuaTrN3tCv3lFO+gZQaZlgOgG+H4DTWrN6hYY10NaQcNxxhApNxx6 ebn98HZwYpMgjLmIvdzNNi/ODI4wGG2dkLMHeo59PQOUuCZcMu65h79ShsDZgfCH9iTryFGj2rY ZeQj93VQXsyg8ROa9kyB1qPilFcnG3tDLuPuw50UQRnhRM/cgAGBXEXwOVUAzN5I1yPCecnitzt i14belIlB7bWA9gWe0UJoUUS/pvd0CPT8kyfjMa5wIb03B0cmxga9lZjSKdQad/aTb1LRnrNv9E o74zHZfsiEP3y05eSZMm5myTl4HHZCcCkXWPvWDUQlKpizt90BUnAXAnmHidMQavMu+MuQrzNy3 pa8Ca8aF5LlGwC4gRGiGLUkFbWTdJMAgWwRJdtpvfpEwFHJA6bOJm37Z0TS27xug9RmieuPqW8h 80XrVffmcmia0Qkf2QjBuNKJ39h0MzhTtOzBUpzOZZmVGY9aDwCA8ZSCQe/pQh+jAo/9wI5V+fw Cda X-Received: by 2002:a05:6102:5e81:b0:604:dc41:b142 with SMTP id ada2fe7eead31-605a4cd8a92mr3550769137.2.1775445618006; Sun, 05 Apr 2026 20:20:18 -0700 (PDT) Received: from [192.168.1.18] (177-4-161-167.user3p.v-tal.net.br. [177.4.161.167]) by smtp.gmail.com with ESMTPSA id ada2fe7eead31-605b214b45fsm9162146137.5.2026.04.05.20.20.16 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 05 Apr 2026 20:20:17 -0700 (PDT) From: =?utf-8?q?C=C3=A1ssio_Gabriel?= Date: Mon, 06 Apr 2026 00:20:04 -0300 Subject: [PATCH 2/4] ALSA: gusclassic: add ISA suspend and resume callbacks Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20260406-b4-alsa-gus-isa-pm-v1-2-b6829a7457cd@gmail.com> References: <20260406-b4-alsa-gus-isa-pm-v1-0-b6829a7457cd@gmail.com> In-Reply-To: <20260406-b4-alsa-gus-isa-pm-v1-0-b6829a7457cd@gmail.com> To: Takashi Iwai , Jaroslav Kysela Cc: linux-sound@vger.kernel.org, linux-kernel@vger.kernel.org, =?utf-8?q?C=C3=A1ssio_Gabriel?= X-Mailer: b4 0.15.1 X-Developer-Signature: v=1; a=openpgp-sha256; l=1831; i=cassiogabrielcontato@gmail.com; h=from:subject:message-id; bh=nPo/kjyyZRkBlCq8myr47QLdwjb5HP5ssuD5hqCZ2yk=; b=owGbwMvMwCV2IdZeKur/u2bG02pJDJmX1bJPLpfi+Xmk5l5EfZXeJOnGGNMHnqktb59e3aGTs CFR9I1GRykLgxgXg6yYIsvqpEWWe7oeXK2PW+EBM4eVCWQIAxenAExkTQEjw7IO40/lxfky6qzK wnrZlVa769i1lsn2mr16rt7feCrtGyPDgaONrFyzquybJ19Xskvcah+S+EzhocTWs1YW7I2aH9Q 4AA== X-Developer-Key: i=cassiogabrielcontato@gmail.com; a=openpgp; fpr=AB62A239BC8AE0D57F5EA848D05D3F1A5AFFEE83 gusclassic still leaves its ISA PM callbacks disabled because the shared GF1 core had no suspend and resume path suitable for PM recovery. Wire the driver up to the new shared GUS suspend and resume helpers so a suspend/resume cycle restores usable GF1 operation without rerunning probe-only detection or tearing down the runtime bookkeeping kept by the card instance. Signed-off-by: C=C3=A1ssio Gabriel --- sound/isa/gus/gusclassic.c | 21 ++++++++++++++++++++- 1 file changed, 20 insertions(+), 1 deletion(-) diff --git a/sound/isa/gus/gusclassic.c b/sound/isa/gus/gusclassic.c index 101202acefb3..363c819ced89 100644 --- a/sound/isa/gus/gusclassic.c +++ b/sound/isa/gus/gusclassic.c @@ -145,6 +145,7 @@ static int snd_gusclassic_probe(struct device *dev, uns= igned int n) error =3D snd_gusclassic_create(card, dev, n, &gus); if (error < 0) return error; + card->private_data =3D gus; =20 error =3D snd_gusclassic_detect(gus); if (error < 0) @@ -193,11 +194,29 @@ static int snd_gusclassic_probe(struct device *dev, u= nsigned int n) return 0; } =20 +#ifdef CONFIG_PM +static int snd_gusclassic_suspend(struct device *dev, unsigned int n, + pm_message_t state) +{ + struct snd_card *card =3D dev_get_drvdata(dev); + + return snd_gus_suspend(card->private_data); +} + +static int snd_gusclassic_resume(struct device *dev, unsigned int n) +{ + struct snd_card *card =3D dev_get_drvdata(dev); + + return snd_gus_resume(card->private_data); +} +#endif + static struct isa_driver snd_gusclassic_driver =3D { .match =3D snd_gusclassic_match, .probe =3D snd_gusclassic_probe, -#if 0 /* FIXME */ +#ifdef CONFIG_PM .suspend =3D snd_gusclassic_suspend, + .resume =3D snd_gusclassic_resume, #endif .driver =3D { .name =3D DEV_NAME --=20 2.53.0 From nobody Sat Apr 11 13:38:35 2026 Received: from mail-vs1-f53.google.com (mail-vs1-f53.google.com [209.85.217.53]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 53C6E34E762 for ; Mon, 6 Apr 2026 03:20:21 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.217.53 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1775445622; cv=none; b=pYh7UremdNt8plvTlqvDJ09Dm5CBFjsdtkXrrhlTaf1s28mJy5eDDqY4kxN7R4MTZKXZei56n23ujLcVHq0wijG9Td/yDaQe4vd2LaOWccckCN/U1oZfM5B6dsMvWfLfZYIGToaCBb03TT4DSBZFvA39CkFMOhFjEljr9Huus80= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1775445622; c=relaxed/simple; bh=RguDGz8h/rrrWD2cTbBLxH+mDSZzcOeQwZ54p3UGGQg=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=merEkJ9OeZxO7mUGdKLAp9G7FXYrdbm9Pzv1DvyllO3BF80ILa+theJmobWGDveqO26X60avMQToVGbmz+ReV0ou3v933PQUEFTZug17V5nOE3h4rrD6R5NzPbwSY2dwDwpfFRm7o491WTFqOXy9sL40MxUmzC5J0WBghHeZRJA= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=HdUTEm71; arc=none smtp.client-ip=209.85.217.53 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="HdUTEm71" Received: by mail-vs1-f53.google.com with SMTP id ada2fe7eead31-604f327bafcso1263561137.0 for ; Sun, 05 Apr 2026 20:20:21 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20251104; t=1775445620; x=1776050420; darn=vger.kernel.org; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:from:to:cc:subject:date:message-id :reply-to; bh=aaXOUdfTDOzAAAnykF1sMhRPk4OSoZf3KJ6n7qQxtHs=; b=HdUTEm71euvRfYS4+qYSwhzoDrhiEiFK0Swr8Dpf0tkXjn7ZJIo0IFGrofZyykbh2u tAZfwuTeNB2RFLhHAe1PGgqhuQZb6Vat6O4ymHRnQQJagtX8Zbx+Ix5dyS60cpSnPoNZ xAH7ZDkHlHM2QuE5IvsDzXZPng/vrg/LBkhOHCmPM59pEfFoqdiJ6KHA7bmNECv8arhO 05QW1Pl8IYFekxIa2tVRWJDHgkaTG0G8ATP30bU35dH3ynZ2AJkKU9AtoKV25w4/Kxww jFeoH4+kWxY26VNa6IioKpf1Be6sQfO/lILlTfEPGsXEk2ufyCklNanl9dWnAg3xWjES hEaQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1775445620; x=1776050420; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-gg:x-gm-message-state:from:to :cc:subject:date:message-id:reply-to; bh=aaXOUdfTDOzAAAnykF1sMhRPk4OSoZf3KJ6n7qQxtHs=; b=JKb09LqaQ8S5eWvdbux20ja4FzIo42WSIeOUd1F7DeyOb7yMCjqUxDhOg6yus/ISvD 90s6I0NaCpOtvgJEReTQGP42TeT6X7Ij/dDLBC/pEL4cWp+0wGQ8tRf3ZAF9iOroDdEy o22TVBYiZpvfmO7UwyUgQxC4H0BVXA2WP6iux2u8+Its5tJgJQvOAvjTSEXCrtx/DzJL j/lNlS1V8SiBVgrnSa2y5hiXApnp+HAVcDYqg5rRPxy5hRmva4SxRPzl6HxUMIbBuMBI L2g+zUDLiWBFLlrVE8IxYb9+r7IwuNyoZuCwZQnHVd4MmwiG9GstkYajlkCtSrF+aVXh vZ9Q== X-Forwarded-Encrypted: i=1; AJvYcCUUcPCdTIzsE6hlaTCYFawiBo9NIE+veTROrLpVG/nZ9DmJmuKOIJDFuI4CbtbEoK9H61/iXBFOkLX310I=@vger.kernel.org X-Gm-Message-State: AOJu0Yyn9dZ9BH20ByRFLiXbFPOitcOR/SHAkOBLkAt7ihgghocmrZk/ QxU19WqLEaaRrx8Rx7Zk1Eq+oHAUo/eHc6g4SKmlxv5g5wOlS+bPtCJH X-Gm-Gg: AeBDievLqBstVs9A7zs0t8VEgmWq4TcCaVfqWRhFPAK4/TzuvnnL/cfn7AkaeGY0Z2c rQDht+Mzv2q+WHEcxSg/XYSYrslBRa4c3lbGCGCMltjeMe2gKpo0Bf2PmVeFljpn/XEPSADJHVn gJ2wGl2i+wVZy736CkkVN7zke325b9r66N6q/8dmSbNefIK6VgJBeByxfcZt6vsQn2djN4AM7oy JBdgylYB+VAtM6X3bSj1uGQxvDmup8IddRaJnIZu6p0KOc7a9z+LtX1PNGT9ORhlBkKP/QQx6X1 TUVk5x7VWVzCAMQBKt2/SHZOXgqwjKYC/7GE2Lsz8qEhioe+9BsTMOOre33r+C5TPZZGj0K26Dr jJnK43gZ6AuxvtkaUwtsnWc5wGUgsK1Mn8c2wbX+uwB7q+iLbnCkR5v14QmM7owPTq2iWRWRhpJ GNDDLIhqpd532b1FFEeuM8XK860NFTFC7nGAOTlIEgOi6z85/bshiHcmef2dUPQBH4fBpcBK6qX sUi X-Received: by 2002:a05:6102:f89:b0:602:a9f3:74d7 with SMTP id ada2fe7eead31-605a4dbe20cmr3734393137.13.1775445620148; Sun, 05 Apr 2026 20:20:20 -0700 (PDT) Received: from [192.168.1.18] (177-4-161-167.user3p.v-tal.net.br. [177.4.161.167]) by smtp.gmail.com with ESMTPSA id ada2fe7eead31-605b214b45fsm9162146137.5.2026.04.05.20.20.18 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 05 Apr 2026 20:20:19 -0700 (PDT) From: =?utf-8?q?C=C3=A1ssio_Gabriel?= Date: Mon, 06 Apr 2026 00:20:05 -0300 Subject: [PATCH 3/4] ALSA: gusextreme: add ISA suspend and resume callbacks Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20260406-b4-alsa-gus-isa-pm-v1-3-b6829a7457cd@gmail.com> References: <20260406-b4-alsa-gus-isa-pm-v1-0-b6829a7457cd@gmail.com> In-Reply-To: <20260406-b4-alsa-gus-isa-pm-v1-0-b6829a7457cd@gmail.com> To: Takashi Iwai , Jaroslav Kysela Cc: linux-sound@vger.kernel.org, linux-kernel@vger.kernel.org, =?utf-8?q?C=C3=A1ssio_Gabriel?= X-Mailer: b4 0.15.1 X-Developer-Signature: v=1; a=openpgp-sha256; l=4588; i=cassiogabrielcontato@gmail.com; h=from:subject:message-id; bh=RguDGz8h/rrrWD2cTbBLxH+mDSZzcOeQwZ54p3UGGQg=; b=owGbwMvMwCV2IdZeKur/u2bG02pJDJmX1bKXPfsoe9Rq2+HN/7lqXXTDtv/N6pEVv3exqe/yz v+MywwedJSyMIhxMciKKbKsTlpkuafrwdX6uBUeMHNYmUCGMHBxCsBEhDIYGfZucXzkm3tBRH2W +p9DwnpXK6al2mgIGG4V6HD+3hcZoMjIMJutsSTWTtV6eXiH5YFE5bU5ExY/9M4tjHHbfG/BwjU XWAE= X-Developer-Key: i=cassiogabrielcontato@gmail.com; a=openpgp; fpr=AB62A239BC8AE0D57F5EA848D05D3F1A5AFFEE83 gusextreme still leaves its ISA PM callbacks disabled because the shared GF1 core had no suspend and resume path suitable for PM recovery. Resume on this board needs one extra step before the shared GF1 path can touch the chip again: the ES1688 side must restore the GF1 routing. Split that routing sequence into a helper, reuse it for probe and resume, reset the ES1688 side first on resume, and then wire the driver up to the shared GUS PM helpers. This restores usable post-resume GF1 operation on GUS Extreme without rerunning probe-only detection in the shared GF1 path. Signed-off-by: C=C3=A1ssio Gabriel --- sound/isa/gus/gusextreme.c | 57 ++++++++++++++++++++++++++++++++++++++----= ---- 1 file changed, 48 insertions(+), 9 deletions(-) diff --git a/sound/isa/gus/gusextreme.c b/sound/isa/gus/gusextreme.c index ed921b89b00a..0984731740c4 100644 --- a/sound/isa/gus/gusextreme.c +++ b/sound/isa/gus/gusextreme.c @@ -44,6 +44,11 @@ static int joystick_dac[SNDRV_CARDS] =3D {[0 ... (SNDRV_= CARDS - 1)] =3D 29}; static int channels[SNDRV_CARDS] =3D {[0 ... (SNDRV_CARDS - 1)] =3D 24}; static int pcm_channels[SNDRV_CARDS] =3D {[0 ... (SNDRV_CARDS - 1)] =3D 2}; =20 +struct snd_gusextreme { + struct snd_es1688 es1688; + struct snd_gus_card *gus; +}; + module_param_array(index, int, NULL, 0444); MODULE_PARM_DESC(index, "Index value for " CRD_NAME " soundcard."); module_param_array(id, charp, NULL, 0444); @@ -142,17 +147,15 @@ static int snd_gusextreme_gus_card_create(struct snd_= card *card, 0, channels[n], pcm_channels[n], 0, rgus); } =20 -static int snd_gusextreme_detect(struct snd_gus_card *gus, - struct snd_es1688 *es1688) +static void snd_gusextreme_enable_gf1(struct snd_gus_card *gus, + struct snd_es1688 *es1688) { - unsigned char d; - /* * This is main stuff - enable access to GF1 chip... * I'm not sure, if this will work for card which have * ES1688 chip in another place than 0x220. - * - * I used reverse-engineering in DOSEMU. [--jk] + * + * I used reverse-engineering in DOSEMU. [--jk] * * ULTRINIT.EXE: * 0x230 =3D 0,2,3 @@ -172,7 +175,14 @@ static int snd_gusextreme_detect(struct snd_gus_card *= gus, outb(0, 0x201); outb(gus->gf1.port & 0x010 ? 3 : 1, ES1688P(es1688, INIT1)); } +} + +static int snd_gusextreme_detect(struct snd_gus_card *gus, + struct snd_es1688 *es1688) +{ + unsigned char d; =20 + snd_gusextreme_enable_gf1(gus, es1688); udelay(100); =20 snd_gf1_i_write8(gus, SNDRV_GF1_GB_RESET, 0); /* reset GF1 */ @@ -223,16 +233,18 @@ static int snd_gusextreme_probe(struct device *dev, u= nsigned int n) { struct snd_card *card; struct snd_gus_card *gus; + struct snd_gusextreme *gusextreme; struct snd_es1688 *es1688; struct snd_opl3 *opl3; int error; =20 error =3D snd_devm_card_new(dev, index[n], id[n], THIS_MODULE, - sizeof(struct snd_es1688), &card); + sizeof(*gusextreme), &card); if (error < 0) return error; =20 - es1688 =3D card->private_data; + gusextreme =3D card->private_data; + es1688 =3D &gusextreme->es1688; =20 if (mpu_port[n] =3D=3D SNDRV_AUTO_PORT) mpu_port[n] =3D 0; @@ -250,6 +262,7 @@ static int snd_gusextreme_probe(struct device *dev, uns= igned int n) error =3D snd_gusextreme_gus_card_create(card, dev, n, &gus); if (error < 0) return error; + gusextreme->gus =3D gus; =20 error =3D snd_gusextreme_detect(gus, es1688); if (error < 0) @@ -321,10 +334,36 @@ static int snd_gusextreme_probe(struct device *dev, u= nsigned int n) return 0; } =20 +#ifdef CONFIG_PM +static int snd_gusextreme_suspend(struct device *dev, unsigned int n, + pm_message_t state) +{ + struct snd_card *card =3D dev_get_drvdata(dev); + struct snd_gusextreme *gusextreme =3D card->private_data; + + return snd_gus_suspend(gusextreme->gus); +} + +static int snd_gusextreme_resume(struct device *dev, unsigned int n) +{ + struct snd_card *card =3D dev_get_drvdata(dev); + struct snd_gusextreme *gusextreme =3D card->private_data; + int err; + + err =3D snd_es1688_reset(&gusextreme->es1688); + if (err < 0) + return err; + + snd_gusextreme_enable_gf1(gusextreme->gus, &gusextreme->es1688); + usleep_range(100, 200); + return snd_gus_resume(gusextreme->gus); +} +#endif + static struct isa_driver snd_gusextreme_driver =3D { .match =3D snd_gusextreme_match, .probe =3D snd_gusextreme_probe, -#if 0 /* FIXME */ +#ifdef CONFIG_PM .suspend =3D snd_gusextreme_suspend, .resume =3D snd_gusextreme_resume, #endif --=20 2.53.0 From nobody Sat Apr 11 13:38:35 2026 Received: from mail-vs1-f49.google.com (mail-vs1-f49.google.com [209.85.217.49]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 741CE356A08 for ; Mon, 6 Apr 2026 03:20:23 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.217.49 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1775445624; cv=none; b=u+/ZmJLvcC6WakU7fvCNUKqR91sWqLVs0HEoSRUmCTAlB2/YnhCiVBxtIIPuY9oVs48l2AU/U2vDmDnhSvJa15hjN5Kn6tuMWQms6jrkpr7kvFf+MgsceTg54DhGznUGMvWcq0C0doiSpSmkz/z5pXVS6/lmW/vhNSYljEwDI2M= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1775445624; c=relaxed/simple; bh=481Wi8F5rATpoD3yObFt4kyolEta/MdoULkTbw9tEns=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=J1uky0HmdaIsExe+yHfc4GXT1oPr8xyjcoFXWJqEvhJZMMsSK1/NXswpDQn/eZAozLywEuHBp7KbdZ3xewwRN2i+AniANyr7dx+l8T7yyQa93dRWRnF91xFew+WQAAKdehaaUJq2PRr1mznGNeoGB+i+DVxc9COJ4aoNoojCun4= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=PdQhmjZB; arc=none smtp.client-ip=209.85.217.49 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="PdQhmjZB" Received: by mail-vs1-f49.google.com with SMTP id ada2fe7eead31-60567e76830so2455348137.0 for ; Sun, 05 Apr 2026 20:20:23 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20251104; t=1775445622; x=1776050422; darn=vger.kernel.org; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:from:to:cc:subject:date:message-id :reply-to; bh=m6iklTPWapiRZ7MgWpEEMZ0NKXNj5RY7pCEbCs4h2g4=; b=PdQhmjZBkZudzg241asu8XKrdZ83zgAd9kzloIDMkh9CUgmB+yziqcFX1SUR48+JHT 6AhBevQIJqtKY4IKmSvEEI0GjMrcbX7KQg8BytUqeCU89M8QmE3lkirSWkqgIsAQ8Uyr f046A3vPIRp8KJAheY4GD6DgtzEE7ygFAgyzyfeCSIewTS6zaM3Hpth8kUIEy9Kedu9e rg00DjvCF60UomUF2ucM1zpdxW5uZ0fbksbymLNDDrM0XGsrx3jd05AtufeecehwANoH QvYxHSEOe/j2wbn8BN4c+ACPJctGsJen6AJq7jhnTgF2DWVVOnDm04kvgbi5WIcbbgQo P5Ew== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1775445622; x=1776050422; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-gg:x-gm-message-state:from:to :cc:subject:date:message-id:reply-to; bh=m6iklTPWapiRZ7MgWpEEMZ0NKXNj5RY7pCEbCs4h2g4=; b=F4/tAsKINiIvwna9S56nstn9Q0+r/LAIPDbf1qUGjRaJfBjFlVY9amK45Y/tMbLJtF aATW9KrKFsEetpKPDqzJ1hTW51Ok/71zTvgSFas8mY5U/S0qRBrqnHx4dkjZuGO2uKkQ nIBMBhV8Ca64aD0CxoelWzkPnmqSFRGiezWTsVekf4kc2EpBaL41J0F7DrMt5/K8gNJX J7UfY9nxby+ebDWHpO3WGRz0y0Pz/u4ZteFkbYaeonS2nQN//frV54g8OW/kQmkdQEmy OM2ItohQqPtTyeP6a9H5HJJiGL7m4xcMH9czA5U2UiEife+KkMfqWK0Eo395FTWffAAh oXjg== X-Forwarded-Encrypted: i=1; AJvYcCX3zJCz4Fcaq+NfwQT0Vn2GRWJvX8KhDuIX1HC0QnR6qKXe7g2JrG8qlBuDteX5V3JoT0vdRyVtmWkfQB0=@vger.kernel.org X-Gm-Message-State: AOJu0Ywxjm+hng5qBCoJAQC7ax19jliQFxCCYIOmMsZUVC8ZRwwMaaKb zxDKwAvsWr0s1PpPLQEDd/1cyCQk9zBdUicFUFrOcpkLZt4ITaqNSDf4 X-Gm-Gg: AeBDievBmG/w3jn0iAX3JRhTMYoVi56NCZtCLbSC7xikx+Tk9NhpyqUSmENfi9IiIsa ZMvuCosPBO9uP/iYSDGr8CYaK5zEkWARSd4/kndW8D4cFv2Zhj4GZrlw0ucMK3PBV9rtdC7icaO kLae5B6ZYBGZf3N7EbT4bV9PjlqYyfQvgnweqfWFhpnLw+zs4YNQKDW+PSSkC4NOfOTeInInKt1 RiV0d27rqRc3XJDU80eQpnodzopVBkIlwAP5fGbR7avszlpE6wvI7hWA4QThKpPpThIsxyk57Bz kjQsP39bXNQdJwyWXTwkJx4h/1w9a8cIqVsBXh+ZpkxwpXKxZL5h0+Z9FOgqGSrVgwjI8TMAduo HFglzGht27SadisTKb3wFv4oCl7iHfOon4RkHGKp9Y1320Asxg0uy+Jtu8VeaLPKfrzHF0B8mjf 49YavNBp1+ihjsLELWfwODaOs2fnWidbSkXSyPgSVJKkSZp2b1K5RMLmsu8Ad6fRumKjklz5W4a xLd X-Received: by 2002:a05:6102:1487:b0:602:b037:4de8 with SMTP id ada2fe7eead31-605a4cc6f09mr3898658137.4.1775445622284; Sun, 05 Apr 2026 20:20:22 -0700 (PDT) Received: from [192.168.1.18] (177-4-161-167.user3p.v-tal.net.br. [177.4.161.167]) by smtp.gmail.com with ESMTPSA id ada2fe7eead31-605b214b45fsm9162146137.5.2026.04.05.20.20.20 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 05 Apr 2026 20:20:22 -0700 (PDT) From: =?utf-8?q?C=C3=A1ssio_Gabriel?= Date: Mon, 06 Apr 2026 00:20:06 -0300 Subject: [PATCH 4/4] ALSA: gusmax: add ISA suspend and resume callbacks Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20260406-b4-alsa-gus-isa-pm-v1-4-b6829a7457cd@gmail.com> References: <20260406-b4-alsa-gus-isa-pm-v1-0-b6829a7457cd@gmail.com> In-Reply-To: <20260406-b4-alsa-gus-isa-pm-v1-0-b6829a7457cd@gmail.com> To: Takashi Iwai , Jaroslav Kysela Cc: linux-sound@vger.kernel.org, linux-kernel@vger.kernel.org, =?utf-8?q?C=C3=A1ssio_Gabriel?= X-Mailer: b4 0.15.1 X-Developer-Signature: v=1; a=openpgp-sha256; l=2077; i=cassiogabrielcontato@gmail.com; h=from:subject:message-id; bh=481Wi8F5rATpoD3yObFt4kyolEta/MdoULkTbw9tEns=; b=owGbwMvMwCV2IdZeKur/u2bG02pJDJmX1bLPnL+9q8bsW4H7mh+WAdeZv1/esGnmNd+FcllbO yx6l2Qt7ChlYRDjYpAVU2RZnbTIck/Xg6v1cSs8YOawMoEMYeDiFICJ1Joy/OGYlaf6wdIgsOAU 794pXQZHXCb9zNx1/Wnl0vrvFQ+3yvUz/NP4cHx3w7x7+eq+zOaXTnAY3d1w9aqWulh4T37xlO+ LvbgB X-Developer-Key: i=cassiogabrielcontato@gmail.com; a=openpgp; fpr=AB62A239BC8AE0D57F5EA848D05D3F1A5AFFEE83 gusmax still leaves its ISA PM callbacks disabled even though the shared GF1 suspend and resume path now exists. This board needs one extra piece of PM glue around the shared GF1 helpers. The attached WSS codec has its own register image that must be saved and restored across suspend, and the MAX control register must be rewritten on resume before the codec and GF1 sides are brought back. Use the existing wss->suspend() and wss->resume() hooks for the codec, then wire the driver up to the shared GUS suspend and resume helpers for the GF1 side. Signed-off-by: C=C3=A1ssio Gabriel --- sound/isa/gus/gusmax.c | 28 +++++++++++++++++++++++++++- 1 file changed, 27 insertions(+), 1 deletion(-) diff --git a/sound/isa/gus/gusmax.c b/sound/isa/gus/gusmax.c index b572411c4422..f1fd7ff2121d 100644 --- a/sound/isa/gus/gusmax.c +++ b/sound/isa/gus/gusmax.c @@ -328,12 +328,38 @@ static int snd_gusmax_probe(struct device *pdev, unsi= gned int dev) return 0; } =20 +#ifdef CONFIG_PM +static int snd_gusmax_suspend(struct device *dev, unsigned int n, + pm_message_t state) +{ + struct snd_card *card =3D dev_get_drvdata(dev); + struct snd_gusmax *maxcard =3D card->private_data; + + maxcard->wss->suspend(maxcard->wss); + return snd_gus_suspend(maxcard->gus); +} + +static int snd_gusmax_resume(struct device *dev, unsigned int n) +{ + struct snd_card *card =3D dev_get_drvdata(dev); + struct snd_gusmax *maxcard =3D card->private_data; + + /* Restore the board routing latch before resuming the codec and GF1. */ + outb(maxcard->gus->max_cntrl_val, GUSP(maxcard->gus, MAXCNTRLPORT)); + maxcard->wss->resume(maxcard->wss); + return snd_gus_resume(maxcard->gus); +} +#endif + #define DEV_NAME "gusmax" =20 static struct isa_driver snd_gusmax_driver =3D { .match =3D snd_gusmax_match, .probe =3D snd_gusmax_probe, - /* FIXME: suspend/resume */ +#ifdef CONFIG_PM + .suspend =3D snd_gusmax_suspend, + .resume =3D snd_gusmax_resume, +#endif .driver =3D { .name =3D DEV_NAME }, --=20 2.53.0