From nobody Fri Oct 10 15:59:06 2025 Received: from esa.microchip.iphmx.com (esa.microchip.iphmx.com [68.232.154.123]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id CE7C723CEF8; Fri, 13 Jun 2025 02:37:08 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=68.232.154.123 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1749782230; cv=none; b=sEyfT+vUbNI0zia5/psEfIAsOabGaLARAGhC4mgY0LvHEg9n1Fd/mi9VOeBWRO7UNbxSLY+3218JhLJokFcG2Gd4LN09hpXjGD/Iqt9heb/JwwTPBxQUBOY+id6ga+4CgSEXFwG5+Tlt19DXfnczOIFXgOfkUy7Cq1QnH5rS0hw= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1749782230; c=relaxed/simple; bh=AaMAd7P99bPS6v1TtqgmLfjW8dLKyubVTRpkuuqvjRQ=; h=From:To:CC:Subject:Date:Message-ID:MIME-Version:Content-Type; b=CaZbvXEPKwMPrA/5SaXyHlSr7rbjpPnjHCZ13sRaRvrlHdNJEZxjPxx6GBSYPBnCzdv/MyHwFnwozPnamvvnU6Q3I8g8fo+6J8s4sKFIl7zGOwzDf6OC0mFpy8AwnW+meaG3yR9/2qfU5h57fBQrAeV1EOsfUElCsQ5YHxsdMlo= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=microchip.com; spf=pass smtp.mailfrom=microchip.com; dkim=pass (2048-bit key) header.d=microchip.com header.i=@microchip.com header.b=y9RzSpuU; arc=none smtp.client-ip=68.232.154.123 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=microchip.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=microchip.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=microchip.com header.i=@microchip.com header.b="y9RzSpuU" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=microchip.com; i=@microchip.com; q=dns/txt; s=mchp; t=1749782228; x=1781318228; h=from:to:cc:subject:date:message-id:mime-version: content-transfer-encoding; bh=AaMAd7P99bPS6v1TtqgmLfjW8dLKyubVTRpkuuqvjRQ=; b=y9RzSpuUhormymyatooWWE0eo1wRRr1K8xkaMce1M21SV55M5sbkwKrj mjXPWPr188pNWr+NjuFyoNt5cac+a0P5ro0NqqIvOk4kRxy14LqNAT5Hf f6dTKL0N4mKOy9+NLwhmxE2bnaAJA1e6IW0/mcybg7GCJBbZQqXK93+vt JzBRpb2vJxzz6jPtu5apOfI2uWUaOylDQ7PlTSlhlrb0+v3s1ODp7Ytze H1Gm0FjSx4+eKtx7i82ecyRcOP1VvPP7Y0A5tfo+FFt2fBFyEffVElYwm jiyTU7cApM877j8keu4Qbver6nLk70Gd2appVdL/XGKYcFc1CxgxNAnsf A==; X-CSE-ConnectionGUID: woBN0T/mSu+U4tVni+WIGg== X-CSE-MsgGUID: 26MULG0hR6OxvlFWVEer3w== X-IronPort-AV: E=Sophos;i="6.16,232,1744095600"; d="scan'208";a="42284946" X-Amp-Result: SKIPPED(no attachment in message) Received: from unknown (HELO email.microchip.com) ([170.129.1.10]) by esa4.microchip.iphmx.com with ESMTP/TLS/ECDHE-RSA-AES128-GCM-SHA256; 12 Jun 2025 19:37:01 -0700 Received: from chn-vm-ex01.mchp-main.com (10.10.85.143) by chn-vm-ex02.mchp-main.com (10.10.85.144) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.1.2507.44; Thu, 12 Jun 2025 19:36:39 -0700 Received: from che-dk-ungapp03lx.microchip.com (10.10.85.11) by chn-vm-ex01.mchp-main.com (10.10.85.143) with Microsoft SMTP Server id 15.1.2507.44 via Frontend Transport; Thu, 12 Jun 2025 19:36:37 -0700 From: Thangaraj Samynathan To: , , CC: Subject: [PATCH v1 for-next] spi: spi_pci1xxxx: Add support for per-instance DMA interrupt vectors Date: Fri, 13 Jun 2025 08:02:36 +0530 Message-ID: <20250613023236.126770-1-thangaraj.s@microchip.com> X-Mailer: git-send-email 2.25.1 Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Add support for dedicated DMA interrupt vectors for each SPI hardware instance in the pci1xxxx driver. This improves scalability and interrupt handling for systems using multiple SPI instances with DMA. Introduce a constant `NUM_VEC_PER_INST` to define the number of IRQ vectors per instance (main, DMA write, DMA read). Update the `pci1xxxx_spi_internal` structure to use an IRQ array. Refactor IRQ allocation and DMA initialization logic: - Assign separate IRQ vectors for DMA read and write interrupts. - Split the original DMA ISR into two handlers: `pci1xxxx_spi_isr_dma_rd` and `pci1xxxx_spi_isr_dma_wr`. - Configure IMWR registers per instance using cached MSI data. - Move DMA register configuration into a new helper function, `pci1xxxx_spi_dma_config()`. Invoke the DMA initialization after all instances are configured to ensure correct IRQ vector mapping. Signed-off-by: Thangaraj Samynathan --- drivers/spi/spi-pci1xxxx.c | 212 +++++++++++++++++++++++++------------ 1 file changed, 144 insertions(+), 68 deletions(-) diff --git a/drivers/spi/spi-pci1xxxx.c b/drivers/spi/spi-pci1xxxx.c index a6c8bf228288..f44fe5841139 100644 --- a/drivers/spi/spi-pci1xxxx.c +++ b/drivers/spi/spi-pci1xxxx.c @@ -97,8 +97,8 @@ #define SPI_DMA_CH1_DONE_INT BIT(1) #define SPI_DMA_CH0_ABORT_INT BIT(16) #define SPI_DMA_CH1_ABORT_INT BIT(17) -#define SPI_DMA_DONE_INT_MASK (SPI_DMA_CH0_DONE_INT | SPI_DMA_CH1_DONE_IN= T) -#define SPI_DMA_ABORT_INT_MASK (SPI_DMA_CH0_ABORT_INT | SPI_DMA_CH1_ABORT= _INT) +#define SPI_DMA_DONE_INT_MASK(x) (1 << (x)) +#define SPI_DMA_ABORT_INT_MASK(x) (1 << (16 + (x))) #define DMA_CH_CONTROL_LIE BIT(3) #define DMA_CH_CONTROL_RIE BIT(4) #define DMA_INTR_EN (DMA_CH_CONTROL_RIE | DMA_CH_CONTROL_LIE) @@ -132,10 +132,12 @@ #define SPI_SUSPEND_CONFIG 0x101 #define SPI_RESUME_CONFIG 0x203 =20 +#define NUM_VEC_PER_INST 3 + struct pci1xxxx_spi_internal { u8 hw_inst; u8 clkdiv; - int irq; + int irq[NUM_VEC_PER_INST]; int mode; bool spi_xfer_in_progress; void *rx_buf; @@ -193,6 +195,9 @@ static const struct pci_device_id pci1xxxx_spi_pci_id_t= able[] =3D { =20 MODULE_DEVICE_TABLE(pci, pci1xxxx_spi_pci_id_table); =20 +static irqreturn_t pci1xxxx_spi_isr_dma_rd(int irq, void *dev); +static irqreturn_t pci1xxxx_spi_isr_dma_wr(int irq, void *dev); + static int pci1xxxx_set_sys_lock(struct pci1xxxx_spi *par) { writel(SPI_SYSLOCK, par->reg_base + SPI_SYSLOCK_REG); @@ -213,13 +218,16 @@ static void pci1xxxx_release_sys_lock(struct pci1xxxx= _spi *par) writel(0x0, par->reg_base + SPI_SYSLOCK_REG); } =20 -static int pci1xxxx_check_spi_can_dma(struct pci1xxxx_spi *spi_bus, int ir= q) +static int pci1xxxx_check_spi_can_dma(struct pci1xxxx_spi *spi_bus, int hw= _inst, int num_vector) { struct pci_dev *pdev =3D spi_bus->dev; u32 pf_num; u32 regval; int ret; =20 + if (num_vector !=3D hw_inst * NUM_VEC_PER_INST) + return -EOPNOTSUPP; + /* * DEV REV Registers is a system register, HW Syslock bit * should be acquired before accessing the register @@ -247,16 +255,6 @@ static int pci1xxxx_check_spi_can_dma(struct pci1xxxx_= spi *spi_bus, int irq) if (spi_bus->dev_rev < 0xC0 || pf_num) return -EOPNOTSUPP; =20 - /* - * DMA Supported only with MSI Interrupts - * One of the SPI instance's MSI vector address and data - * is used for DMA Interrupt - */ - if (!irq_get_msi_desc(irq)) { - dev_warn(&pdev->dev, "Error MSI Interrupt not supported, will operate in= PIO mode\n"); - return -EOPNOTSUPP; - } - spi_bus->dma_offset_bar =3D pcim_iomap(pdev, 2, pci_resource_len(pdev, 2)= ); if (!spi_bus->dma_offset_bar) { dev_warn(&pdev->dev, "Error failed to map dma bar, will operate in PIO m= ode\n"); @@ -273,29 +271,90 @@ static int pci1xxxx_check_spi_can_dma(struct pci1xxxx= _spi *spi_bus, int irq) return 0; } =20 -static int pci1xxxx_spi_dma_init(struct pci1xxxx_spi *spi_bus, int irq) +static void pci1xxxx_spi_dma_config(struct pci1xxxx_spi *spi_bus) { + struct pci1xxxx_spi_internal *spi_sub_ptr; + u8 iter, irq_index; struct msi_msg msi; + u32 regval; + u16 data; + + irq_index =3D spi_bus->total_hw_instances; + for (iter =3D 0; iter < spi_bus->total_hw_instances; iter++) { + spi_sub_ptr =3D spi_bus->spi_int[iter]; + get_cached_msi_msg(spi_sub_ptr->irq[1], &msi); + if (iter =3D=3D 0) { + writel(msi.address_hi, spi_bus->dma_offset_bar + + SPI_DMA_INTR_IMWR_WDONE_HIGH); + writel(msi.address_hi, spi_bus->dma_offset_bar + + SPI_DMA_INTR_IMWR_WABORT_HIGH); + writel(msi.address_hi, spi_bus->dma_offset_bar + + SPI_DMA_INTR_IMWR_RDONE_HIGH); + writel(msi.address_hi, spi_bus->dma_offset_bar + + SPI_DMA_INTR_IMWR_RABORT_HIGH); + writel(msi.address_lo, spi_bus->dma_offset_bar + + SPI_DMA_INTR_IMWR_WDONE_LOW); + writel(msi.address_lo, spi_bus->dma_offset_bar + + SPI_DMA_INTR_IMWR_WABORT_LOW); + writel(msi.address_lo, spi_bus->dma_offset_bar + + SPI_DMA_INTR_IMWR_RDONE_LOW); + writel(msi.address_lo, spi_bus->dma_offset_bar + + SPI_DMA_INTR_IMWR_RABORT_LOW); + writel(0, spi_bus->dma_offset_bar + SPI_DMA_INTR_WR_IMWR_DATA); + writel(0, spi_bus->dma_offset_bar + SPI_DMA_INTR_RD_IMWR_DATA); + } + regval =3D readl(spi_bus->dma_offset_bar + SPI_DMA_INTR_WR_IMWR_DATA); + data =3D msi.data + irq_index; + writel((regval | (data << (iter * 16))), spi_bus->dma_offset_bar + + SPI_DMA_INTR_WR_IMWR_DATA); + regval =3D readl(spi_bus->dma_offset_bar + SPI_DMA_INTR_WR_IMWR_DATA); + irq_index++; + + data =3D msi.data + irq_index; + regval =3D readl(spi_bus->dma_offset_bar + SPI_DMA_INTR_RD_IMWR_DATA); + writel(regval | (data << (iter * 16)), spi_bus->dma_offset_bar + + SPI_DMA_INTR_RD_IMWR_DATA); + regval =3D readl(spi_bus->dma_offset_bar + SPI_DMA_INTR_RD_IMWR_DATA); + irq_index++; + } +} + +static int pci1xxxx_spi_dma_init(struct pci1xxxx_spi *spi_bus, int hw_inst= , int num_vector) +{ + struct pci1xxxx_spi_internal *spi_sub_ptr; + u8 iter, irq_index; int ret; =20 - ret =3D pci1xxxx_check_spi_can_dma(spi_bus, irq); + irq_index =3D hw_inst; + ret =3D pci1xxxx_check_spi_can_dma(spi_bus, hw_inst, num_vector); if (ret) return ret; =20 spin_lock_init(&spi_bus->dma_reg_lock); - get_cached_msi_msg(irq, &msi); writel(SPI_DMA_ENGINE_EN, spi_bus->dma_offset_bar + SPI_DMA_GLOBAL_WR_ENG= INE_EN); writel(SPI_DMA_ENGINE_EN, spi_bus->dma_offset_bar + SPI_DMA_GLOBAL_RD_ENG= INE_EN); - writel(msi.address_hi, spi_bus->dma_offset_bar + SPI_DMA_INTR_IMWR_WDONE_= HIGH); - writel(msi.address_hi, spi_bus->dma_offset_bar + SPI_DMA_INTR_IMWR_WABORT= _HIGH); - writel(msi.address_hi, spi_bus->dma_offset_bar + SPI_DMA_INTR_IMWR_RDONE_= HIGH); - writel(msi.address_hi, spi_bus->dma_offset_bar + SPI_DMA_INTR_IMWR_RABORT= _HIGH); - writel(msi.address_lo, spi_bus->dma_offset_bar + SPI_DMA_INTR_IMWR_WDONE_= LOW); - writel(msi.address_lo, spi_bus->dma_offset_bar + SPI_DMA_INTR_IMWR_WABORT= _LOW); - writel(msi.address_lo, spi_bus->dma_offset_bar + SPI_DMA_INTR_IMWR_RDONE_= LOW); - writel(msi.address_lo, spi_bus->dma_offset_bar + SPI_DMA_INTR_IMWR_RABORT= _LOW); - writel(msi.data, spi_bus->dma_offset_bar + SPI_DMA_INTR_WR_IMWR_DATA); - writel(msi.data, spi_bus->dma_offset_bar + SPI_DMA_INTR_RD_IMWR_DATA); + + for (iter =3D 0; iter < hw_inst; iter++) { + spi_sub_ptr =3D spi_bus->spi_int[iter]; + spi_sub_ptr->irq[1] =3D pci_irq_vector(spi_bus->dev, irq_index); + ret =3D devm_request_irq(&spi_bus->dev->dev, spi_sub_ptr->irq[1], + pci1xxxx_spi_isr_dma_wr, PCI1XXXX_IRQ_FLAGS, + pci_name(spi_bus->dev), spi_sub_ptr); + if (ret < 0) + return ret; + + irq_index++; + + spi_sub_ptr->irq[2] =3D pci_irq_vector(spi_bus->dev, irq_index); + ret =3D devm_request_irq(&spi_bus->dev->dev, spi_sub_ptr->irq[2], + pci1xxxx_spi_isr_dma_rd, PCI1XXXX_IRQ_FLAGS, + pci_name(spi_bus->dev), spi_sub_ptr); + if (ret < 0) + return ret; + + irq_index++; + } + pci1xxxx_spi_dma_config(spi_bus); dma_set_max_seg_size(&spi_bus->dev->dev, PCI1XXXX_SPI_BUFFER_SIZE); spi_bus->can_dma =3D true; return 0; @@ -401,13 +460,13 @@ static void pci1xxxx_spi_setup(struct pci1xxxx_spi *p= ar, u8 hw_inst, u32 mode, writel(regval, par->reg_base + SPI_MST_CTL_REG_OFFSET(hw_inst)); } =20 -static void pci1xxxx_start_spi_xfer(struct pci1xxxx_spi_internal *p, u8 hw= _inst) +static void pci1xxxx_start_spi_xfer(struct pci1xxxx_spi_internal *p) { u32 regval; =20 - regval =3D readl(p->parent->reg_base + SPI_MST_CTL_REG_OFFSET(hw_inst)); + regval =3D readl(p->parent->reg_base + SPI_MST_CTL_REG_OFFSET(p->hw_inst)= ); regval |=3D SPI_MST_CTL_GO; - writel(regval, p->parent->reg_base + SPI_MST_CTL_REG_OFFSET(hw_inst)); + writel(regval, p->parent->reg_base + SPI_MST_CTL_REG_OFFSET(p->hw_inst)); } =20 static int pci1xxxx_spi_transfer_with_io(struct spi_controller *spi_ctlr, @@ -451,7 +510,7 @@ static int pci1xxxx_spi_transfer_with_io(struct spi_con= troller *spi_ctlr, &tx_buf[bytes_transfered], len); bytes_transfered +=3D len; pci1xxxx_spi_setup(par, p->hw_inst, spi->mode, clkdiv, len); - pci1xxxx_start_spi_xfer(p, p->hw_inst); + pci1xxxx_start_spi_xfer(p); =20 /* Wait for DMA_TERM interrupt */ result =3D wait_for_completion_timeout(&p->spi_xfer_done, @@ -627,7 +686,7 @@ static void pci1xxxx_spi_setup_next_dma_transfer(struct= pci1xxxx_spi_internal *p } } =20 -static irqreturn_t pci1xxxx_spi_isr_dma(int irq, void *dev) +static irqreturn_t pci1xxxx_spi_isr_dma_rd(int irq, void *dev) { struct pci1xxxx_spi_internal *p =3D dev; irqreturn_t spi_int_fired =3D IRQ_NONE; @@ -637,36 +696,53 @@ static irqreturn_t pci1xxxx_spi_isr_dma(int irq, void= *dev) spin_lock_irqsave(&p->parent->dma_reg_lock, flags); /* Clear the DMA RD INT and start spi xfer*/ regval =3D readl(p->parent->dma_offset_bar + SPI_DMA_INTR_RD_STS); - if (regval & SPI_DMA_DONE_INT_MASK) { - if (regval & SPI_DMA_CH0_DONE_INT) - pci1xxxx_start_spi_xfer(p, SPI0); - if (regval & SPI_DMA_CH1_DONE_INT) - pci1xxxx_start_spi_xfer(p, SPI1); - spi_int_fired =3D IRQ_HANDLED; - } - if (regval & SPI_DMA_ABORT_INT_MASK) { - p->dma_aborted_rd =3D true; - spi_int_fired =3D IRQ_HANDLED; + if (regval) { + if (regval & SPI_DMA_DONE_INT_MASK(p->hw_inst)) { + pci1xxxx_start_spi_xfer(p); + spi_int_fired =3D IRQ_HANDLED; + } + if (regval & SPI_DMA_ABORT_INT_MASK(p->hw_inst)) { + p->dma_aborted_rd =3D true; + spi_int_fired =3D IRQ_HANDLED; + } } - writel(regval, p->parent->dma_offset_bar + SPI_DMA_INTR_RD_CLR); + writel((SPI_DMA_DONE_INT_MASK(p->hw_inst) | SPI_DMA_ABORT_INT_MASK(p->hw_= inst)), + p->parent->dma_offset_bar + SPI_DMA_INTR_RD_CLR); + spin_unlock_irqrestore(&p->parent->dma_reg_lock, flags); + return spi_int_fired; +} =20 +static irqreturn_t pci1xxxx_spi_isr_dma_wr(int irq, void *dev) +{ + struct pci1xxxx_spi_internal *p =3D dev; + irqreturn_t spi_int_fired =3D IRQ_NONE; + unsigned long flags; + u32 regval; + + spin_lock_irqsave(&p->parent->dma_reg_lock, flags); /* Clear the DMA WR INT */ regval =3D readl(p->parent->dma_offset_bar + SPI_DMA_INTR_WR_STS); - if (regval & SPI_DMA_DONE_INT_MASK) { - if (regval & SPI_DMA_CH0_DONE_INT) - pci1xxxx_spi_setup_next_dma_transfer(p->parent->spi_int[SPI0]); - - if (regval & SPI_DMA_CH1_DONE_INT) - pci1xxxx_spi_setup_next_dma_transfer(p->parent->spi_int[SPI1]); - - spi_int_fired =3D IRQ_HANDLED; - } - if (regval & SPI_DMA_ABORT_INT_MASK) { - p->dma_aborted_wr =3D true; - spi_int_fired =3D IRQ_HANDLED; + if (regval) { + if (regval & SPI_DMA_DONE_INT_MASK(p->hw_inst)) { + pci1xxxx_spi_setup_next_dma_transfer(p); + spi_int_fired =3D IRQ_HANDLED; + } + if (regval & SPI_DMA_ABORT_INT_MASK(p->hw_inst)) { + p->dma_aborted_wr =3D true; + spi_int_fired =3D IRQ_HANDLED; + } } - writel(regval, p->parent->dma_offset_bar + SPI_DMA_INTR_WR_CLR); + writel((SPI_DMA_DONE_INT_MASK(p->hw_inst) | SPI_DMA_ABORT_INT_MASK(p->hw_= inst)), + p->parent->dma_offset_bar + SPI_DMA_INTR_WR_CLR); spin_unlock_irqrestore(&p->parent->dma_reg_lock, flags); + return spi_int_fired; +} + +static irqreturn_t pci1xxxx_spi_isr_dma(int irq, void *dev) +{ + struct pci1xxxx_spi_internal *p =3D dev; + irqreturn_t spi_int_fired =3D IRQ_NONE; + u32 regval; =20 /* Clear the SPI GO_BIT Interrupt */ regval =3D readl(p->parent->reg_base + SPI_MST_EVENT_REG_OFFSET(p->hw_ins= t)); @@ -764,7 +840,7 @@ static int pci1xxxx_spi_probe(struct pci_dev *pdev, con= st struct pci_device_id * if (!spi_bus->reg_base) return -EINVAL; =20 - num_vector =3D pci_alloc_irq_vectors(pdev, 1, hw_inst_cnt, + num_vector =3D pci_alloc_irq_vectors(pdev, 1, hw_inst_cnt * NUM_VEC_PER= _INST, PCI_IRQ_INTX | PCI_IRQ_MSI); if (num_vector < 0) { dev_err(&pdev->dev, "Error allocating MSI vectors\n"); @@ -778,27 +854,23 @@ static int pci1xxxx_spi_probe(struct pci_dev *pdev, c= onst struct pci_device_id * regval &=3D ~SPI_INTR; writel(regval, spi_bus->reg_base + SPI_MST_EVENT_MASK_REG_OFFSET(spi_sub_ptr->hw_inst)); - spi_sub_ptr->irq =3D pci_irq_vector(pdev, 0); + spi_sub_ptr->irq[0] =3D pci_irq_vector(pdev, 0); =20 if (num_vector >=3D hw_inst_cnt) - ret =3D devm_request_irq(&pdev->dev, spi_sub_ptr->irq, + ret =3D devm_request_irq(&pdev->dev, spi_sub_ptr->irq[0], pci1xxxx_spi_isr, PCI1XXXX_IRQ_FLAGS, pci_name(pdev), spi_sub_ptr); else - ret =3D devm_request_irq(&pdev->dev, spi_sub_ptr->irq, + ret =3D devm_request_irq(&pdev->dev, spi_sub_ptr->irq[0], pci1xxxx_spi_shared_isr, PCI1XXXX_IRQ_FLAGS | IRQF_SHARED, pci_name(pdev), spi_bus); if (ret < 0) { dev_err(&pdev->dev, "Unable to request irq : %d", - spi_sub_ptr->irq); + spi_sub_ptr->irq[0]); return -ENODEV; } =20 - ret =3D pci1xxxx_spi_dma_init(spi_bus, spi_sub_ptr->irq); - if (ret && ret !=3D -EOPNOTSUPP) - return ret; - /* This register is only applicable for 1st instance */ regval =3D readl(spi_bus->reg_base + SPI_PCI_CTRL_REG_OFFSET(0)); if (!only_sec_inst) @@ -820,13 +892,13 @@ static int pci1xxxx_spi_probe(struct pci_dev *pdev, c= onst struct pci_device_id * writel(regval, spi_bus->reg_base + SPI_MST_EVENT_MASK_REG_OFFSET(spi_sub_ptr->hw_inst)); if (num_vector >=3D hw_inst_cnt) { - spi_sub_ptr->irq =3D pci_irq_vector(pdev, iter); - ret =3D devm_request_irq(&pdev->dev, spi_sub_ptr->irq, + spi_sub_ptr->irq[0] =3D pci_irq_vector(pdev, iter); + ret =3D devm_request_irq(&pdev->dev, spi_sub_ptr->irq[0], pci1xxxx_spi_isr, PCI1XXXX_IRQ_FLAGS, pci_name(pdev), spi_sub_ptr); if (ret < 0) { dev_err(&pdev->dev, "Unable to request irq : %d", - spi_sub_ptr->irq); + spi_sub_ptr->irq[0]); return -ENODEV; } } @@ -849,6 +921,10 @@ static int pci1xxxx_spi_probe(struct pci_dev *pdev, co= nst struct pci_device_id * if (ret) return ret; } + ret =3D pci1xxxx_spi_dma_init(spi_bus, hw_inst_cnt, num_vector); + if (ret && ret !=3D -EOPNOTSUPP) + return ret; + pci_set_drvdata(pdev, spi_bus); =20 return 0; --=20 2.25.1