From patchwork Wed Oct 24 17:55:31 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Liming Sun X-Patchwork-Id: 10654839 Return-Path: Received: from mail.wl.linuxfoundation.org (pdx-wl-mail.web.codeaurora.org [172.30.200.125]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 18EA714BD for ; Wed, 24 Oct 2018 17:58:07 +0000 (UTC) Received: from mail.wl.linuxfoundation.org (localhost [127.0.0.1]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id 05E1E2B14B for ; Wed, 24 Oct 2018 17:58:07 +0000 (UTC) Received: by mail.wl.linuxfoundation.org (Postfix, from userid 486) id ED7552B152; Wed, 24 Oct 2018 17:58:06 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on pdx-wl-mail.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-2.9 required=2.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,MAILING_LIST_MULTI,RCVD_IN_DNSWL_NONE,UNPARSEABLE_RELAY autolearn=ham version=3.3.1 Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.wl.linuxfoundation.org (Postfix) with ESMTPS id EF2502B14B for ; Wed, 24 Oct 2018 17:58:04 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20170209; h=Sender: Content-Transfer-Encoding:Content-Type:MIME-Version:Cc:List-Subscribe: List-Help:List-Post:List-Archive:List-Unsubscribe:List-Id:References: In-Reply-To:Message-Id:Date:Subject:To:From:Reply-To:Content-ID: Content-Description:Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc :Resent-Message-ID:List-Owner; bh=iELEQ3maYDuBt6T7gFlWw9I5+Pf2DFvJ9/GGmOIF5JY=; b=OGFQCpm+UiXc6gtqQXl73+DseP wjti6FWuqZUPjoe+BxUWZu/+Or95vtgL/k03ivwnBjuna5eiiUEJDIKRr/YBFuhp/H2jFRtpT626Y CTkf4mgKpBuw6iTPWoJGm1Zrjki0ejRp0HxLAahQN5V8DRufKdTcgU9ZZvqJuYLgLQND4x4nxRCSp UVg0ZkLBgaWYC/5v1XPkepYFqKVv/GSnqf+I+fKj0voP3gOTj87Sx9tgHu6pCbnp8LNeArQVNCK84 zaDWV1JZTpEdUxe+kwPvxw1mZmw7LcDrtv8bamBG1oOYBUq4jTVftiNNqb8YW6ElQNOiejuKOwJqv TopNR/Jg==; Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.90_1 #2 (Red Hat Linux)) id 1gFNPt-0007w2-1o; Wed, 24 Oct 2018 17:58:01 +0000 Received: from mail-il-dmz.mellanox.com ([193.47.165.129] helo=mellanox.co.il) by bombadil.infradead.org with esmtp (Exim 4.90_1 #2 (Red Hat Linux)) id 1gFNNv-00076O-66 for linux-arm-kernel@lists.infradead.org; Wed, 24 Oct 2018 17:56:57 +0000 Received: from Internal Mail-Server by MTLPINE1 (envelope-from lsun@mellanox.com) with ESMTPS (AES256-SHA encrypted); 24 Oct 2018 20:00:49 +0200 Received: from bu-lab53.mtbu.labs.mlnx (bu-lab53.mtbu.labs.mlnx [10.15.8.107]) by labmailer.mlnx (8.13.8/8.13.8) with ESMTP id w9OHtewB029010; Wed, 24 Oct 2018 20:55:40 +0300 Received: from bu-lab53.mtbu.labs.mlnx (localhost [127.0.0.1]) by bu-lab53.mtbu.labs.mlnx (8.14.7/8.14.7) with ESMTP id w9OHtdfW137760; Wed, 24 Oct 2018 13:55:39 -0400 Received: (from lsun@localhost) by bu-lab53.mtbu.labs.mlnx (8.14.7/8.14.7/Submit) id w9OHtcwc137759; Wed, 24 Oct 2018 13:55:38 -0400 From: Liming Sun To: Olof Johansson , Arnd Bergmann , David Woods , Robin Murphy , arm-soc Subject: [PATCH v4 1/4] soc: Add TmFifo driver for Mellanox BlueField Soc Date: Wed, 24 Oct 2018 13:55:31 -0400 Message-Id: <1540403734-137721-1-git-send-email-lsun@mellanox.com> X-Mailer: git-send-email 1.8.3.1 In-Reply-To: References: X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20181024_105559_890858_D45E8204 X-CRM114-Status: GOOD ( 23.18 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.21 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: devicetree@vger.kernel.org, Liming Sun , linux-arm-kernel@lists.infradead.org MIME-Version: 1.0 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+patchwork-linux-arm=patchwork.kernel.org@lists.infradead.org X-Virus-Scanned: ClamAV using ClamSMTP This commit adds the TmFifo driver for Mellanox BlueField Soc. TmFifo is a shared FIFO which enables external host machine to exchange data with the SoC via USB or PCIe. The driver is based on virtio framework and has console and network access enabled. Reviewed-by: David Woods Signed-off-by: Liming Sun --- drivers/soc/Kconfig | 1 + drivers/soc/Makefile | 1 + drivers/soc/mellanox/Kconfig | 18 + drivers/soc/mellanox/Makefile | 5 + drivers/soc/mellanox/tmfifo.c | 1239 ++++++++++++++++++++++++++++++++++++ drivers/soc/mellanox/tmfifo_regs.h | 75 +++ 6 files changed, 1339 insertions(+) create mode 100644 drivers/soc/mellanox/Kconfig create mode 100644 drivers/soc/mellanox/Makefile create mode 100644 drivers/soc/mellanox/tmfifo.c create mode 100644 drivers/soc/mellanox/tmfifo_regs.h diff --git a/drivers/soc/Kconfig b/drivers/soc/Kconfig index c07b4a8..fa87dc8 100644 --- a/drivers/soc/Kconfig +++ b/drivers/soc/Kconfig @@ -7,6 +7,7 @@ source "drivers/soc/bcm/Kconfig" source "drivers/soc/fsl/Kconfig" source "drivers/soc/imx/Kconfig" source "drivers/soc/mediatek/Kconfig" +source "drivers/soc/mellanox/Kconfig" source "drivers/soc/qcom/Kconfig" source "drivers/soc/renesas/Kconfig" source "drivers/soc/rockchip/Kconfig" diff --git a/drivers/soc/Makefile b/drivers/soc/Makefile index 113e884..93052d0 100644 --- a/drivers/soc/Makefile +++ b/drivers/soc/Makefile @@ -13,6 +13,7 @@ obj-$(CONFIG_ARCH_GEMINI) += gemini/ obj-$(CONFIG_ARCH_MXC) += imx/ obj-$(CONFIG_SOC_XWAY) += lantiq/ obj-y += mediatek/ +obj-$(CONFIG_SOC_MLNX) += mellanox/ obj-$(CONFIG_ARCH_MESON) += amlogic/ obj-y += qcom/ obj-y += renesas/ diff --git a/drivers/soc/mellanox/Kconfig b/drivers/soc/mellanox/Kconfig new file mode 100644 index 0000000..d88efa1 --- /dev/null +++ b/drivers/soc/mellanox/Kconfig @@ -0,0 +1,18 @@ +menuconfig SOC_MLNX + bool "Mellanox SoC drivers" + default y if ARCH_MLNX_BLUEFIELD + +if ARCH_MLNX_BLUEFIELD || COMPILE_TEST + +config MLNX_BLUEFIELD_TMFIFO + tristate "Mellanox BlueField SoC TmFifo driver" + depends on ARM64 + default m + select VIRTIO_CONSOLE + select VIRTIO_NET + help + Say y here to enable TmFifo support. The TmFifo driver provides the + virtio driver framework for the TMFIFO of Mellanox BlueField SoC and + the implementation of a console and network driver. + +endif # ARCH_MLNX_BLUEFIELD diff --git a/drivers/soc/mellanox/Makefile b/drivers/soc/mellanox/Makefile new file mode 100644 index 0000000..c44c0e2 --- /dev/null +++ b/drivers/soc/mellanox/Makefile @@ -0,0 +1,5 @@ +# SPDX-License-Identifier: GPL-2.0 +# +# Makefile for Mellanox SoC drivers. +# +obj-$(CONFIG_MLNX_BLUEFIELD_TMFIFO) += tmfifo.o diff --git a/drivers/soc/mellanox/tmfifo.c b/drivers/soc/mellanox/tmfifo.c new file mode 100644 index 0000000..5647cb6 --- /dev/null +++ b/drivers/soc/mellanox/tmfifo.c @@ -0,0 +1,1239 @@ +/* + * Copyright (c) 2018, Mellanox Technologies. All rights reserved. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 and + * only version 2 as published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "tmfifo_regs.h" + +#define TMFIFO_GET_FIELD(reg, mask) FIELD_GET(mask, reg) + +#define TMFIFO_SET_FIELD(reg, mask, value) \ + ((reg & ~mask) | FIELD_PREP(mask, value)) + +/* Vring size. */ +#define TMFIFO_VRING_SIZE 1024 + +/* Console Tx buffer size. */ +#define TMFIFO_CONS_TX_BUF_SIZE (32 * 1024) + +/* Use a timer for house-keeping. */ +static int tmfifo_timer_interval = HZ / 10; + +/* Global lock. */ +static struct mutex tmfifo_lock; + +/* Virtio ring size. */ +static int tmfifo_vring_size = TMFIFO_VRING_SIZE; +module_param(tmfifo_vring_size, int, 0444); +MODULE_PARM_DESC(tmfifo_vring_size, "Size of the vring."); + +struct tmfifo; + +/* A flag to indicate TmFifo ready. */ +static bool tmfifo_ready; + +/* Virtual devices sharing the TM FIFO. */ +#define TMFIFO_VDEV_MAX (VIRTIO_ID_CONSOLE + 1) + +/* Spin lock. */ +static DEFINE_SPINLOCK(tmfifo_spin_lock); + +/* Structure to maintain the ring state. */ +struct tmfifo_vring { + void *va; /* virtual address */ + dma_addr_t dma; /* dma address */ + struct virtqueue *vq; /* virtqueue pointer */ + struct vring_desc *desc; /* current desc */ + struct vring_desc *desc_head; /* current desc head */ + int cur_len; /* processed len in current desc */ + int rem_len; /* remaining length to be processed */ + int size; /* vring size */ + int align; /* vring alignment */ + int id; /* vring id */ + int vdev_id; /* TMFIFO_VDEV_xxx */ + u32 pkt_len; /* packet total length */ + __virtio16 next_avail; /* next avail desc id */ + struct tmfifo *fifo; /* pointer back to the tmfifo */ +}; + +/* Interrupt types. */ +enum { + TM_RX_LWM_IRQ, /* Rx low water mark irq */ + TM_RX_HWM_IRQ, /* Rx high water mark irq */ + TM_TX_LWM_IRQ, /* Tx low water mark irq */ + TM_TX_HWM_IRQ, /* Tx high water mark irq */ + TM_IRQ_CNT +}; + +/* Ring types (Rx & Tx). */ +enum { + TMFIFO_VRING_RX, /* Rx ring */ + TMFIFO_VRING_TX, /* Tx ring */ + TMFIFO_VRING_NUM +}; + +struct tmfifo_vdev { + struct virtio_device vdev; /* virtual device */ + u8 status; + u64 features; + union { /* virtio config space */ + struct virtio_console_config cons; + struct virtio_net_config net; + } config; + struct tmfifo_vring vrings[TMFIFO_VRING_NUM]; + u8 *tx_buf; /* tx buffer */ + u32 tx_head; /* tx buffer head */ + u32 tx_tail; /* tx buffer tail */ +}; + +#define TMFIFO_VDEV_TX_BUF_AVAIL(vdev) \ + (((vdev)->tx_tail >= (vdev)->tx_head) ? \ + (TMFIFO_CONS_TX_BUF_SIZE - 8 - ((vdev)->tx_tail - (vdev)->tx_head)) : \ + ((vdev)->tx_head - (vdev)->tx_tail - 8)) + +#define TMFIFO_VDEV_TX_BUF_PUSH(vdev, len) do { \ + (vdev)->tx_tail += (len); \ + if ((vdev)->tx_tail >= TMFIFO_CONS_TX_BUF_SIZE) \ + (vdev)->tx_tail -= TMFIFO_CONS_TX_BUF_SIZE; \ +} while (0) + +#define TMFIFO_VDEV_TX_BUF_POP(vdev, len) do { \ + (vdev)->tx_head += (len); \ + if ((vdev)->tx_head >= TMFIFO_CONS_TX_BUF_SIZE) \ + (vdev)->tx_head -= TMFIFO_CONS_TX_BUF_SIZE; \ +} while (0) + +/* TMFIFO device structure */ +struct tmfifo { + struct tmfifo_vdev *vdev[TMFIFO_VDEV_MAX]; /* virtual devices */ + struct platform_device *pdev; /* platform device */ + struct mutex lock; + void __iomem *rx_base; /* mapped register base */ + void __iomem *tx_base; /* mapped register base */ + int tx_fifo_size; /* number of entries of the Tx FIFO */ + int rx_fifo_size; /* number of entries of the Rx FIFO */ + unsigned long pend_events; /* pending bits for deferred process */ + int irq[TM_IRQ_CNT]; /* irq numbers */ + struct work_struct work; /* work struct for deferred process */ + struct timer_list timer; /* keepalive timer */ + struct tmfifo_vring *vring[2]; /* current Tx/Rx ring */ +}; + +union tmfifo_msg_hdr { + struct { + u8 type; /* message type */ + __be16 len; /* payload length */ + u8 unused[5]; /* reserved, set to 0 */ + } __packed; + u64 data; +}; + +/* + * Default MAC. + * This MAC address will be read from EFI persistent variable if configured. + * It can also be reconfigured with standard Linux tools. + */ +static u8 tmfifo_net_default_mac[6] = {0x00, 0x1A, 0xCA, 0xFF, 0xFF, 0x01}; + +/* MTU setting of the virtio-net interface. */ +#define TMFIFO_NET_MTU 1500 + +/* Supported virtio-net features. */ +#define TMFIFO_NET_FEATURES ((1UL << VIRTIO_NET_F_MTU) | \ + (1UL << VIRTIO_NET_F_STATUS) | \ + (1UL << VIRTIO_NET_F_MAC)) + +/* Forward declaration. */ +static void tmfifo_virtio_rxtx(struct virtqueue *vq, bool is_rx); +static void tmfifo_release_pkt(struct virtio_device *vdev, + struct tmfifo_vring *vring, + struct vring_desc **desc); + +/* Allocate vrings for the fifo. */ +static int tmfifo_alloc_vrings(struct tmfifo *fifo, + struct tmfifo_vdev *tm_vdev, int vdev_id) +{ + dma_addr_t dma; + void *va; + int i, size; + struct tmfifo_vring *vring; + + for (i = 0; i < ARRAY_SIZE(tm_vdev->vrings); i++) { + vring = &tm_vdev->vrings[i]; + vring->fifo = fifo; + vring->size = tmfifo_vring_size; + vring->align = SMP_CACHE_BYTES; + vring->id = i; + vring->vdev_id = vdev_id; + + size = PAGE_ALIGN(vring_size(vring->size, vring->align)); + va = dma_alloc_coherent(tm_vdev->vdev.dev.parent, size, &dma, + GFP_KERNEL); + if (!va) { + dev_err(tm_vdev->vdev.dev.parent, + "vring allocation failed\n"); + return -EINVAL; + } + + vring->va = va; + vring->dma = dma; + } + + return 0; +} + +/* Free vrings of the fifo device. */ +static void tmfifo_free_vrings(struct tmfifo *fifo, int vdev_id) +{ + int i, size; + struct tmfifo_vring *vring; + struct tmfifo_vdev *tm_vdev = fifo->vdev[vdev_id]; + + for (i = 0; i < ARRAY_SIZE(tm_vdev->vrings); i++) { + vring = &tm_vdev->vrings[i]; + + size = PAGE_ALIGN(vring_size(vring->size, vring->align)); + if (vring->va) { + dma_free_coherent(tm_vdev->vdev.dev.parent, size, + vring->va, vring->dma); + vring->va = NULL; + if (vring->vq) { + vring_del_virtqueue(vring->vq); + vring->vq = NULL; + } + } + } +} + +/* Free interrupts of the fifo device. */ +static void tmfifo_free_irqs(struct tmfifo *fifo) +{ + int i, irq; + + for (i = 0; i < TM_IRQ_CNT; i++) { + irq = fifo->irq[i]; + if (irq) { + fifo->irq[i] = 0; + disable_irq(irq); + free_irq(irq, (u8 *)fifo + i); + } + } +} + +/* Work handler for Rx, Tx or activity monitoring. */ +static void tmfifo_work_handler(struct work_struct *work) +{ + int i; + struct tmfifo_vdev *tm_vdev; + struct tmfifo *fifo = container_of(work, struct tmfifo, work); + + if (!tmfifo_ready) + return; + + mutex_lock(&fifo->lock); + + /* Tx. */ + if (test_and_clear_bit(TM_TX_LWM_IRQ, &fifo->pend_events) && + fifo->irq[TM_TX_LWM_IRQ]) { + for (i = 0; i < TMFIFO_VDEV_MAX; i++) { + tm_vdev = fifo->vdev[i]; + if (tm_vdev != NULL) { + tmfifo_virtio_rxtx( + tm_vdev->vrings[TMFIFO_VRING_TX].vq, + false); + } + } + } + + /* Rx. */ + if (test_and_clear_bit(TM_RX_HWM_IRQ, &fifo->pend_events) && + fifo->irq[TM_RX_HWM_IRQ]) { + for (i = 0; i < TMFIFO_VDEV_MAX; i++) { + tm_vdev = fifo->vdev[i]; + if (tm_vdev != NULL) { + tmfifo_virtio_rxtx( + tm_vdev->vrings[TMFIFO_VRING_RX].vq, + true); + } + } + } + + mutex_unlock(&fifo->lock); +} + +/* Interrupt handler. */ +static irqreturn_t tmfifo_irq_handler(int irq, void *dev_id) +{ + int i = (uintptr_t)dev_id % sizeof(void *); + struct tmfifo *fifo = dev_id - i; + + if (i < TM_IRQ_CNT && !test_and_set_bit(i, &fifo->pend_events)) + schedule_work(&fifo->work); + + return IRQ_HANDLED; +} + +/* Nothing to do for now. */ +static void tmfifo_virtio_dev_release(struct device *dev) +{ +} + +/* Get the next packet descriptor from the vring. */ +static inline struct vring_desc * +tmfifo_virtio_get_next_desc(struct virtqueue *vq) +{ + unsigned int idx, head; + struct vring *vr = (struct vring *)virtqueue_get_vring(vq); + struct tmfifo_vring *vring = (struct tmfifo_vring *)vq->priv; + + if (!vr || vring->next_avail == vr->avail->idx) + return NULL; + + idx = vring->next_avail % vr->num; + head = vr->avail->ring[idx]; + BUG_ON(head >= vr->num); + vring->next_avail++; + return &vr->desc[head]; +} + +static inline void tmfifo_virtio_release_desc(struct virtio_device *vdev, + struct vring *vr, + struct vring_desc *desc, u32 len) +{ + unsigned int idx; + + idx = vr->used->idx % vr->num; + vr->used->ring[idx].id = desc - vr->desc; + vr->used->ring[idx].len = cpu_to_virtio32(vdev, len); + + /* Virtio could poll and check the 'idx' to decide + * whether the desc is done or not. Add a memory + * barrier here to make sure the update above completes + * before updating the idx. + */ + mb(); + vr->used->idx++; +} + +/* Get the total length of a descriptor chain. */ +static inline u32 tmfifo_virtio_get_pkt_len(struct virtio_device *vdev, + struct vring_desc *desc, struct vring *vr) +{ + u32 len = 0, idx; + + while (desc) { + len += virtio32_to_cpu(vdev, desc->len); + if (!(virtio16_to_cpu(vdev, desc->flags) & VRING_DESC_F_NEXT)) + break; + idx = virtio16_to_cpu(vdev, desc->next); + desc = &vr->desc[idx]; + } + + return len; +} + +static void tmfifo_release_pkt(struct virtio_device *vdev, + struct tmfifo_vring *vring, + struct vring_desc **desc) +{ + struct vring *vr = (struct vring *)virtqueue_get_vring(vring->vq); + struct vring_desc *desc_head; + uint32_t pkt_len = 0; + + if (!vr) + return; + + if (desc != NULL && *desc != NULL && vring->desc_head != NULL) { + desc_head = vring->desc_head; + pkt_len = vring->pkt_len; + } else { + desc_head = tmfifo_virtio_get_next_desc(vring->vq); + if (desc_head != NULL) { + pkt_len = tmfifo_virtio_get_pkt_len(vdev, + desc_head, vr); + } + } + + if (desc_head != NULL) + tmfifo_virtio_release_desc(vdev, vr, desc_head, pkt_len); + + if (desc != NULL) + *desc = NULL; + vring->pkt_len = 0; +} + +/* House-keeping timer. */ +static void tmfifo_timer(struct timer_list *arg) +{ + struct tmfifo *fifo = container_of(arg, struct tmfifo, timer); + + /* + * Wake up the work handler to poll the Rx FIFO in case interrupt + * missing or any leftover bytes stuck in the FIFO. + */ + test_and_set_bit(TM_RX_HWM_IRQ, &fifo->pend_events); + + /* + * Wake up Tx handler in case virtio has queued too many packets + * and are waiting for buffer return. + */ + test_and_set_bit(TM_TX_LWM_IRQ, &fifo->pend_events); + + schedule_work(&fifo->work); + + mod_timer(&fifo->timer, jiffies + tmfifo_timer_interval); +} + +/* Buffer the console output. */ +static void tmfifo_console_output(struct tmfifo_vdev *cons, + struct virtqueue *vq) +{ + u32 len, pkt_len, idx; + struct vring_desc *head_desc, *desc = NULL; + struct vring *vr = (struct vring *)virtqueue_get_vring(vq); + struct virtio_device *vdev = &cons->vdev; + void *addr; + union tmfifo_msg_hdr *hdr; + + for (;;) { + head_desc = tmfifo_virtio_get_next_desc(vq); + if (head_desc == NULL) + break; + + /* Release the packet if no more space. */ + pkt_len = tmfifo_virtio_get_pkt_len(vdev, head_desc, vr); + if (pkt_len + sizeof(*hdr) > TMFIFO_VDEV_TX_BUF_AVAIL(cons)) { + tmfifo_virtio_release_desc(vdev, vr, head_desc, + pkt_len); + break; + } + + hdr = (union tmfifo_msg_hdr *)&cons->tx_buf[cons->tx_tail]; + hdr->data = 0; + hdr->type = VIRTIO_ID_CONSOLE; + hdr->len = htons(pkt_len); + + TMFIFO_VDEV_TX_BUF_PUSH(cons, sizeof(*hdr)); + desc = head_desc; + + while (desc != NULL) { + addr = phys_to_virt(virtio64_to_cpu(vdev, desc->addr)); + len = virtio32_to_cpu(vdev, desc->len); + + if (len <= TMFIFO_CONS_TX_BUF_SIZE - cons->tx_tail) { + memcpy(cons->tx_buf + cons->tx_tail, addr, len); + } else { + u32 seg; + + seg = TMFIFO_CONS_TX_BUF_SIZE - cons->tx_tail; + memcpy(cons->tx_buf + cons->tx_tail, addr, seg); + addr += seg; + memcpy(cons->tx_buf, addr, len - seg); + } + TMFIFO_VDEV_TX_BUF_PUSH(cons, len); + + if (!(virtio16_to_cpu(vdev, desc->flags) & + VRING_DESC_F_NEXT)) + break; + idx = virtio16_to_cpu(vdev, desc->next); + desc = &vr->desc[idx]; + } + + /* Make each packet 8-byte aligned. */ + TMFIFO_VDEV_TX_BUF_PUSH(cons, ((pkt_len + 7) & -8) - pkt_len); + + tmfifo_virtio_release_desc(vdev, vr, head_desc, pkt_len); + } +} + +/* Rx & Tx processing of a virtual queue. */ +static void tmfifo_virtio_rxtx(struct virtqueue *vq, bool is_rx) +{ + struct tmfifo_vring *vring; + struct tmfifo *fifo; + struct vring *vr; + struct virtio_device *vdev; + u64 sts, data; + int num_avail = 0, hdr_len, tx_reserve; + void *addr; + u32 len, idx; + struct vring_desc *desc; + unsigned long flags; + struct tmfifo_vdev *cons; + + if (!vq) + return; + + vring = (struct tmfifo_vring *)vq->priv; + fifo = vring->fifo; + vr = (struct vring *)virtqueue_get_vring(vq); + + if (!fifo->vdev[vring->vdev_id]) + return; + vdev = &fifo->vdev[vring->vdev_id]->vdev; + cons = fifo->vdev[VIRTIO_ID_CONSOLE]; + + /* Don't continue if another vring is running. */ + if (fifo->vring[is_rx] != NULL && fifo->vring[is_rx] != vring) + return; + + /* tx_reserve is used to reserved some room in FIFO for console. */ + if (vring->vdev_id == VIRTIO_ID_NET) { + hdr_len = sizeof(struct virtio_net_hdr); + tx_reserve = fifo->tx_fifo_size / 16; + } else { + BUG_ON(vring->vdev_id != VIRTIO_ID_CONSOLE); + hdr_len = 0; + tx_reserve = 1; + } + + desc = vring->desc; + +again: + while (1) { + /* Get available FIFO space. */ + if (num_avail == 0) { + if (is_rx) { + /* Get the number of available words in FIFO. */ + sts = readq(fifo->rx_base + TMFIFO_RX_STS); + num_avail = TMFIFO_GET_FIELD(sts, + TMFIFO_RX_STS__COUNT_MASK); + + /* Don't continue if nothing in FIFO. */ + if (num_avail <= 0) + break; + } else { + /* Get available space in FIFO. */ + sts = readq(fifo->tx_base + TMFIFO_TX_STS); + num_avail = fifo->tx_fifo_size - tx_reserve - + TMFIFO_GET_FIELD(sts, + TMFIFO_TX_STS__COUNT_MASK); + + if (num_avail <= 0) + break; + } + } + + /* Console output always comes from the Tx buffer. */ + if (!is_rx && vring->vdev_id == VIRTIO_ID_CONSOLE && + cons != NULL && cons->tx_buf != NULL) { + for (;;) { + spin_lock_irqsave(&tmfifo_spin_lock, flags); + if (cons->tx_head == cons->tx_tail) { + spin_unlock_irqrestore( + &tmfifo_spin_lock, flags); + return; + } + addr = cons->tx_buf + cons->tx_head; + writeq(cpu_to_le64(*(u64 *)addr), + fifo->tx_base + TMFIFO_TX_DATA); + TMFIFO_VDEV_TX_BUF_POP(cons, sizeof(u64)); + spin_unlock_irqrestore(&tmfifo_spin_lock, + flags); + if (--num_avail <= 0) + goto again; + } + } + + /* Get the desc of next packet. */ + if (!desc) { + /* Save the head desc of the chain. */ + vring->desc_head = tmfifo_virtio_get_next_desc(vq); + if (!vring->desc_head) { + vring->desc = NULL; + return; + } + desc = vring->desc_head; + vring->desc = desc; + + if (is_rx && vring->vdev_id == VIRTIO_ID_NET) { + struct virtio_net_hdr *net_hdr; + + /* Initialize the packet header. */ + net_hdr = (struct virtio_net_hdr *) + phys_to_virt(virtio64_to_cpu( + vdev, desc->addr)); + memset(net_hdr, 0, sizeof(*net_hdr)); + } + } + + /* Beginning of each packet. */ + if (vring->pkt_len == 0) { + int vdev_id, vring_change = 0; + union tmfifo_msg_hdr hdr; + + num_avail--; + + /* Read/Write packet length. */ + if (is_rx) { + hdr.data = readq(fifo->rx_base + + TMFIFO_RX_DATA); + hdr.data = le64_to_cpu(hdr.data); + + /* Skip the length 0 packet (keepalive). */ + if (hdr.len == 0) + continue; + + /* Check packet type. */ + if (hdr.type == VIRTIO_ID_NET) { + vdev_id = VIRTIO_ID_NET; + hdr_len = sizeof(struct virtio_net_hdr); + } else if (hdr.type == VIRTIO_ID_CONSOLE) { + vdev_id = VIRTIO_ID_CONSOLE; + hdr_len = 0; + } else { + continue; + } + + /* + * Check whether the new packet still belongs + * to this vring or not. If not, update the + * pkt_len of the new vring and return. + */ + if (vdev_id != vring->vdev_id) { + struct tmfifo_vdev *dev2 = + fifo->vdev[vdev_id]; + + if (!dev2) + break; + vring->desc = desc; + vring = &dev2->vrings[TMFIFO_VRING_RX]; + vring_change = 1; + } + vring->pkt_len = ntohs(hdr.len) + hdr_len; + } else { + vring->pkt_len = tmfifo_virtio_get_pkt_len( + vdev, desc, vr); + + hdr.data = 0; + hdr.type = (vring->vdev_id == VIRTIO_ID_NET) ? + VIRTIO_ID_NET : + VIRTIO_ID_CONSOLE; + hdr.len = htons(vring->pkt_len - hdr_len); + writeq(cpu_to_le64(hdr.data), + fifo->tx_base + TMFIFO_TX_DATA); + } + + vring->cur_len = hdr_len; + vring->rem_len = vring->pkt_len; + fifo->vring[is_rx] = vring; + + if (vring_change) + return; + continue; + } + + /* Check available space in this desc. */ + len = virtio32_to_cpu(vdev, desc->len); + if (len > vring->rem_len) + len = vring->rem_len; + + /* Check if the current desc is already done. */ + if (vring->cur_len == len) + goto check_done; + + addr = phys_to_virt(virtio64_to_cpu(vdev, desc->addr)); + + /* Read a word from FIFO for Rx. */ + if (is_rx) { + data = readq(fifo->rx_base + TMFIFO_RX_DATA); + data = le64_to_cpu(data); + } + + if (vring->cur_len + sizeof(u64) <= len) { + /* The whole word. */ + if (is_rx) { + memcpy(addr + vring->cur_len, &data, + sizeof(u64)); + } else { + memcpy(&data, addr + vring->cur_len, + sizeof(u64)); + } + vring->cur_len += sizeof(u64); + } else { + /* Leftover bytes. */ + BUG_ON(vring->cur_len > len); + if (is_rx) { + memcpy(addr + vring->cur_len, &data, + len - vring->cur_len); + } else { + memcpy(&data, addr + vring->cur_len, + len - vring->cur_len); + } + vring->cur_len = len; + } + + /* Write the word into FIFO for Tx. */ + if (!is_rx) { + writeq(cpu_to_le64(data), + fifo->tx_base + TMFIFO_TX_DATA); + } + + num_avail--; + +check_done: + /* Check whether this desc is full or completed. */ + if (vring->cur_len == len) { + vring->cur_len = 0; + vring->rem_len -= len; + + /* Get the next desc on the chain. */ + if (vring->rem_len > 0 && + (virtio16_to_cpu(vdev, desc->flags) & + VRING_DESC_F_NEXT)) { + idx = virtio16_to_cpu(vdev, desc->next); + desc = &vr->desc[idx]; + continue; + } + + /* Done and release the desc. */ + tmfifo_release_pkt(vdev, vring, &desc); + fifo->vring[is_rx] = NULL; + + /* Notify upper layer that packet is done. */ + spin_lock_irqsave(&tmfifo_spin_lock, flags); + vring_interrupt(0, vq); + spin_unlock_irqrestore(&tmfifo_spin_lock, flags); + continue; + } + } + + /* Save the current desc. */ + vring->desc = desc; +} + +/* The notify function is called when new buffers are posted. */ +static bool tmfifo_virtio_notify(struct virtqueue *vq) +{ + struct tmfifo_vring *vring = (struct tmfifo_vring *)vq->priv; + struct tmfifo *fifo = vring->fifo; + unsigned long flags; + + /* + * Virtio maintains vrings in pairs, even number ring for Rx + * and odd number ring for Tx. + */ + if (!(vring->id & 1)) { + /* Set the RX HWM bit to start Rx. */ + if (!test_and_set_bit(TM_RX_HWM_IRQ, &fifo->pend_events)) + schedule_work(&fifo->work); + } else { + /* + * Console could make blocking call with interrupts disabled. + * In such case, the vring needs to be served right away. For + * other cases, just set the TX LWM bit to start Tx in the + * worker handler. + */ + if (vring->vdev_id == VIRTIO_ID_CONSOLE) { + spin_lock_irqsave(&tmfifo_spin_lock, flags); + tmfifo_console_output(fifo->vdev[VIRTIO_ID_CONSOLE], + vq); + spin_unlock_irqrestore(&tmfifo_spin_lock, flags); + schedule_work(&fifo->work); + } else if (!test_and_set_bit(TM_TX_LWM_IRQ, &fifo->pend_events)) + schedule_work(&fifo->work); + } + + return true; +} + +/* Get the array of feature bits for this device. */ +static u64 tmfifo_virtio_get_features(struct virtio_device *vdev) +{ + struct tmfifo_vdev *tm_vdev = container_of(vdev, struct tmfifo_vdev, + vdev); + + return tm_vdev->features; +} + +/* Confirm device features to use. */ +static int tmfifo_virtio_finalize_features(struct virtio_device *vdev) +{ + struct tmfifo_vdev *tm_vdev = container_of(vdev, struct tmfifo_vdev, + vdev); + + tm_vdev->features = vdev->features; + return 0; +} + +/* Free virtqueues found by find_vqs(). */ +static void tmfifo_virtio_del_vqs(struct virtio_device *vdev) +{ + int i; + struct tmfifo_vring *vring; + struct virtqueue *vq; + struct tmfifo_vdev *tm_vdev = container_of(vdev, struct tmfifo_vdev, + vdev); + + for (i = 0; i < ARRAY_SIZE(tm_vdev->vrings); i++) { + vring = &tm_vdev->vrings[i]; + + /* Release the pending packet. */ + if (vring->desc != NULL) + tmfifo_release_pkt(&tm_vdev->vdev, vring, &vring->desc); + + vq = vring->vq; + if (vq) { + vring->vq = NULL; + vring_del_virtqueue(vq); + } + } +} + +/* Create and initialize the virtual queues. */ +static int tmfifo_virtio_find_vqs(struct virtio_device *vdev, + unsigned int nvqs, + struct virtqueue *vqs[], + vq_callback_t *callbacks[], + const char * const names[], + const bool *ctx, + struct irq_affinity *desc) +{ + int i, ret = -EINVAL, size; + struct tmfifo_vring *vring; + struct virtqueue *vq; + struct tmfifo_vdev *tm_vdev = container_of(vdev, struct tmfifo_vdev, + vdev); + + if (nvqs > ARRAY_SIZE(tm_vdev->vrings)) + return -EINVAL; + + for (i = 0; i < nvqs; ++i) { + if (!names[i]) + goto error; + vring = &tm_vdev->vrings[i]; + + /* zero vring */ + size = vring_size(vring->size, vring->align); + memset(vring->va, 0, size); + vq = vring_new_virtqueue(i, vring->size, vring->align, vdev, + false, false, vring->va, + tmfifo_virtio_notify, + callbacks[i], names[i]); + if (!vq) { + dev_err(&vdev->dev, "vring_new_virtqueue failed\n"); + ret = -ENOMEM; + goto error; + } + + vqs[i] = vq; + vring->vq = vq; + vq->priv = vring; + } + + return 0; + +error: + tmfifo_virtio_del_vqs(vdev); + return ret; +} + +/* Read the status byte. */ +static u8 tmfifo_virtio_get_status(struct virtio_device *vdev) +{ + struct tmfifo_vdev *tm_vdev = container_of(vdev, struct tmfifo_vdev, + vdev); + + return tm_vdev->status; +} + +/* Write the status byte. */ +static void tmfifo_virtio_set_status(struct virtio_device *vdev, u8 status) +{ + struct tmfifo_vdev *tm_vdev = container_of(vdev, struct tmfifo_vdev, + vdev); + + tm_vdev->status = status; +} + +/* Reset the device. Not much here for now. */ +static void tmfifo_virtio_reset(struct virtio_device *vdev) +{ + struct tmfifo_vdev *tm_vdev = container_of(vdev, struct tmfifo_vdev, + vdev); + + tm_vdev->status = 0; +} + +/* Read the value of a configuration field. */ +static void tmfifo_virtio_get(struct virtio_device *vdev, + unsigned int offset, + void *buf, + unsigned int len) +{ + struct tmfifo_vdev *tm_vdev = container_of(vdev, struct tmfifo_vdev, + vdev); + + if (offset + len > sizeof(tm_vdev->config) || offset + len < len) { + dev_err(vdev->dev.parent, "virtio_get access out of bounds\n"); + return; + } + + memcpy(buf, (u8 *)&tm_vdev->config + offset, len); +} + +/* Write the value of a configuration field. */ +static void tmfifo_virtio_set(struct virtio_device *vdev, + unsigned int offset, + const void *buf, + unsigned int len) +{ + struct tmfifo_vdev *tm_vdev = container_of(vdev, struct tmfifo_vdev, + vdev); + + if (offset + len > sizeof(tm_vdev->config) || offset + len < len) { + dev_err(vdev->dev.parent, "virtio_get access out of bounds\n"); + return; + } + + memcpy((u8 *)&tm_vdev->config + offset, buf, len); +} + +/* Virtio config operations. */ +static const struct virtio_config_ops tmfifo_virtio_config_ops = { + .get_features = tmfifo_virtio_get_features, + .finalize_features = tmfifo_virtio_finalize_features, + .find_vqs = tmfifo_virtio_find_vqs, + .del_vqs = tmfifo_virtio_del_vqs, + .reset = tmfifo_virtio_reset, + .set_status = tmfifo_virtio_set_status, + .get_status = tmfifo_virtio_get_status, + .get = tmfifo_virtio_get, + .set = tmfifo_virtio_set, +}; + +/* Create vdev type in a tmfifo. */ +int tmfifo_create_vdev(struct tmfifo *fifo, int vdev_id, u64 features, + void *config, u32 size) +{ + struct tmfifo_vdev *tm_vdev; + int ret = 0; + + mutex_lock(&fifo->lock); + + tm_vdev = fifo->vdev[vdev_id]; + if (tm_vdev != NULL) { + pr_err("vdev %d already exists\n", vdev_id); + ret = -EEXIST; + goto already_exist; + } + + tm_vdev = kzalloc(sizeof(*tm_vdev), GFP_KERNEL); + if (!tm_vdev) { + ret = -ENOMEM; + goto already_exist; + } + + tm_vdev->vdev.id.device = vdev_id; + tm_vdev->vdev.config = &tmfifo_virtio_config_ops; + tm_vdev->vdev.dev.parent = &fifo->pdev->dev; + tm_vdev->vdev.dev.release = tmfifo_virtio_dev_release; + tm_vdev->features = features; + if (config) + memcpy(&tm_vdev->config, config, size); + if (tmfifo_alloc_vrings(fifo, tm_vdev, vdev_id)) { + pr_err("Unable to allocate vring\n"); + ret = -ENOMEM; + goto alloc_vring_fail; + } + if (vdev_id == VIRTIO_ID_CONSOLE) { + tm_vdev->tx_buf = kmalloc(TMFIFO_CONS_TX_BUF_SIZE, + GFP_KERNEL); + } + fifo->vdev[vdev_id] = tm_vdev; + + /* Register the virtio device. */ + ret = register_virtio_device(&tm_vdev->vdev); + if (ret) { + dev_err(&fifo->pdev->dev, "register_virtio_device() failed\n"); + goto register_fail; + } + + mutex_unlock(&fifo->lock); + return 0; + +register_fail: + tmfifo_free_vrings(fifo, vdev_id); + fifo->vdev[vdev_id] = NULL; +alloc_vring_fail: + kfree(tm_vdev); +already_exist: + mutex_unlock(&fifo->lock); + return ret; +} + +/* Delete vdev type from a tmfifo. */ +int tmfifo_delete_vdev(struct tmfifo *fifo, int vdev_id) +{ + struct tmfifo_vdev *tm_vdev; + + mutex_lock(&fifo->lock); + + /* Unregister vdev. */ + tm_vdev = fifo->vdev[vdev_id]; + if (tm_vdev) { + unregister_virtio_device(&tm_vdev->vdev); + tmfifo_free_vrings(fifo, vdev_id); + kfree(tm_vdev->tx_buf); + kfree(tm_vdev); + fifo->vdev[vdev_id] = NULL; + } + + mutex_unlock(&fifo->lock); + + return 0; +} + +/* Device remove function. */ +static int tmfifo_remove(struct platform_device *pdev) +{ + int i; + struct tmfifo *fifo = platform_get_drvdata(pdev); + struct resource *rx_res, *tx_res; + + tmfifo_ready = false; + + if (fifo) { + mutex_lock(&tmfifo_lock); + + /* Stop the timer. */ + del_timer_sync(&fifo->timer); + + /* Release interrupts. */ + tmfifo_free_irqs(fifo); + + /* Cancel the pending work. */ + cancel_work_sync(&fifo->work); + + for (i = 0; i < TMFIFO_VDEV_MAX; i++) + tmfifo_delete_vdev(fifo, i); + + /* Release IO resources. */ + if (fifo->rx_base) + iounmap(fifo->rx_base); + if (fifo->tx_base) + iounmap(fifo->tx_base); + + platform_set_drvdata(pdev, NULL); + kfree(fifo); + + mutex_unlock(&tmfifo_lock); + } + + rx_res = platform_get_resource(pdev, IORESOURCE_MEM, 0); + if (rx_res) + release_mem_region(rx_res->start, resource_size(rx_res)); + tx_res = platform_get_resource(pdev, IORESOURCE_MEM, 1); + if (tx_res) + release_mem_region(tx_res->start, resource_size(tx_res)); + + return 0; +} + +/* Read the configured network MAC address from efi variable. */ +static void tmfifo_get_cfg_mac(u8 *mac) +{ + u8 buf[6]; + efi_status_t status; + unsigned long size = sizeof(buf); + efi_char16_t name[] = { 'R', 's', 'h', 'i', 'm', 'M', 'a', 'c', + 'A', 'd', 'd', 'r', 0 }; + efi_guid_t guid = EFI_GLOBAL_VARIABLE_GUID; + + status = efi.get_variable(name, &guid, NULL, &size, buf); + if (status == EFI_SUCCESS && size == sizeof(buf)) + memcpy(mac, buf, sizeof(buf)); +} + +/* Probe the TMFIFO. */ +static int tmfifo_probe(struct platform_device *pdev) +{ + u64 ctl; + struct tmfifo *fifo; + struct resource *rx_res, *tx_res; + struct virtio_net_config net_config; + int i, ret; + + /* Get the resource of the Rx & Tx FIFO. */ + rx_res = platform_get_resource(pdev, IORESOURCE_MEM, 0); + tx_res = platform_get_resource(pdev, IORESOURCE_MEM, 1); + if (!rx_res || !tx_res) { + ret = -EINVAL; + goto err; + } + + if (request_mem_region(rx_res->start, + resource_size(rx_res), "bf-tmfifo") == NULL) { + ret = -EBUSY; + goto early_err; + } + + if (request_mem_region(tx_res->start, + resource_size(tx_res), "bf-tmfifo") == NULL) { + release_mem_region(rx_res->start, resource_size(rx_res)); + ret = -EBUSY; + goto early_err; + } + + ret = -ENOMEM; + fifo = kzalloc(sizeof(struct tmfifo), GFP_KERNEL); + if (!fifo) + goto err; + + fifo->pdev = pdev; + platform_set_drvdata(pdev, fifo); + + INIT_WORK(&fifo->work, tmfifo_work_handler); + + timer_setup(&fifo->timer, tmfifo_timer, 0); + fifo->timer.function = tmfifo_timer; + + for (i = 0; i < TM_IRQ_CNT; i++) { + fifo->irq[i] = platform_get_irq(pdev, i); + ret = request_irq(fifo->irq[i], tmfifo_irq_handler, 0, + "tmfifo", (u8 *)fifo + i); + if (ret) { + pr_err("Unable to request irq\n"); + fifo->irq[i] = 0; + goto err; + } + } + + fifo->rx_base = ioremap(rx_res->start, resource_size(rx_res)); + if (!fifo->rx_base) + goto err; + + fifo->tx_base = ioremap(tx_res->start, resource_size(tx_res)); + if (!fifo->tx_base) + goto err; + + /* Get Tx FIFO size and set the low/high watermark. */ + ctl = readq(fifo->tx_base + TMFIFO_TX_CTL); + fifo->tx_fifo_size = + TMFIFO_GET_FIELD(ctl, TMFIFO_TX_CTL__MAX_ENTRIES_MASK); + ctl = TMFIFO_SET_FIELD(ctl, TMFIFO_TX_CTL__LWM_MASK, + fifo->tx_fifo_size / 2); + ctl = TMFIFO_SET_FIELD(ctl, TMFIFO_TX_CTL__HWM_MASK, + fifo->tx_fifo_size - 1); + writeq(ctl, fifo->tx_base + TMFIFO_TX_CTL); + + /* Get Rx FIFO size and set the low/high watermark. */ + ctl = readq(fifo->rx_base + TMFIFO_RX_CTL); + fifo->rx_fifo_size = + TMFIFO_GET_FIELD(ctl, TMFIFO_RX_CTL__MAX_ENTRIES_MASK); + ctl = TMFIFO_SET_FIELD(ctl, TMFIFO_RX_CTL__LWM_MASK, 0); + ctl = TMFIFO_SET_FIELD(ctl, TMFIFO_RX_CTL__HWM_MASK, 1); + writeq(ctl, fifo->rx_base + TMFIFO_RX_CTL); + + mutex_init(&fifo->lock); + + /* Create the console vdev. */ + ret = tmfifo_create_vdev(fifo, VIRTIO_ID_CONSOLE, 0, NULL, 0); + if (ret) + goto err; + + /* Create the network vdev. */ + memset(&net_config, 0, sizeof(net_config)); + net_config.mtu = TMFIFO_NET_MTU; + net_config.status = VIRTIO_NET_S_LINK_UP; + memcpy(net_config.mac, tmfifo_net_default_mac, 6); + tmfifo_get_cfg_mac(net_config.mac); + ret = tmfifo_create_vdev(fifo, VIRTIO_ID_NET, TMFIFO_NET_FEATURES, + &net_config, sizeof(net_config)); + if (ret) + goto err; + + mod_timer(&fifo->timer, jiffies + tmfifo_timer_interval); + + tmfifo_ready = true; + + return 0; + +err: + tmfifo_remove(pdev); +early_err: + dev_err(&pdev->dev, "Probe Failed\n"); + return ret; +} + +static const struct of_device_id tmfifo_match[] = { + { .compatible = "mellanox,bf-tmfifo" }, + {}, +}; +MODULE_DEVICE_TABLE(of, tmfifo_match); + +static const struct acpi_device_id bf_tmfifo_acpi_match[] = { + { "MLNXBF01", 0 }, + {}, +}; +MODULE_DEVICE_TABLE(acpi, bf_tmfifo_acpi_match); + +static struct platform_driver tmfifo_driver = { + .probe = tmfifo_probe, + .remove = tmfifo_remove, + .driver = { + .name = "bf-tmfifo", + .of_match_table = tmfifo_match, + .acpi_match_table = ACPI_PTR(bf_tmfifo_acpi_match), + }, +}; + +static int __init tmfifo_init(void) +{ + int ret; + + mutex_init(&tmfifo_lock); + + ret = platform_driver_register(&tmfifo_driver); + if (ret) + pr_err("Failed to register tmfifo driver.\n"); + + return ret; +} + +static void __exit tmfifo_exit(void) +{ + platform_driver_unregister(&tmfifo_driver); +} + +module_init(tmfifo_init); +module_exit(tmfifo_exit); + +MODULE_DESCRIPTION("Mellanox BlueField SoC TMFIFO Driver"); +MODULE_LICENSE("GPL v2"); +MODULE_AUTHOR("Mellanox Technologies"); diff --git a/drivers/soc/mellanox/tmfifo_regs.h b/drivers/soc/mellanox/tmfifo_regs.h new file mode 100644 index 0000000..f42c9d6 --- /dev/null +++ b/drivers/soc/mellanox/tmfifo_regs.h @@ -0,0 +1,75 @@ +/* + * Copyright (c) 2018, Mellanox Technologies. All rights reserved. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 and + * only version 2 as published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + */ + +#ifndef __TMFIFO_REGS_H__ +#define __TMFIFO_REGS_H__ + +#include + +#define TMFIFO_TX_DATA 0x0 + +#define TMFIFO_TX_STS 0x8 +#define TMFIFO_TX_STS__LENGTH 0x0001 +#define TMFIFO_TX_STS__COUNT_SHIFT 0 +#define TMFIFO_TX_STS__COUNT_WIDTH 9 +#define TMFIFO_TX_STS__COUNT_RESET_VAL 0 +#define TMFIFO_TX_STS__COUNT_RMASK 0x1ff +#define TMFIFO_TX_STS__COUNT_MASK 0x1ff + +#define TMFIFO_TX_CTL 0x10 +#define TMFIFO_TX_CTL__LENGTH 0x0001 +#define TMFIFO_TX_CTL__LWM_SHIFT 0 +#define TMFIFO_TX_CTL__LWM_WIDTH 8 +#define TMFIFO_TX_CTL__LWM_RESET_VAL 128 +#define TMFIFO_TX_CTL__LWM_RMASK 0xff +#define TMFIFO_TX_CTL__LWM_MASK 0xff +#define TMFIFO_TX_CTL__HWM_SHIFT 8 +#define TMFIFO_TX_CTL__HWM_WIDTH 8 +#define TMFIFO_TX_CTL__HWM_RESET_VAL 128 +#define TMFIFO_TX_CTL__HWM_RMASK 0xff +#define TMFIFO_TX_CTL__HWM_MASK 0xff00 +#define TMFIFO_TX_CTL__MAX_ENTRIES_SHIFT 32 +#define TMFIFO_TX_CTL__MAX_ENTRIES_WIDTH 9 +#define TMFIFO_TX_CTL__MAX_ENTRIES_RESET_VAL 256 +#define TMFIFO_TX_CTL__MAX_ENTRIES_RMASK 0x1ff +#define TMFIFO_TX_CTL__MAX_ENTRIES_MASK 0x1ff00000000ULL + +#define TMFIFO_RX_DATA 0x0 + +#define TMFIFO_RX_STS 0x8 +#define TMFIFO_RX_STS__LENGTH 0x0001 +#define TMFIFO_RX_STS__COUNT_SHIFT 0 +#define TMFIFO_RX_STS__COUNT_WIDTH 9 +#define TMFIFO_RX_STS__COUNT_RESET_VAL 0 +#define TMFIFO_RX_STS__COUNT_RMASK 0x1ff +#define TMFIFO_RX_STS__COUNT_MASK 0x1ff + +#define TMFIFO_RX_CTL 0x10 +#define TMFIFO_RX_CTL__LENGTH 0x0001 +#define TMFIFO_RX_CTL__LWM_SHIFT 0 +#define TMFIFO_RX_CTL__LWM_WIDTH 8 +#define TMFIFO_RX_CTL__LWM_RESET_VAL 128 +#define TMFIFO_RX_CTL__LWM_RMASK 0xff +#define TMFIFO_RX_CTL__LWM_MASK 0xff +#define TMFIFO_RX_CTL__HWM_SHIFT 8 +#define TMFIFO_RX_CTL__HWM_WIDTH 8 +#define TMFIFO_RX_CTL__HWM_RESET_VAL 128 +#define TMFIFO_RX_CTL__HWM_RMASK 0xff +#define TMFIFO_RX_CTL__HWM_MASK 0xff00 +#define TMFIFO_RX_CTL__MAX_ENTRIES_SHIFT 32 +#define TMFIFO_RX_CTL__MAX_ENTRIES_WIDTH 9 +#define TMFIFO_RX_CTL__MAX_ENTRIES_RESET_VAL 256 +#define TMFIFO_RX_CTL__MAX_ENTRIES_RMASK 0x1ff +#define TMFIFO_RX_CTL__MAX_ENTRIES_MASK 0x1ff00000000ULL + +#endif /* !defined(__TMFIFO_REGS_H__) */ From patchwork Wed Oct 24 17:55:32 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Liming Sun X-Patchwork-Id: 10654835 Return-Path: Received: from mail.wl.linuxfoundation.org (pdx-wl-mail.web.codeaurora.org [172.30.200.125]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 32F3314BD for ; Wed, 24 Oct 2018 17:56:47 +0000 (UTC) Received: from mail.wl.linuxfoundation.org (localhost [127.0.0.1]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id 24E9E2B145 for ; Wed, 24 Oct 2018 17:56:47 +0000 (UTC) Received: by mail.wl.linuxfoundation.org (Postfix, from userid 486) id 187CC2B14F; Wed, 24 Oct 2018 17:56:47 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on pdx-wl-mail.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-2.9 required=2.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,MAILING_LIST_MULTI,RCVD_IN_DNSWL_NONE,UNPARSEABLE_RELAY autolearn=ham version=3.3.1 Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.wl.linuxfoundation.org (Postfix) with ESMTPS id 90BDF2B145 for ; Wed, 24 Oct 2018 17:56:46 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20170209; h=Sender: Content-Transfer-Encoding:Content-Type:MIME-Version:Cc:List-Subscribe: List-Help:List-Post:List-Archive:List-Unsubscribe:List-Id:References: In-Reply-To:Message-Id:Date:Subject:To:From:Reply-To:Content-ID: Content-Description:Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc :Resent-Message-ID:List-Owner; bh=bQLfh5PxdaTop3sVoLNlR6PUiEemBSQyCQh0MyzYsuI=; b=dpfnRnWRtw1iLbHNWZXwInaIol hTkgBq95j3Qa4Y7puVXpqYwTQ4kEarXk4XiXY17siy+UqbIoQsLpNOFQXCi+SnlFy97fyBY7MrIol ssLvBqybGuNgoLPmEKE5b/jW9nJFBvBegy+aaiNas8azSzsee/r4Xp45e3jAFuTsXH58aJ3DKn8lK 86Hfu+nQMN8LIpmnrM6yUg6rmRSW1jkoFgi5WI2d524vWUze4L60Jq4K6n8/lyDVybjdJGPg+eKBF X7Cx0uqdIDjwns3fzd6SIO9WKJt21DfyIktM5QQlhN8GdU0n0EXLkN1gYUDQB6ej2HP1Oq9qmGmws Mo0iel6w==; Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.90_1 #2 (Red Hat Linux)) id 1gFNOb-0007Mc-BK; Wed, 24 Oct 2018 17:56:41 +0000 Received: from mail-il-dmz.mellanox.com ([193.47.165.129] helo=mellanox.co.il) by bombadil.infradead.org with esmtp (Exim 4.90_1 #2 (Red Hat Linux)) id 1gFNNv-00076i-5r for linux-arm-kernel@lists.infradead.org; Wed, 24 Oct 2018 17:56:01 +0000 Received: from Internal Mail-Server by MTLPINE1 (envelope-from lsun@mellanox.com) with ESMTPS (AES256-SHA encrypted); 24 Oct 2018 20:00:56 +0200 Received: from bu-lab53.mtbu.labs.mlnx (bu-lab53.mtbu.labs.mlnx [10.15.8.107]) by labmailer.mlnx (8.13.8/8.13.8) with ESMTP id w9OHtlOL029126; Wed, 24 Oct 2018 20:55:48 +0300 Received: from bu-lab53.mtbu.labs.mlnx (localhost [127.0.0.1]) by bu-lab53.mtbu.labs.mlnx (8.14.7/8.14.7) with ESMTP id w9OHtlIq137762; Wed, 24 Oct 2018 13:55:47 -0400 Received: (from lsun@localhost) by bu-lab53.mtbu.labs.mlnx (8.14.7/8.14.7/Submit) id w9OHtlMB137761; Wed, 24 Oct 2018 13:55:47 -0400 From: Liming Sun To: Olof Johansson , Arnd Bergmann , David Woods , Robin Murphy , arm-soc Subject: [PATCH v4 2/4] arm64: Add Mellanox BlueField SoC config option Date: Wed, 24 Oct 2018 13:55:32 -0400 Message-Id: <1540403734-137721-2-git-send-email-lsun@mellanox.com> X-Mailer: git-send-email 1.8.3.1 In-Reply-To: <1540403734-137721-1-git-send-email-lsun@mellanox.com> References: <1540403734-137721-1-git-send-email-lsun@mellanox.com> In-Reply-To: References: X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20181024_105559_651258_F8135B17 X-CRM114-Status: UNSURE ( 8.40 ) X-CRM114-Notice: Please train this message. X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.21 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: devicetree@vger.kernel.org, Liming Sun , linux-arm-kernel@lists.infradead.org MIME-Version: 1.0 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+patchwork-linux-arm=patchwork.kernel.org@lists.infradead.org X-Virus-Scanned: ClamAV using ClamSMTP This commit introduces config option for Mellanox BlueField SoC, which can be used to build the SoC specific drivers, and enables it by default in configs/defconfig. Reviewed-by: David Woods Signed-off-by: Liming Sun Reviewed-by: Arnd Bergmann --- arch/arm64/Kconfig.platforms | 6 ++++++ arch/arm64/configs/defconfig | 1 + 2 files changed, 7 insertions(+) diff --git a/arch/arm64/Kconfig.platforms b/arch/arm64/Kconfig.platforms index d5aeac3..aeb67c2 100644 --- a/arch/arm64/Kconfig.platforms +++ b/arch/arm64/Kconfig.platforms @@ -110,6 +110,12 @@ config ARCH_MESON help This enables support for the Amlogic S905 SoCs. +config ARCH_MLNX_BLUEFIELD + bool "Mellanox BlueField SoC Family" + select SOC_MLNX + help + This enables support for the Mellanox BlueField SoC. + config ARCH_MVEBU bool "Marvell EBU SoC Family" select ARMADA_AP806_SYSCON diff --git a/arch/arm64/configs/defconfig b/arch/arm64/configs/defconfig index f9a186f..508cb9d 100644 --- a/arch/arm64/configs/defconfig +++ b/arch/arm64/configs/defconfig @@ -43,6 +43,7 @@ CONFIG_ARCH_LG1K=y CONFIG_ARCH_HISI=y CONFIG_ARCH_MEDIATEK=y CONFIG_ARCH_MESON=y +CONFIG_ARCH_MLNX_BLUEFIELD=y CONFIG_ARCH_MVEBU=y CONFIG_ARCH_QCOM=y CONFIG_ARCH_ROCKCHIP=y From patchwork Wed Oct 24 17:55:33 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Liming Sun X-Patchwork-Id: 10654837 Return-Path: Received: from mail.wl.linuxfoundation.org (pdx-wl-mail.web.codeaurora.org [172.30.200.125]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 7463614BD for ; Wed, 24 Oct 2018 17:57:28 +0000 (UTC) Received: from mail.wl.linuxfoundation.org (localhost [127.0.0.1]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id 66F4B2B14B for ; Wed, 24 Oct 2018 17:57:28 +0000 (UTC) Received: by mail.wl.linuxfoundation.org (Postfix, from userid 486) id 5A8B52B152; Wed, 24 Oct 2018 17:57:28 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on pdx-wl-mail.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-2.9 required=2.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,MAILING_LIST_MULTI,RCVD_IN_DNSWL_NONE,UNPARSEABLE_RELAY autolearn=ham version=3.3.1 Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.wl.linuxfoundation.org (Postfix) with ESMTPS id DD9D62B14F for ; Wed, 24 Oct 2018 17:57:27 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20170209; h=Sender: Content-Transfer-Encoding:Content-Type:MIME-Version:Cc:List-Subscribe: List-Help:List-Post:List-Archive:List-Unsubscribe:List-Id:References: In-Reply-To:Message-Id:Date:Subject:To:From:Reply-To:Content-ID: Content-Description:Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc :Resent-Message-ID:List-Owner; bh=obEHSw6rZbGoA9J2qmc3w/bNautf7Tpf8XVNnGgYatI=; b=WJqFB/6VBG5AakwLffLY0ZD2dT a/kD85N1Zoyum7DtTYU+GeSy9jvVvgE9jafYdwjlCIyjxgn/88l3cmoy7sRNpZCdPIo1HVAo+ivrf Kt96QSFi96cRUWS7WNVGhboWjSmPDhhFNYnLwHuQ4QvGJ0bhbpsSOr75nf1grb2rcT3sdI2wOST+7 4XwswxqNu4FESSDkbOsIAa3ui3i+aGNSD3Lp8Acg0N+vemNzdlKa5v1hG6tG1T9p3gQaU7rUC1Tb5 87culuPxFOcjoxQQoYlcOScIPkIeMeHF3q9Ggqu2Kc08AKOSNQyhqOsQkchog28gS97HXd1w79faE YeIMYiRQ==; Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.90_1 #2 (Red Hat Linux)) id 1gFNPG-0007f5-E7; Wed, 24 Oct 2018 17:57:22 +0000 Received: from mail-il-dmz.mellanox.com ([193.47.165.129] helo=mellanox.co.il) by bombadil.infradead.org with esmtp (Exim 4.90_1 #2 (Red Hat Linux)) id 1gFNNv-000772-5Z for linux-arm-kernel@lists.infradead.org; Wed, 24 Oct 2018 17:56:04 +0000 Received: from Internal Mail-Server by MTLPINE1 (envelope-from lsun@mellanox.com) with ESMTPS (AES256-SHA encrypted); 24 Oct 2018 20:00:59 +0200 Received: from bu-lab53.mtbu.labs.mlnx (bu-lab53.mtbu.labs.mlnx [10.15.8.107]) by labmailer.mlnx (8.13.8/8.13.8) with ESMTP id w9OHtolN029170; Wed, 24 Oct 2018 20:55:51 +0300 Received: from bu-lab53.mtbu.labs.mlnx (localhost [127.0.0.1]) by bu-lab53.mtbu.labs.mlnx (8.14.7/8.14.7) with ESMTP id w9OHtolC137764; Wed, 24 Oct 2018 13:55:50 -0400 Received: (from lsun@localhost) by bu-lab53.mtbu.labs.mlnx (8.14.7/8.14.7/Submit) id w9OHto2m137763; Wed, 24 Oct 2018 13:55:50 -0400 From: Liming Sun To: Olof Johansson , Arnd Bergmann , David Woods , Robin Murphy , arm-soc Subject: [PATCH v4 3/4] dt-bindings: soc: Add TmFifo binding for Mellanox BlueField SoC Date: Wed, 24 Oct 2018 13:55:33 -0400 Message-Id: <1540403734-137721-3-git-send-email-lsun@mellanox.com> X-Mailer: git-send-email 1.8.3.1 In-Reply-To: <1540403734-137721-1-git-send-email-lsun@mellanox.com> References: <1540403734-137721-1-git-send-email-lsun@mellanox.com> In-Reply-To: References: X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20181024_105559_640087_7DC0E4AD X-CRM114-Status: GOOD ( 10.07 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.21 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: devicetree@vger.kernel.org, Liming Sun , linux-arm-kernel@lists.infradead.org MIME-Version: 1.0 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+patchwork-linux-arm=patchwork.kernel.org@lists.infradead.org X-Virus-Scanned: ClamAV using ClamSMTP Add devicetree bindings for the TmFifo which is found on Mellanox BlueField SoCs. Reviewed-by: Rob Herring Reviewed-by: David Woods Signed-off-by: Liming Sun --- .../devicetree/bindings/soc/mellanox/tmfifo.txt | 23 ++++++++++++++++++++++ 1 file changed, 23 insertions(+) create mode 100644 Documentation/devicetree/bindings/soc/mellanox/tmfifo.txt diff --git a/Documentation/devicetree/bindings/soc/mellanox/tmfifo.txt b/Documentation/devicetree/bindings/soc/mellanox/tmfifo.txt new file mode 100644 index 0000000..8a13fa6 --- /dev/null +++ b/Documentation/devicetree/bindings/soc/mellanox/tmfifo.txt @@ -0,0 +1,23 @@ +* Mellanox BlueField SoC TmFifo + +BlueField TmFifo provides a shared FIFO between the target and the +external host machine, which can be accessed by external host via +USB or PCIe. In the current tmfifo driver, this FIFO has been demuxed +to implement virtual console and network interface based on the virtio +framework. + +Required properties: + +- compatible: Should be "mellanox,bf-tmfifo" +- reg: Physical base address and length of Rx/Tx block +- interrupts: The interrupt number of Rx low water mark, Rx high water mark + Tx low water mark, Tx high water mark respectively. + +Example: + +tmfifo@800a20 { + compatible = "mellanox,bf-tmfifo"; + reg = <0x00800a20 0x00000018 + 0x00800a40 0x00000018>; + interrupts = <41, 42, 43, 44>; +}; From patchwork Wed Oct 24 17:55:34 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Liming Sun X-Patchwork-Id: 10654833 Return-Path: Received: from mail.wl.linuxfoundation.org (pdx-wl-mail.web.codeaurora.org [172.30.200.125]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 0434613A9 for ; Wed, 24 Oct 2018 17:56:08 +0000 (UTC) Received: from mail.wl.linuxfoundation.org (localhost [127.0.0.1]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id EA71E2B066 for ; Wed, 24 Oct 2018 17:56:07 +0000 (UTC) Received: by mail.wl.linuxfoundation.org (Postfix, from userid 486) id DE8692B157; Wed, 24 Oct 2018 17:56:07 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on pdx-wl-mail.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-2.9 required=2.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,MAILING_LIST_MULTI,RCVD_IN_DNSWL_NONE,UNPARSEABLE_RELAY autolearn=ham version=3.3.1 Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.wl.linuxfoundation.org (Postfix) with ESMTPS id 85DF82B066 for ; Wed, 24 Oct 2018 17:56:07 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20170209; h=Sender: Content-Transfer-Encoding:Content-Type:MIME-Version:Cc:List-Subscribe: List-Help:List-Post:List-Archive:List-Unsubscribe:List-Id:References: In-Reply-To:Message-Id:Date:Subject:To:From:Reply-To:Content-ID: Content-Description:Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc :Resent-Message-ID:List-Owner; bh=/MgBboas6M+Yeh7gre21bFUMYOeRX9arRiGS4bYkTjs=; b=WUoBL6jLI+Mn414mVdU28Lv/jk 2oD0p8suAo3mMlI5LK65aHNJgVQFk+DvnO5Lva0qnW4/PVr9zEk+8w/JUUxPLaZ3KT9G+/PRNRHjD c28xZCt9qflSC3+TqG01ilF2GyvoMyO9K10BZFD/mBOgln4QlkqpSE2H9v8Hc4gKjJW9VheE1tTzk tdzHj8XodEzvpuKeyEECVfmjKw17LKORwcuh5RGLYOapWMxQjFagYMrUC6JInxaeiPnCcWMYACs3f +jktBGLYZVLRqPTXFxWOSfbILtyUEoLGb5iK6Wlcz1AHt5g1VuYBVwH31xCnCUbfhfJHGiEt77UGr kZT6aMig==; Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.90_1 #2 (Red Hat Linux)) id 1gFNO0-00078x-2u; Wed, 24 Oct 2018 17:56:04 +0000 Received: from mail-il-dmz.mellanox.com ([193.47.165.129] helo=mellanox.co.il) by bombadil.infradead.org with esmtp (Exim 4.90_1 #2 (Red Hat Linux)) id 1gFNNu-000776-Us for linux-arm-kernel@lists.infradead.org; Wed, 24 Oct 2018 17:56:01 +0000 Received: from Internal Mail-Server by MTLPINE1 (envelope-from lsun@mellanox.com) with ESMTPS (AES256-SHA encrypted); 24 Oct 2018 20:01:02 +0200 Received: from bu-lab53.mtbu.labs.mlnx (bu-lab53.mtbu.labs.mlnx [10.15.8.107]) by labmailer.mlnx (8.13.8/8.13.8) with ESMTP id w9OHtr7T029213; Wed, 24 Oct 2018 20:55:54 +0300 Received: from bu-lab53.mtbu.labs.mlnx (localhost [127.0.0.1]) by bu-lab53.mtbu.labs.mlnx (8.14.7/8.14.7) with ESMTP id w9OHtrQP137774; Wed, 24 Oct 2018 13:55:53 -0400 Received: (from lsun@localhost) by bu-lab53.mtbu.labs.mlnx (8.14.7/8.14.7/Submit) id w9OHtrYj137773; Wed, 24 Oct 2018 13:55:53 -0400 From: Liming Sun To: Olof Johansson , Arnd Bergmann , David Woods , Robin Murphy , arm-soc Subject: [PATCH v4 4/4] MAINTAINERS: Add entry for Mellanox Bluefield Soc Date: Wed, 24 Oct 2018 13:55:34 -0400 Message-Id: <1540403734-137721-4-git-send-email-lsun@mellanox.com> X-Mailer: git-send-email 1.8.3.1 In-Reply-To: <1540403734-137721-1-git-send-email-lsun@mellanox.com> References: <1540403734-137721-1-git-send-email-lsun@mellanox.com> In-Reply-To: References: X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20181024_105559_452048_AEE7F74C X-CRM114-Status: UNSURE ( 6.90 ) X-CRM114-Notice: Please train this message. X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.21 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: devicetree@vger.kernel.org, Liming Sun , linux-arm-kernel@lists.infradead.org MIME-Version: 1.0 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+patchwork-linux-arm=patchwork.kernel.org@lists.infradead.org X-Virus-Scanned: ClamAV using ClamSMTP Add maintainer information for Mellanox BlueField SoC. Reviewed-by: David Woods Signed-off-by: Liming Sun --- MAINTAINERS | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/MAINTAINERS b/MAINTAINERS index c78feb0..07f7c7e 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -1649,6 +1649,14 @@ L: linux-mediatek@lists.infradead.org (moderated for non-subscribers) S: Maintained F: drivers/phy/mediatek/phy-mtk-tphy.c +ARM/Mellanox BlueField SoC support +M: David Woods +M: Liming Sun +L: linux-arm-kernel@lists.infradead.org (moderated for non-subscribers) +S: Maintained +F: drivers/soc/mellanox/* +F: Documentation/devicetree/bindings/soc/mellanox/tmfifo.txt + ARM/MICREL KS8695 ARCHITECTURE M: Greg Ungerer L: linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)