Unverified Commit 84049e2d authored by Cezary Rojewski's avatar Cezary Rojewski Committed by Mark Brown
Browse files

ASoC: Intel: avs: Remove unused IRQ-related code 



Most IRQ-related code is duplicated in the driver. Switch to the new
implementation and remove unused members.

While the change is non-trivial, from functional perspective status quo
is achieved.

Signed-off-by: default avatarCezary Rojewski <cezary.rojewski@intel.com>
Link: https://lore.kernel.org/r/20240419084857.2719593-3-cezary.rojewski@intel.com


Signed-off-by: default avatarMark Brown <broonie@kernel.org>
parent 7ce6ceeb

sound/soc/intel/avs/apl.c

+0 −2
Original line number Diff line number Diff line
@@ -255,8 +255,6 @@ const struct avs_dsp_ops avs_apl_dsp_ops = { 
	.reset = avs_dsp_core_reset,

	.stall = avs_dsp_core_stall,

	.dsp_interrupt = avs_apl_dsp_interrupt,

	.irq_handler = avs_irq_handler,

	.irq_thread = avs_skl_irq_thread,

	.int_control = avs_dsp_interrupt_control,

	.load_basefw = avs_hda_load_basefw,

	.load_lib = avs_hda_load_library,

sound/soc/intel/avs/avs.h

+0 −5
Original line number Diff line number Diff line
@@ -47,8 +47,6 @@ struct avs_dsp_ops { 
	int (* const reset)(struct avs_dev *, u32, bool);

	int (* const stall)(struct avs_dev *, u32, bool);

	irqreturn_t (* const dsp_interrupt)(struct avs_dev *);

	irqreturn_t (* const irq_handler)(struct avs_dev *);

	irqreturn_t (* const irq_thread)(struct avs_dev *);

	void (* const int_control)(struct avs_dev *, bool);

	int (* const load_basefw)(struct avs_dev *, struct firmware *);

	int (* const load_lib)(struct avs_dev *, struct firmware *, u32);
@@ -246,7 +244,6 @@ struct avs_ipc { 
#define AVS_IPC_RET(ret) \

	(((ret) <= 0) ? (ret) : -AVS_EIPC)



irqreturn_t avs_irq_handler(struct avs_dev *adev);

void avs_dsp_process_response(struct avs_dev *adev, u64 header);

int avs_dsp_send_msg_timeout(struct avs_dev *adev, struct avs_ipc_msg *request,

			     struct avs_ipc_msg *reply, int timeout, const char *name);
@@ -268,8 +265,6 @@ void avs_ipc_block(struct avs_ipc *ipc); 
int avs_dsp_disable_d0ix(struct avs_dev *adev);

int avs_dsp_enable_d0ix(struct avs_dev *adev);



irqreturn_t avs_skl_irq_thread(struct avs_dev *adev);

irqreturn_t avs_cnl_irq_thread(struct avs_dev *adev);

void avs_skl_ipc_interrupt(struct avs_dev *adev);

irqreturn_t avs_cnl_dsp_interrupt(struct avs_dev *adev);

int avs_apl_enable_logs(struct avs_dev *adev, enum avs_log_enable enable, u32 aging_period,

sound/soc/intel/avs/cldma.c

+4 −41
Original line number Diff line number Diff line
@@ -248,28 +248,6 @@ void hda_cldma_setup(struct hda_cldma *cl) 
	snd_hdac_stream_writel(cl, CL_SPBFCTL, 1);

}



static irqreturn_t cldma_irq_handler(int irq, void *dev_id)

{

	struct hda_cldma *cl = dev_id;

	u32 adspis;



	adspis = snd_hdac_adsp_readl(cl, AVS_ADSP_REG_ADSPIS);

	if (adspis == UINT_MAX)

		return IRQ_NONE;

	if (!(adspis & AVS_ADSP_ADSPIS_CLDMA))

		return IRQ_NONE;



	cl->sd_status = snd_hdac_stream_readb(cl, SD_STS);

	dev_warn(cl->dev, "%s sd_status: 0x%08x\n", __func__, cl->sd_status);



	/* disable CLDMA interrupt */

	snd_hdac_adsp_updatel(cl, AVS_ADSP_REG_ADSPIC, AVS_ADSP_ADSPIC_CLDMA, 0);



	complete(&cl->completion);



	return IRQ_HANDLED;

}



void hda_cldma_interrupt(struct hda_cldma *cl)

{

	/* disable CLDMA interrupt */
@@ -284,7 +262,6 @@ void hda_cldma_interrupt(struct hda_cldma *cl) 
int hda_cldma_init(struct hda_cldma *cl, struct hdac_bus *bus, void __iomem *dsp_ba,

		   unsigned int buffer_size)

{

	struct pci_dev *pci = to_pci_dev(bus->dev);

	int ret;



	ret = snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV_SG, bus->dev, buffer_size, &cl->dmab_data);
@@ -292,8 +269,10 @@ int hda_cldma_init(struct hda_cldma *cl, struct hdac_bus *bus, void __iomem *dsp 
		return ret;



	ret = snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, bus->dev, BDL_SIZE, &cl->dmab_bdl);

	if (ret < 0)

		goto alloc_err;

	if (ret < 0) {

		snd_dma_free_pages(&cl->dmab_data);

		return ret;

	}



	cl->dev = bus->dev;

	cl->bus = bus;
@@ -301,27 +280,11 @@ int hda_cldma_init(struct hda_cldma *cl, struct hdac_bus *bus, void __iomem *dsp 
	cl->buffer_size = buffer_size;

	cl->sd_addr = dsp_ba + AZX_CL_SD_BASE;



	ret = pci_request_irq(pci, 0, cldma_irq_handler, NULL, cl, "CLDMA");

	if (ret < 0) {

		dev_err(cl->dev, "Failed to request CLDMA IRQ handler: %d\n", ret);

		goto req_err;

	}



	return 0;



req_err:

	snd_dma_free_pages(&cl->dmab_bdl);

alloc_err:

	snd_dma_free_pages(&cl->dmab_data);



	return ret;

}



void hda_cldma_free(struct hda_cldma *cl)

{

	struct pci_dev *pci = to_pci_dev(cl->dev);



	pci_free_irq(pci, 0, cl);

	snd_dma_free_pages(&cl->dmab_data);

	snd_dma_free_pages(&cl->dmab_bdl);

}

sound/soc/intel/avs/cnl.c

+0 −34
Original line number Diff line number Diff line
@@ -10,38 +10,6 @@ 
#include "avs.h"

#include "messages.h"



irqreturn_t avs_cnl_irq_thread(struct avs_dev *adev)

{

	union avs_reply_msg msg;

	u32 hipctdr, hipctdd, hipctda;



	hipctdr = snd_hdac_adsp_readl(adev, CNL_ADSP_REG_HIPCTDR);

	hipctdd = snd_hdac_adsp_readl(adev, CNL_ADSP_REG_HIPCTDD);



	/* Ensure DSP sent new response to process. */

	if (!(hipctdr & CNL_ADSP_HIPCTDR_BUSY))

		return IRQ_NONE;



	msg.primary = hipctdr;

	msg.ext.val = hipctdd;

	avs_dsp_process_response(adev, msg.val);



	/* Tell DSP we accepted its message. */

	snd_hdac_adsp_updatel(adev, CNL_ADSP_REG_HIPCTDR,

			      CNL_ADSP_HIPCTDR_BUSY, CNL_ADSP_HIPCTDR_BUSY);

	/* Ack this response. */

	snd_hdac_adsp_updatel(adev, CNL_ADSP_REG_HIPCTDA,

			      CNL_ADSP_HIPCTDA_DONE, CNL_ADSP_HIPCTDA_DONE);

	/* HW might have been clock gated, give some time for change to propagate. */

	snd_hdac_adsp_readl_poll(adev, CNL_ADSP_REG_HIPCTDA, hipctda,

				 !(hipctda & CNL_ADSP_HIPCTDA_DONE), 10, 1000);

	/* Unmask busy interrupt. */

	snd_hdac_adsp_updatel(adev, CNL_ADSP_REG_HIPCCTL,

			      AVS_ADSP_HIPCCTL_BUSY, AVS_ADSP_HIPCCTL_BUSY);



	return IRQ_HANDLED;

}



static void avs_cnl_ipc_interrupt(struct avs_dev *adev)

{

	const struct avs_spec *spec = adev->spec;
@@ -109,8 +77,6 @@ const struct avs_dsp_ops avs_cnl_dsp_ops = { 
	.reset = avs_dsp_core_reset,

	.stall = avs_dsp_core_stall,

	.dsp_interrupt = avs_cnl_dsp_interrupt,

	.irq_handler = avs_irq_handler,

	.irq_thread = avs_cnl_irq_thread,

	.int_control = avs_dsp_interrupt_control,

	.load_basefw = avs_hda_load_basefw,

	.load_lib = avs_hda_load_library,

sound/soc/intel/avs/core.c

+3 −88
Original line number Diff line number Diff line
@@ -257,85 +257,6 @@ static void hdac_update_stream(struct hdac_bus *bus, struct hdac_stream *stream) 
	}

}



static irqreturn_t hdac_bus_irq_handler(int irq, void *context)

{

	struct hdac_bus *bus = context;

	u32 mask, int_enable;

	u32 status;

	int ret = IRQ_NONE;



	if (!pm_runtime_active(bus->dev))

		return ret;



	spin_lock(&bus->reg_lock);



	status = snd_hdac_chip_readl(bus, INTSTS);

	if (status == 0 || status == UINT_MAX) {

		spin_unlock(&bus->reg_lock);

		return ret;

	}



	/* clear rirb int */

	status = snd_hdac_chip_readb(bus, RIRBSTS);

	if (status & RIRB_INT_MASK) {

		if (status & RIRB_INT_RESPONSE)

			snd_hdac_bus_update_rirb(bus);

		snd_hdac_chip_writeb(bus, RIRBSTS, RIRB_INT_MASK);

	}



	mask = (0x1 << bus->num_streams) - 1;



	status = snd_hdac_chip_readl(bus, INTSTS);

	status &= mask;

	if (status) {

		/* Disable stream interrupts; Re-enable in bottom half */

		int_enable = snd_hdac_chip_readl(bus, INTCTL);

		snd_hdac_chip_writel(bus, INTCTL, (int_enable & (~mask)));

		ret = IRQ_WAKE_THREAD;

	} else {

		ret = IRQ_HANDLED;

	}



	spin_unlock(&bus->reg_lock);

	return ret;

}



static irqreturn_t hdac_bus_irq_thread(int irq, void *context)

{

	struct hdac_bus *bus = context;

	u32 status;

	u32 int_enable;

	u32 mask;

	unsigned long flags;



	status = snd_hdac_chip_readl(bus, INTSTS);



	snd_hdac_bus_handle_stream_irq(bus, status, hdac_update_stream);



	/* Re-enable stream interrupts */

	mask = (0x1 << bus->num_streams) - 1;

	spin_lock_irqsave(&bus->reg_lock, flags);

	int_enable = snd_hdac_chip_readl(bus, INTCTL);

	snd_hdac_chip_writel(bus, INTCTL, (int_enable | mask));

	spin_unlock_irqrestore(&bus->reg_lock, flags);



	return IRQ_HANDLED;

}



static irqreturn_t avs_dsp_irq_handler(int irq, void *dev_id)

{

	struct avs_dev *adev = dev_id;



	return avs_dsp_op(adev, irq_handler);

}



static irqreturn_t avs_dsp_irq_thread(int irq, void *dev_id)

{

	struct avs_dev *adev = dev_id;



	return avs_dsp_op(adev, irq_thread);

}



static irqreturn_t avs_hda_interrupt(struct hdac_bus *bus)

{

	irqreturn_t ret = IRQ_NONE;
@@ -359,7 +280,6 @@ static irqreturn_t avs_hda_interrupt(struct hdac_bus *bus) 
	return ret;

}



__maybe_unused

static irqreturn_t avs_hda_irq_handler(int irq, void *dev_id)

{

	struct hdac_bus *bus = dev_id;
@@ -375,7 +295,6 @@ static irqreturn_t avs_hda_irq_handler(int irq, void *dev_id) 
	return IRQ_WAKE_THREAD;

}



__maybe_unused

static irqreturn_t avs_hda_irq_thread(int irq, void *dev_id)

{

	struct hdac_bus *bus = dev_id;
@@ -391,16 +310,14 @@ static irqreturn_t avs_hda_irq_thread(int irq, void *dev_id) 
	return IRQ_HANDLED;

}



__maybe_unused

static irqreturn_t avs_dsp_irq_handler2(int irq, void *dev_id)

static irqreturn_t avs_dsp_irq_handler(int irq, void *dev_id)

{

	struct avs_dev *adev = dev_id;



	return avs_hda_irq_handler(irq, &adev->base.core);

}



__maybe_unused

static irqreturn_t avs_dsp_irq_thread2(int irq, void *dev_id)

static irqreturn_t avs_dsp_irq_thread(int irq, void *dev_id)

{

	struct avs_dev *adev = dev_id;

	struct hdac_bus *bus = &adev->base.core;
@@ -429,7 +346,7 @@ static int avs_hdac_acquire_irq(struct avs_dev *adev) 
		return ret;

	}



	ret = pci_request_irq(pci, 0, hdac_bus_irq_handler, hdac_bus_irq_thread, bus,

	ret = pci_request_irq(pci, 0, avs_hda_irq_handler, avs_hda_irq_thread, bus,

			      KBUILD_MODNAME);

	if (ret < 0) {

		dev_err(adev->dev, "Failed to request stream IRQ handler: %d\n", ret);
@@ -610,8 +527,6 @@ static void avs_pci_shutdown(struct pci_dev *pci) 
	snd_hdac_bus_stop_chip(bus);

	snd_hdac_display_power(bus, HDA_CODEC_IDX_CONTROLLER, false);



	if (avs_platattr_test(adev, CLDMA))

		pci_free_irq(pci, 0, &code_loader);

	pci_free_irq(pci, 0, adev);

	pci_free_irq(pci, 0, bus);

	pci_free_irq_vectors(pci);