| // SPDX-License-Identifier: GPL-2.0 | |
| /* Marvell Octeon CN10K DPI driver | |
| * | |
| * Copyright (C) 2024 Marvell. | |
| * | |
| */ | |
| #include <linux/bitfield.h> | |
| #include <linux/compat.h> | |
| #include <linux/delay.h> | |
| #include <linux/miscdevice.h> | |
| #include <linux/module.h> | |
| #include <linux/pci.h> | |
| #include <linux/irq.h> | |
| #include <linux/interrupt.h> | |
| #include <uapi/misc/mrvl_cn10k_dpi.h> | |
| /* PCI device IDs */ | |
| #define PCI_DEVID_MRVL_CN10K_DPI_PF 0xA080 | |
| #define PCI_SUBDEVID_MRVL_CN10K_DPI_PF 0xB900 | |
| /* PCI BAR Number */ | |
| #define PCI_DPI_CFG_BAR 0 | |
| /* MSI-X interrupts */ | |
| #define DPI_MAX_REQQ_INT 0x20 | |
| #define DPI_MAX_CC_INT 0x40 | |
| /* MBOX MSI-X interrupt vector index */ | |
| #define DPI_MBOX_PF_VF_INT_IDX 0x75 | |
| #define DPI_MAX_IRQS (DPI_MBOX_PF_VF_INT_IDX + 1) | |
| #define DPI_MAX_VFS 0x20 | |
| #define DPI_MAX_ENG_FIFO_SZ 0x20 | |
| #define DPI_MAX_ENG_MOLR 0x400 | |
| #define DPI_DMA_IDS_DMA_NPA_PF_FUNC(x) FIELD_PREP(GENMASK_ULL(31, 16), x) | |
| #define DPI_DMA_IDS_INST_STRM(x) FIELD_PREP(GENMASK_ULL(47, 40), x) | |
| #define DPI_DMA_IDS_DMA_STRM(x) FIELD_PREP(GENMASK_ULL(39, 32), x) | |
| #define DPI_DMA_ENG_EN_MOLR(x) FIELD_PREP(GENMASK_ULL(41, 32), x) | |
| #define DPI_EBUS_PORTX_CFG_MPS(x) FIELD_PREP(GENMASK(6, 4), x) | |
| #define DPI_DMA_IDS_DMA_SSO_PF_FUNC(x) FIELD_PREP(GENMASK(15, 0), x) | |
| #define DPI_DMA_IDS2_INST_AURA(x) FIELD_PREP(GENMASK(19, 0), x) | |
| #define DPI_DMA_IBUFF_CSIZE_CSIZE(x) FIELD_PREP(GENMASK(13, 0), x) | |
| #define DPI_EBUS_PORTX_CFG_MRRS(x) FIELD_PREP(GENMASK(2, 0), x) | |
| #define DPI_ENG_BUF_BLKS(x) FIELD_PREP(GENMASK(5, 0), x) | |
| #define DPI_DMA_CONTROL_DMA_ENB GENMASK_ULL(53, 48) | |
| #define DPI_DMA_CONTROL_O_MODE BIT_ULL(14) | |
| #define DPI_DMA_CONTROL_LDWB BIT_ULL(32) | |
| #define DPI_DMA_CONTROL_WQECSMODE1 BIT_ULL(37) | |
| #define DPI_DMA_CONTROL_ZBWCSEN BIT_ULL(39) | |
| #define DPI_DMA_CONTROL_WQECSOFF(ofst) (((u64)ofst) << 40) | |
| #define DPI_DMA_CONTROL_WQECSDIS BIT_ULL(47) | |
| #define DPI_DMA_CONTROL_PKT_EN BIT_ULL(56) | |
| #define DPI_DMA_IBUFF_CSIZE_NPA_FREE BIT(16) | |
| #define DPI_CTL_EN BIT_ULL(0) | |
| #define DPI_DMA_CC_INT BIT_ULL(0) | |
| #define DPI_DMA_QRST BIT_ULL(0) | |
| #define DPI_REQQ_INT_INSTRFLT BIT_ULL(0) | |
| #define DPI_REQQ_INT_RDFLT BIT_ULL(1) | |
| #define DPI_REQQ_INT_WRFLT BIT_ULL(2) | |
| #define DPI_REQQ_INT_CSFLT BIT_ULL(3) | |
| #define DPI_REQQ_INT_INST_DBO BIT_ULL(4) | |
| #define DPI_REQQ_INT_INST_ADDR_NULL BIT_ULL(5) | |
| #define DPI_REQQ_INT_INST_FILL_INVAL BIT_ULL(6) | |
| #define DPI_REQQ_INT_INSTR_PSN BIT_ULL(7) | |
| #define DPI_REQQ_INT \ | |
| (DPI_REQQ_INT_INSTRFLT | \ | |
| DPI_REQQ_INT_RDFLT | \ | |
| DPI_REQQ_INT_WRFLT | \ | |
| DPI_REQQ_INT_CSFLT | \ | |
| DPI_REQQ_INT_INST_DBO | \ | |
| DPI_REQQ_INT_INST_ADDR_NULL | \ | |
| DPI_REQQ_INT_INST_FILL_INVAL | \ | |
| DPI_REQQ_INT_INSTR_PSN) | |
| #define DPI_PF_RAS_EBI_DAT_PSN BIT_ULL(0) | |
| #define DPI_PF_RAS_NCB_DAT_PSN BIT_ULL(1) | |
| #define DPI_PF_RAS_NCB_CMD_PSN BIT_ULL(2) | |
| #define DPI_PF_RAS_INT \ | |
| (DPI_PF_RAS_EBI_DAT_PSN | \ | |
| DPI_PF_RAS_NCB_DAT_PSN | \ | |
| DPI_PF_RAS_NCB_CMD_PSN) | |
| /* Message fields in word_l of DPI mailbox structure */ | |
| #define DPI_MBOX_VFID(msg) FIELD_GET(GENMASK_ULL(7, 0), msg) | |
| #define DPI_MBOX_CMD(msg) FIELD_GET(GENMASK_ULL(11, 8), msg) | |
| #define DPI_MBOX_CBUF_SIZE(msg) FIELD_GET(GENMASK_ULL(27, 12), msg) | |
| #define DPI_MBOX_CBUF_AURA(msg) FIELD_GET(GENMASK_ULL(47, 28), msg) | |
| #define DPI_MBOX_SSO_PFFUNC(msg) FIELD_GET(GENMASK_ULL(63, 48), msg) | |
| /* Message fields in word_h of DPI mailbox structure */ | |
| #define DPI_MBOX_NPA_PFFUNC(msg) FIELD_GET(GENMASK_ULL(15, 0), msg) | |
| #define DPI_MBOX_WQES_COMPL(msg) FIELD_GET(GENMASK_ULL(16, 16), msg) | |
| #define DPI_MBOX_WQES_OFFSET(msg) FIELD_GET(GENMASK_ULL(23, 17), msg) | |
| #define DPI_DMAX_IBUFF_CSIZE(x) (0x0ULL | ((x) << 11)) | |
| #define DPI_DMAX_IDS(x) (0x18ULL | ((x) << 11)) | |
| #define DPI_DMAX_IDS2(x) (0x20ULL | ((x) << 11)) | |
| #define DPI_DMAX_QRST(x) (0x30ULL | ((x) << 11)) | |
| #define DPI_CTL 0x10010ULL | |
| #define DPI_DMA_CONTROL 0x10018ULL | |
| #define DPI_PF_RAS 0x10308ULL | |
| #define DPI_PF_RAS_ENA_W1C 0x10318ULL | |
| #define DPI_MBOX_VF_PF_INT 0x16300ULL | |
| #define DPI_MBOX_VF_PF_INT_W1S 0x16308ULL | |
| #define DPI_MBOX_VF_PF_INT_ENA_W1C 0x16310ULL | |
| #define DPI_MBOX_VF_PF_INT_ENA_W1S 0x16318ULL | |
| #define DPI_DMA_ENGX_EN(x) (0x10040ULL | ((x) << 3)) | |
| #define DPI_ENGX_BUF(x) (0x100C0ULL | ((x) << 3)) | |
| #define DPI_EBUS_PORTX_CFG(x) (0x10100ULL | ((x) << 3)) | |
| #define DPI_DMA_CCX_INT(x) (0x11000ULL | ((x) << 3)) | |
| #define DPI_DMA_CCX_INT_ENA_W1C(x) (0x11800ULL | ((x) << 3)) | |
| #define DPI_REQQX_INT(x) (0x12C00ULL | ((x) << 5)) | |
| #define DPI_REQQX_INT_ENA_W1C(x) (0x13800ULL | ((x) << 5)) | |
| #define DPI_MBOX_PF_VF_DATA0(x) (0x16000ULL | ((x) << 4)) | |
| #define DPI_MBOX_PF_VF_DATA1(x) (0x16008ULL | ((x) << 4)) | |
| #define DPI_WCTL_FIF_THR 0x17008ULL | |
| #define DPI_EBUS_MAX_PORTS 2 | |
| #define DPI_EBUS_MRRS_MIN 128 | |
| #define DPI_EBUS_MRRS_MAX 1024 | |
| #define DPI_EBUS_MPS_MIN 128 | |
| #define DPI_EBUS_MPS_MAX 1024 | |
| #define DPI_WCTL_FIFO_THRESHOLD 0x30 | |
| #define DPI_QUEUE_OPEN 0x1 | |
| #define DPI_QUEUE_CLOSE 0x2 | |
| #define DPI_REG_DUMP 0x3 | |
| #define DPI_GET_REG_CFG 0x4 | |
| #define DPI_QUEUE_OPEN_V2 0x5 | |
| enum dpi_mbox_rsp_type { | |
| DPI_MBOX_TYPE_CMD, | |
| DPI_MBOX_TYPE_RSP_ACK, | |
| DPI_MBOX_TYPE_RSP_NACK, | |
| }; | |
| struct dpivf_config { | |
| u32 aura; | |
| u16 csize; | |
| u16 sso_pf_func; | |
| u16 npa_pf_func; | |
| }; | |
| struct dpipf_vf { | |
| struct dpivf_config vf_config; | |
| bool setup_done; | |
| u8 this_vfid; | |
| }; | |
| /* DPI device mailbox */ | |
| struct dpi_mbox { | |
| struct work_struct work; | |
| /* lock to serialize mbox requests */ | |
| struct mutex lock; | |
| struct dpipf *pf; | |
| u8 __iomem *pf_vf_data_reg; | |
| u8 __iomem *vf_pf_data_reg; | |
| }; | |
| struct dpipf { | |
| struct miscdevice miscdev; | |
| void __iomem *reg_base; | |
| struct pci_dev *pdev; | |
| struct dpipf_vf vf[DPI_MAX_VFS]; | |
| /* Mailbox to talk to VFs */ | |
| struct dpi_mbox *mbox[DPI_MAX_VFS]; | |
| }; | |
| struct dpi_mbox_message { | |
| uint64_t word_l; | |
| uint64_t word_h; | |
| }; | |
| static inline void dpi_reg_write(struct dpipf *dpi, u64 offset, u64 val) | |
| { | |
| writeq(val, dpi->reg_base + offset); | |
| } | |
| static inline u64 dpi_reg_read(struct dpipf *dpi, u64 offset) | |
| { | |
| return readq(dpi->reg_base + offset); | |
| } | |
| static void dpi_wqe_cs_offset(struct dpipf *dpi, u8 offset) | |
| { | |
| u64 reg; | |
| reg = dpi_reg_read(dpi, DPI_DMA_CONTROL); | |
| reg &= ~DPI_DMA_CONTROL_WQECSDIS; | |
| reg |= DPI_DMA_CONTROL_ZBWCSEN | DPI_DMA_CONTROL_WQECSMODE1; | |
| reg |= DPI_DMA_CONTROL_WQECSOFF(offset); | |
| dpi_reg_write(dpi, DPI_DMA_CONTROL, reg); | |
| } | |
| static int dpi_queue_init(struct dpipf *dpi, struct dpipf_vf *dpivf, u8 vf) | |
| { | |
| u16 sso_pf_func = dpivf->vf_config.sso_pf_func; | |
| u16 npa_pf_func = dpivf->vf_config.npa_pf_func; | |
| u16 csize = dpivf->vf_config.csize; | |
| u32 aura = dpivf->vf_config.aura; | |
| unsigned long timeout; | |
| u64 reg; | |
| dpi_reg_write(dpi, DPI_DMAX_QRST(vf), DPI_DMA_QRST); | |
| /* Wait for a maximum of 3 sec */ | |
| timeout = jiffies + msecs_to_jiffies(3000); | |
| while (!time_after(jiffies, timeout)) { | |
| reg = dpi_reg_read(dpi, DPI_DMAX_QRST(vf)); | |
| if (!(reg & DPI_DMA_QRST)) | |
| break; | |
| /* Reset would take time for the request cache to drain */ | |
| usleep_range(500, 1000); | |
| } | |
| if (reg & DPI_DMA_QRST) { | |
| dev_err(&dpi->pdev->dev, "Queue reset failed\n"); | |
| return -EBUSY; | |
| } | |
| dpi_reg_write(dpi, DPI_DMAX_IDS2(vf), 0); | |
| dpi_reg_write(dpi, DPI_DMAX_IDS(vf), 0); | |
| reg = DPI_DMA_IBUFF_CSIZE_CSIZE(csize) | DPI_DMA_IBUFF_CSIZE_NPA_FREE; | |
| dpi_reg_write(dpi, DPI_DMAX_IBUFF_CSIZE(vf), reg); | |
| reg = dpi_reg_read(dpi, DPI_DMAX_IDS2(vf)); | |
| reg |= DPI_DMA_IDS2_INST_AURA(aura); | |
| dpi_reg_write(dpi, DPI_DMAX_IDS2(vf), reg); | |
| reg = dpi_reg_read(dpi, DPI_DMAX_IDS(vf)); | |
| reg |= DPI_DMA_IDS_DMA_NPA_PF_FUNC(npa_pf_func); | |
| reg |= DPI_DMA_IDS_DMA_SSO_PF_FUNC(sso_pf_func); | |
| reg |= DPI_DMA_IDS_DMA_STRM(vf + 1); | |
| reg |= DPI_DMA_IDS_INST_STRM(vf + 1); | |
| dpi_reg_write(dpi, DPI_DMAX_IDS(vf), reg); | |
| return 0; | |
| } | |
| static void dpi_queue_fini(struct dpipf *dpi, u8 vf) | |
| { | |
| dpi_reg_write(dpi, DPI_DMAX_QRST(vf), DPI_DMA_QRST); | |
| /* Reset IDS and IDS2 registers */ | |
| dpi_reg_write(dpi, DPI_DMAX_IDS2(vf), 0); | |
| dpi_reg_write(dpi, DPI_DMAX_IDS(vf), 0); | |
| } | |
| static irqreturn_t dpi_mbox_intr_handler(int irq, void *data) | |
| { | |
| struct dpipf *dpi = data; | |
| u64 reg; | |
| u32 vf; | |
| reg = dpi_reg_read(dpi, DPI_MBOX_VF_PF_INT); | |
| if (reg) { | |
| for (vf = 0; vf < pci_num_vf(dpi->pdev); vf++) { | |
| if (reg & BIT_ULL(vf)) | |
| schedule_work(&dpi->mbox[vf]->work); | |
| } | |
| dpi_reg_write(dpi, DPI_MBOX_VF_PF_INT, reg); | |
| } | |
| return IRQ_HANDLED; | |
| } | |
| static int queue_config(struct dpipf *dpi, struct dpipf_vf *dpivf, struct dpi_mbox_message *msg) | |
| { | |
| int ret = 0; | |
| switch (DPI_MBOX_CMD(msg->word_l)) { | |
| case DPI_QUEUE_OPEN: | |
| case DPI_QUEUE_OPEN_V2: | |
| dpivf->vf_config.aura = DPI_MBOX_CBUF_AURA(msg->word_l); | |
| dpivf->vf_config.csize = DPI_MBOX_CMD(msg->word_l) == DPI_QUEUE_OPEN ? | |
| DPI_MBOX_CBUF_SIZE(msg->word_l) >> 3 : | |
| DPI_MBOX_CBUF_SIZE(msg->word_l); | |
| dpivf->vf_config.sso_pf_func = DPI_MBOX_SSO_PFFUNC(msg->word_l); | |
| dpivf->vf_config.npa_pf_func = DPI_MBOX_NPA_PFFUNC(msg->word_h); | |
| ret = dpi_queue_init(dpi, dpivf, DPI_MBOX_VFID(msg->word_l)); | |
| if (!ret) { | |
| if (DPI_MBOX_WQES_COMPL(msg->word_h)) | |
| dpi_wqe_cs_offset(dpi, DPI_MBOX_WQES_OFFSET(msg->word_h)); | |
| dpivf->setup_done = true; | |
| } | |
| break; | |
| case DPI_QUEUE_CLOSE: | |
| memset(&dpivf->vf_config, 0, sizeof(struct dpivf_config)); | |
| dpi_queue_fini(dpi, DPI_MBOX_VFID(msg->word_l)); | |
| dpivf->setup_done = false; | |
| break; | |
| default: | |
| return -EINVAL; | |
| } | |
| return ret; | |
| } | |
| static void dpi_pfvf_mbox_work(struct work_struct *work) | |
| { | |
| struct dpi_mbox *mbox = container_of(work, struct dpi_mbox, work); | |
| struct dpi_mbox_message msg; | |
| struct dpipf_vf *dpivf; | |
| struct dpipf *dpi; | |
| int vfid, ret; | |
| dpi = mbox->pf; | |
| memset(&msg, 0, sizeof(msg)); | |
| mutex_lock(&mbox->lock); | |
| msg.word_l = readq(mbox->vf_pf_data_reg); | |
| if (msg.word_l == (u64)-1) | |
| goto exit; | |
| vfid = DPI_MBOX_VFID(msg.word_l); | |
| if (vfid >= pci_num_vf(dpi->pdev)) | |
| goto exit; | |
| dpivf = &dpi->vf[vfid]; | |
| msg.word_h = readq(mbox->pf_vf_data_reg); | |
| ret = queue_config(dpi, dpivf, &msg); | |
| if (ret < 0) | |
| writeq(DPI_MBOX_TYPE_RSP_NACK, mbox->pf_vf_data_reg); | |
| else | |
| writeq(DPI_MBOX_TYPE_RSP_ACK, mbox->pf_vf_data_reg); | |
| exit: | |
| mutex_unlock(&mbox->lock); | |
| } | |
| /* Setup registers for a PF mailbox */ | |
| static void dpi_setup_mbox_regs(struct dpipf *dpi, int vf) | |
| { | |
| struct dpi_mbox *mbox = dpi->mbox[vf]; | |
| mbox->pf_vf_data_reg = dpi->reg_base + DPI_MBOX_PF_VF_DATA0(vf); | |
| mbox->vf_pf_data_reg = dpi->reg_base + DPI_MBOX_PF_VF_DATA1(vf); | |
| } | |
| static int dpi_pfvf_mbox_setup(struct dpipf *dpi) | |
| { | |
| int vf; | |
| for (vf = 0; vf < DPI_MAX_VFS; vf++) { | |
| dpi->mbox[vf] = devm_kzalloc(&dpi->pdev->dev, sizeof(*dpi->mbox[vf]), GFP_KERNEL); | |
| if (!dpi->mbox[vf]) | |
| return -ENOMEM; | |
| mutex_init(&dpi->mbox[vf]->lock); | |
| INIT_WORK(&dpi->mbox[vf]->work, dpi_pfvf_mbox_work); | |
| dpi->mbox[vf]->pf = dpi; | |
| dpi_setup_mbox_regs(dpi, vf); | |
| } | |
| return 0; | |
| } | |
| static void dpi_pfvf_mbox_destroy(struct dpipf *dpi) | |
| { | |
| unsigned int vf; | |
| for (vf = 0; vf < DPI_MAX_VFS; vf++) { | |
| if (work_pending(&dpi->mbox[vf]->work)) | |
| cancel_work_sync(&dpi->mbox[vf]->work); | |
| dpi->mbox[vf] = NULL; | |
| } | |
| } | |
| static void dpi_init(struct dpipf *dpi) | |
| { | |
| unsigned int engine, port; | |
| u8 mrrs_val, mps_val; | |
| u64 reg; | |
| for (engine = 0; engine < DPI_MAX_ENGINES; engine++) { | |
| if (engine == 4 || engine == 5) | |
| reg = DPI_ENG_BUF_BLKS(16); | |
| else | |
| reg = DPI_ENG_BUF_BLKS(8); | |
| dpi_reg_write(dpi, DPI_ENGX_BUF(engine), reg); | |
| } | |
| reg = DPI_DMA_CONTROL_ZBWCSEN | DPI_DMA_CONTROL_PKT_EN | DPI_DMA_CONTROL_LDWB | | |
| DPI_DMA_CONTROL_O_MODE | DPI_DMA_CONTROL_DMA_ENB; | |
| dpi_reg_write(dpi, DPI_DMA_CONTROL, reg); | |
| dpi_reg_write(dpi, DPI_CTL, DPI_CTL_EN); | |
| mrrs_val = 2; /* 512B */ | |
| mps_val = 1; /* 256B */ | |
| for (port = 0; port < DPI_EBUS_MAX_PORTS; port++) { | |
| reg = dpi_reg_read(dpi, DPI_EBUS_PORTX_CFG(port)); | |
| reg &= ~(DPI_EBUS_PORTX_CFG_MRRS(7) | DPI_EBUS_PORTX_CFG_MPS(7)); | |
| reg |= DPI_EBUS_PORTX_CFG_MPS(mps_val) | DPI_EBUS_PORTX_CFG_MRRS(mrrs_val); | |
| dpi_reg_write(dpi, DPI_EBUS_PORTX_CFG(port), reg); | |
| } | |
| dpi_reg_write(dpi, DPI_WCTL_FIF_THR, DPI_WCTL_FIFO_THRESHOLD); | |
| } | |
| static void dpi_fini(struct dpipf *dpi) | |
| { | |
| unsigned int engine; | |
| for (engine = 0; engine < DPI_MAX_ENGINES; engine++) | |
| dpi_reg_write(dpi, DPI_ENGX_BUF(engine), 0); | |
| dpi_reg_write(dpi, DPI_DMA_CONTROL, 0); | |
| dpi_reg_write(dpi, DPI_CTL, 0); | |
| } | |
| static void dpi_free_irq_vectors(void *pdev) | |
| { | |
| pci_free_irq_vectors((struct pci_dev *)pdev); | |
| } | |
| static int dpi_irq_init(struct dpipf *dpi) | |
| { | |
| struct pci_dev *pdev = dpi->pdev; | |
| struct device *dev = &pdev->dev; | |
| int i, ret; | |
| /* Clear all RAS interrupts */ | |
| dpi_reg_write(dpi, DPI_PF_RAS, DPI_PF_RAS_INT); | |
| /* Clear all RAS interrupt enable bits */ | |
| dpi_reg_write(dpi, DPI_PF_RAS_ENA_W1C, DPI_PF_RAS_INT); | |
| for (i = 0; i < DPI_MAX_REQQ_INT; i++) { | |
| dpi_reg_write(dpi, DPI_REQQX_INT(i), DPI_REQQ_INT); | |
| dpi_reg_write(dpi, DPI_REQQX_INT_ENA_W1C(i), DPI_REQQ_INT); | |
| } | |
| for (i = 0; i < DPI_MAX_CC_INT; i++) { | |
| dpi_reg_write(dpi, DPI_DMA_CCX_INT(i), DPI_DMA_CC_INT); | |
| dpi_reg_write(dpi, DPI_DMA_CCX_INT_ENA_W1C(i), DPI_DMA_CC_INT); | |
| } | |
| ret = pci_alloc_irq_vectors(pdev, DPI_MAX_IRQS, DPI_MAX_IRQS, PCI_IRQ_MSIX); | |
| if (ret != DPI_MAX_IRQS) { | |
| dev_err(dev, "DPI: Failed to alloc %d msix irqs\n", DPI_MAX_IRQS); | |
| return ret; | |
| } | |
| ret = devm_add_action_or_reset(dev, dpi_free_irq_vectors, pdev); | |
| if (ret) { | |
| dev_err(dev, "DPI: Failed to add irq free action\n"); | |
| return ret; | |
| } | |
| ret = devm_request_irq(dev, pci_irq_vector(pdev, DPI_MBOX_PF_VF_INT_IDX), | |
| dpi_mbox_intr_handler, 0, "dpi-mbox", dpi); | |
| if (ret) | |
| return ret; | |
| dpi_reg_write(dpi, DPI_MBOX_VF_PF_INT_ENA_W1S, GENMASK_ULL(31, 0)); | |
| return 0; | |
| } | |
| static int dpi_mps_mrrs_config(struct dpipf *dpi, void __user *arg) | |
| { | |
| struct dpi_mps_mrrs_cfg cfg; | |
| u8 mrrs_val, mps_val; | |
| u64 reg; | |
| if (copy_from_user(&cfg, arg, sizeof(struct dpi_mps_mrrs_cfg))) | |
| return -EFAULT; | |
| if (cfg.max_read_req_sz < DPI_EBUS_MRRS_MIN || cfg.max_read_req_sz > DPI_EBUS_MRRS_MAX || | |
| !is_power_of_2(cfg.max_read_req_sz)) | |
| return -EINVAL; | |
| if (cfg.max_payload_sz < DPI_EBUS_MPS_MIN || cfg.max_payload_sz > DPI_EBUS_MPS_MAX || | |
| !is_power_of_2(cfg.max_payload_sz)) | |
| return -EINVAL; | |
| if (cfg.port >= DPI_EBUS_MAX_PORTS) | |
| return -EINVAL; | |
| /* Make sure reserved fields are set to 0 */ | |
| if (cfg.reserved) | |
| return -EINVAL; | |
| mrrs_val = fls(cfg.max_read_req_sz >> 8); | |
| mps_val = fls(cfg.max_payload_sz >> 8); | |
| reg = dpi_reg_read(dpi, DPI_EBUS_PORTX_CFG(cfg.port)); | |
| reg &= ~(DPI_EBUS_PORTX_CFG_MRRS(0x7) | DPI_EBUS_PORTX_CFG_MPS(0x7)); | |
| reg |= DPI_EBUS_PORTX_CFG_MPS(mps_val) | DPI_EBUS_PORTX_CFG_MRRS(mrrs_val); | |
| dpi_reg_write(dpi, DPI_EBUS_PORTX_CFG(cfg.port), reg); | |
| return 0; | |
| } | |
| static int dpi_engine_config(struct dpipf *dpi, void __user *arg) | |
| { | |
| struct dpi_engine_cfg cfg; | |
| unsigned int engine; | |
| u8 *eng_buf; | |
| u64 reg; | |
| if (copy_from_user(&cfg, arg, sizeof(struct dpi_engine_cfg))) | |
| return -EFAULT; | |
| /* Make sure reserved fields are set to 0 */ | |
| if (cfg.reserved) | |
| return -EINVAL; | |
| eng_buf = (u8 *)&cfg.fifo_mask; | |
| for (engine = 0; engine < DPI_MAX_ENGINES; engine++) { | |
| if (eng_buf[engine] > DPI_MAX_ENG_FIFO_SZ) | |
| return -EINVAL; | |
| dpi_reg_write(dpi, DPI_ENGX_BUF(engine), eng_buf[engine]); | |
| if (cfg.update_molr) { | |
| if (cfg.molr[engine] > DPI_MAX_ENG_MOLR) | |
| return -EINVAL; | |
| reg = DPI_DMA_ENG_EN_MOLR(cfg.molr[engine]); | |
| dpi_reg_write(dpi, DPI_DMA_ENGX_EN(engine), reg); | |
| } else { | |
| /* Make sure unused fields are set to 0 */ | |
| if (cfg.molr[engine]) | |
| return -EINVAL; | |
| } | |
| } | |
| return 0; | |
| } | |
| static long dpi_dev_ioctl(struct file *fptr, unsigned int cmd, unsigned long data) | |
| { | |
| void __user *arg = (void __user *)data; | |
| struct dpipf *dpi; | |
| int ret; | |
| dpi = container_of(fptr->private_data, struct dpipf, miscdev); | |
| switch (cmd) { | |
| case DPI_MPS_MRRS_CFG: | |
| ret = dpi_mps_mrrs_config(dpi, arg); | |
| break; | |
| case DPI_ENGINE_CFG: | |
| ret = dpi_engine_config(dpi, arg); | |
| break; | |
| default: | |
| ret = -ENOTTY; | |
| break; | |
| } | |
| return ret; | |
| } | |
| static const struct file_operations dpi_device_fops = { | |
| .owner = THIS_MODULE, | |
| .unlocked_ioctl = dpi_dev_ioctl, | |
| .compat_ioctl = compat_ptr_ioctl, | |
| }; | |
| static int dpi_probe(struct pci_dev *pdev, const struct pci_device_id *id) | |
| { | |
| struct device *dev = &pdev->dev; | |
| struct dpipf *dpi; | |
| int ret; | |
| dpi = devm_kzalloc(dev, sizeof(*dpi), GFP_KERNEL); | |
| if (!dpi) | |
| return -ENOMEM; | |
| dpi->pdev = pdev; | |
| ret = pcim_enable_device(pdev); | |
| if (ret) { | |
| dev_err(dev, "DPI: Failed to enable PCI device\n"); | |
| return ret; | |
| } | |
| ret = pcim_iomap_regions(pdev, BIT(0) | BIT(4), KBUILD_MODNAME); | |
| if (ret) { | |
| dev_err(dev, "DPI: Failed to request MMIO region\n"); | |
| return ret; | |
| } | |
| dpi->reg_base = pcim_iomap_table(pdev)[PCI_DPI_CFG_BAR]; | |
| /* Initialize global PF registers */ | |
| dpi_init(dpi); | |
| /* Setup PF-VF mailbox */ | |
| ret = dpi_pfvf_mbox_setup(dpi); | |
| if (ret) { | |
| dev_err(dev, "DPI: Failed to setup pf-vf mbox\n"); | |
| goto err_dpi_fini; | |
| } | |
| /* Register interrupts */ | |
| ret = dpi_irq_init(dpi); | |
| if (ret) { | |
| dev_err(dev, "DPI: Failed to initialize irq vectors\n"); | |
| goto err_dpi_mbox_free; | |
| } | |
| pci_set_drvdata(pdev, dpi); | |
| dpi->miscdev.minor = MISC_DYNAMIC_MINOR; | |
| dpi->miscdev.name = KBUILD_MODNAME; | |
| dpi->miscdev.fops = &dpi_device_fops; | |
| dpi->miscdev.parent = dev; | |
| ret = misc_register(&dpi->miscdev); | |
| if (ret) { | |
| dev_err(dev, "DPI: Failed to register misc device\n"); | |
| goto err_dpi_mbox_free; | |
| } | |
| return 0; | |
| err_dpi_mbox_free: | |
| dpi_pfvf_mbox_destroy(dpi); | |
| err_dpi_fini: | |
| dpi_fini(dpi); | |
| return ret; | |
| } | |
| static void dpi_remove(struct pci_dev *pdev) | |
| { | |
| struct dpipf *dpi = pci_get_drvdata(pdev); | |
| misc_deregister(&dpi->miscdev); | |
| pci_sriov_configure_simple(pdev, 0); | |
| dpi_pfvf_mbox_destroy(dpi); | |
| dpi_fini(dpi); | |
| pci_set_drvdata(pdev, NULL); | |
| } | |
| static const struct pci_device_id dpi_id_table[] = { | |
| { PCI_DEVICE_SUB(PCI_VENDOR_ID_CAVIUM, PCI_DEVID_MRVL_CN10K_DPI_PF, | |
| PCI_VENDOR_ID_CAVIUM, PCI_SUBDEVID_MRVL_CN10K_DPI_PF) }, | |
| { } /* end of table */ | |
| }; | |
| static struct pci_driver dpi_driver = { | |
| .name = KBUILD_MODNAME, | |
| .id_table = dpi_id_table, | |
| .probe = dpi_probe, | |
| .remove = dpi_remove, | |
| .sriov_configure = pci_sriov_configure_simple, | |
| }; | |
| module_pci_driver(dpi_driver); | |
| MODULE_DEVICE_TABLE(pci, dpi_id_table); | |
| MODULE_AUTHOR("Marvell."); | |
| MODULE_DESCRIPTION("Marvell Octeon CN10K DPI Driver"); | |
| MODULE_LICENSE("GPL"); |