From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-6.7 required=3.0 tests=DKIM_ADSP_CUSTOM_MED, DKIM_SIGNED,DKIM_VALID,FREEMAIL_FORGED_FROMDOMAIN,FREEMAIL_FROM, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY, SPF_PASS,URIBL_BLOCKED autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 883BFC43381 for ; Fri, 15 Mar 2019 13:18:43 +0000 (UTC) Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 561F821871 for ; Fri, 15 Mar 2019 13:18:43 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="ZdOAD8JV"; dkim=fail reason="signature verification failed" (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="b4zcWHgG" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 561F821871 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=gmail.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-arm-kernel-bounces+infradead-linux-arm-kernel=archiver.kernel.org@lists.infradead.org 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:Cc:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:In-Reply-To:MIME-Version:Date: Message-ID:From:References:To:Subject:Reply-To:Content-ID:Content-Description :Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=TemKpHrYiwOFfYAjROp6dwbZiSUAQMeWV3VZVTxjkyQ=; b=ZdOAD8JVWv8hk3 s1CTGUOh72aAx2Ll0ktU0nk/6lEvKPZjkKidoR1H99Dgp/eIReHAYNH+dAUKudcpBGjeuiBdBI23O IoQ0ZHoVKLDP55uQxKeB4ddWzKBl2k8d0zx5HltS5bKd4XonwC6AlTT7PDKNd38uLJcox8bkHw+SH DRE2fUfLgsRZM7vGJce7bdu1BI7v8pBxYKdHfmslLZZ7DAI8Opiabf/w2Nt69tvfIlv81yg/ZKeng Lbrr+vHHeLLByIdDW7/Z+/Fxw9BMkgDjWBmGNP+i4wnAtdNBFdHrlkMvVQZo8Y6LUibY0iVUEeczQ RBYuOMfVSErfMlxWj/Mw==; 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 1h4mjM-0002Sb-H4; Fri, 15 Mar 2019 13:18:36 +0000 Received: from mail-ed1-x543.google.com ([2a00:1450:4864:20::543]) by bombadil.infradead.org with esmtps (Exim 4.90_1 #2 (Red Hat Linux)) id 1h4mjI-0002S0-MP for linux-arm-kernel@lists.infradead.org; Fri, 15 Mar 2019 13:18:34 +0000 Received: by mail-ed1-x543.google.com with SMTP id p27so7583176edc.6 for ; Fri, 15 Mar 2019 06:18:30 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=subject:to:cc:references:from:openpgp:autocrypt:message-id:date :user-agent:mime-version:in-reply-to:content-language :content-transfer-encoding; bh=ZIohvt2jh5A6vomhVQX9sPKheUaevf/u43vy0PD7mt4=; b=b4zcWHgGQd9YcugaIRZi/RZtMNH4Romd9ENbxVWjjbgusaDUN8Bg/ICpPsXGBWW1kJ 6yqtfeX+Lo6GNMRarDz3jzfsJ4jB/umuktyRjW9GM9P8ZDBf+ggQQ+rSNqMvw+BGQx96 8roK2NsCr+oeSTilN8fuBeEMMFjyW8I8GOkfEMk4gGjqCqxv0cL0C9WmzZzch6q5ynlR /KKOkdQTDC1zuE8dGxgvqPIjy07/ngRUPCR1wlAGmVE12rerMXoiF6oJUtdfypAkgszg pO5lHlAt4HPCQw9CCmk7GaJnTVQzuYoeAEYXh6zbgVGhNBHbMElQz6Ef3gYqncbeNINO gmsQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:subject:to:cc:references:from:openpgp:autocrypt :message-id:date:user-agent:mime-version:in-reply-to :content-language:content-transfer-encoding; bh=ZIohvt2jh5A6vomhVQX9sPKheUaevf/u43vy0PD7mt4=; b=tVKcKr9WIa/JqcV9MS05zdBdaIsBNf8YMO0chsYQIf9WEPxc22u9kquStWkyS/JAdN IVJGfLcedct//YJoNqjP8IjMFUH6wdyIE8P1Nqqm2BEDbZuKWUuBDVgAVq3Sh/4TC115 OUDsVD73gAZaQJ6xhv802RYgPSK437Qi2z+G2+Tu8tWauFnJg6mDUb+MFMh/PKn9+qky BWef24RgP71mz8LKvlT46c39gPBdjU5AlKZ4ETXtZe6WF1yLgxgJoPNzsf83OKk939so qWNEPhOVDgypPUP4ibtomOX6oL5gLLmW25r1EUBegyp09KH9Yba9GfVFuvj8P7Y8HnuU aEiA== X-Gm-Message-State: APjAAAU0YIUVKy/yuzuxIYk5W8Dz+m+RKifTo6uiLS0ZyzrAeNSLI8Z+ g+kh1bDRmMu17qFOBFkxW7f+ZyKv X-Google-Smtp-Source: APXvYqy8LcBstgMJWQAEPXOaDypNzYDdE1MVc/j0C/hNyMonQsZyLJcZSF5k5qfasEbTalLyIgdqeQ== X-Received: by 2002:a17:906:4759:: with SMTP id j25mr2303356ejs.194.1552655907890; Fri, 15 Mar 2019 06:18:27 -0700 (PDT) Received: from ziggy.stardust ([37.223.147.22]) by smtp.gmail.com with ESMTPSA id m11sm408146eja.62.2019.03.15.06.18.26 (version=TLS1_3 cipher=AEAD-AES128-GCM-SHA256 bits=128/128); Fri, 15 Mar 2019 06:18:26 -0700 (PDT) Subject: Re: [PATCH v7 1/9] soc: Add TmFifo driver for Mellanox BlueField Soc To: Liming Sun , Olof Johansson , Arnd Bergmann , David Woods , Robin Murphy , arm-soc References: <1546543042-156044-1-git-send-email-lsun@mellanox.com> From: Matthias Brugger Openpgp: preference=signencrypt Autocrypt: addr=matthias.bgg@gmail.com; prefer-encrypt=mutual; keydata= mQINBFP1zgUBEAC21D6hk7//0kOmsUrE3eZ55kjc9DmFPKIz6l4NggqwQjBNRHIMh04BbCMY fL3eT7ZsYV5nur7zctmJ+vbszoOASXUpfq8M+S5hU2w7sBaVk5rpH9yW8CUWz2+ZpQXPJcFa OhLZuSKB1F5JcvLbETRjNzNU7B3TdS2+zkgQQdEyt7Ij2HXGLJ2w+yG2GuR9/iyCJRf10Okq gTh//XESJZ8S6KlOWbLXRE+yfkKDXQx2Jr1XuVvM3zPqH5FMg8reRVFsQ+vI0b+OlyekT/Xe 0Hwvqkev95GG6x7yseJwI+2ydDH6M5O7fPKFW5mzAdDE2g/K9B4e2tYK6/rA7Fq4cqiAw1+u EgO44+eFgv082xtBez5WNkGn18vtw0LW3ESmKh19u6kEGoi0WZwslCNaGFrS4M7OH+aOJeqK fx5dIv2CEbxc6xnHY7dwkcHikTA4QdbdFeUSuj4YhIZ+0QlDVtS1QEXyvZbZky7ur9rHkZvP ZqlUsLJ2nOqsmahMTIQ8Mgx9SLEShWqD4kOF4zNfPJsgEMB49KbS2o9jxbGB+JKupjNddfxZ HlH1KF8QwCMZEYaTNogrVazuEJzx6JdRpR3sFda/0x5qjTadwIW6Cl9tkqe2h391dOGX1eOA 1ntn9O/39KqSrWNGvm+1raHK+Ev1yPtn0Wxn+0oy1tl67TxUjQARAQABtClNYXR0aGlhcyBC cnVnZ2VyIDxtYXR0aGlhcy5iZ2dAZ21haWwuY29tPokCUgQTAQIAPAIbAwYLCQgHAwIGFQgC CQoLBBYCAwECHgECF4AWIQTmuZIYwPLDJRwsOhfZFAuyVhMC8QUCWt3scQIZAQAKCRDZFAuy VhMC8WzRD/4onkC+gCxG+dvui5SXCJ7bGLCu0xVtiGC673Kz5Aq3heITsERHBV0BqqctOEBy ZozQQe2Hindu9lasOmwfH8+vfTK+2teCgWesoE3g3XKbrOCB4RSrQmXGC3JYx6rcvMlLV/Ch YMRR3qv04BOchnjkGtvm9aZWH52/6XfChyh7XYndTe5F2bqeTjt+kF/ql+xMc4E6pniqIfkv c0wsH4CkBHqoZl9w5e/b9MspTqsU9NszTEOFhy7p2CYw6JEa/vmzR6YDzGs8AihieIXDOfpT DUr0YUlDrwDSrlm/2MjNIPTmSGHH94ScOqu/XmGW/0q1iar/Yr0leomUOeeEzCqQtunqShtE 4Mn2uEixFL+9jiVtMjujr6mphznwpEqObPCZ3IcWqOFEz77rSL+oqFiEA03A2WBDlMm++Sve 9jpkJBLosJRhAYmQ6ey6MFO6Krylw1LXcq5z1XQQavtFRgZoruHZ3XlhT5wcfLJtAqrtfCe0 aQ0kJW+4zj9/So0uxJDAtGuOpDYnmK26dgFN0tAhVuNInEVhtErtLJHeJzFKJzNyQ4GlCaLw jKcwWcqDJcrx9R7LsCu4l2XpKiyxY6fO4O8DnSleVll9NPfAZFZvf8AIy3EQ8BokUsiuUYHz wUo6pclk55PZRaAsHDX/fNr24uC6Eh5oNQ+v4Pax/gtyybkCDQRT9c4FARAAqdGWpdzcSM8q 6I2oTPS5J4KXXIJS8O2jbUcxoNuaSBnUkhwp2eML/i30oLbEC+akmagcOLD0kOY46yRFeSEC SPM9SWLxKvKUTQYGLX2sphPVZ3hEdFYKen3+cbvo6GyYTnm8ropHM9uqmXPZFFfLJDL76Nau kFsRfPMQUuwMe3hFVLmF7ntvdX3Z3jKImoMWrgA/SnsT6K40n/GCl1HNz2T8PSnqAUQjvSoI FAenxb23NtW6kg50xIxlb7DKbncnQGGTwoYn8u9Lgxkh8gJ03IMiSDHZ9o+wl21U8B3OXr1K L08vXmdR70d6MJSmt6pKs7yTjxraF0ZS6gz+F2BTy080jxceZwEWIIbK7zU3tm1hnr7QIbj/ H6W2Pv9p5CXzQCIw17FXFXjpGPa9knzd4WMzJv2Rgx/m8/ZG91aKq+4Cbz9TLQ7OyRdXqhPJ CopfKgZ2l/Fc5+AGhogJLxOopBoELIdHgB50Durx4YJLmQ1z/oimD0O/mUb5fJu0FUQ5Boc1 kHHJ8J8bZTuFrGAomfvnsek+dyenegqBpZCDniCSfdgeAx9oWNoXG4cgo8OVG7J/1YIWBHRa Wnk+WyXGBfbY/8247Gy8oaXtQs1OnehbMKBHRIY0tgoyUlag3wXuUzeK+0PKtWC7ZYelKNC0 Fn+zL9XpnK3HLE5ckhBLgK8AEQEAAYkCHwQYAQIACQUCU/XOBQIbDAAKCRDZFAuyVhMC8Yyu D/9g6+JZZ+oEy7HoGZ0Bawnlxu/xQrzaK/ltQhA2vtiMaxCN46gOvEF/x+IvFscAucm3q4Dy bJJkW2qY30ISK9MDELnudPmHRqCxTj8koabvcI1cP8Z0Fw1reMNZVgWgVZJkwHuPYnkhY15u 3vHDzcWnfnvmguKgYoJxkqqdp/acb0x/qpQgufrWGeYv2yb1YNidXBHTJSuelFcGp/oBXeJz rQ2IP1JBbQmQfPSePZzWdSLlrR+3jcBJEP/A/73lSObOQpiYJomXPcla6dH+iyV0IiiZdYgU Htwru4Stv/cFVFsUJk1fIOP1qjSa+L6Y0dWX6JMniqUXHhaXo6OPf7ArpVbBygMuzvy99LtS FSkMcYXn359sXOYsRy4V+Yr7Bs0lzdnHnKdpVqHiDvNgrrLoPNrKTiYwTmzTVbb9u/BjUGhC YUS705vcjBgXhdXS44kgO22kaB5c6Obg7WP7cucFomITovtZs5Rm1iaZZc31lzobfFPUwDSc YXOj6ckS9bF9lDG26z3C/muyiifZeiQvvG1ygexrHtnKYTNxqisOGjjcXzDzpS8egIOtIEI/ arzlqK5RprMLVOl6n/npxEWmInjBetsBsaX/9kJNZFM4Yais5scOnP+tuTnFTW2K9xKySyuD q/iLORJYRYMloJPaDAftiYfjFa8zuw1XnQyG17kCDQRT9gX3ARAAsL2UwyvSLQuMxOW2GRLv CiZuxtIEoUuhaBWdC/Yq3c6rWpTu692lhLd4bRpKJkE4nE3saaTVxIHFF3tt3IHSa3Qf831S lW39EkcFxr7DbO17kRThOyU1k7KDhUQqhRaUoT1NznrykvpTlNszhYNjA0CMYWH249MJXgck iKOezSHbQ2bZWtFG3uTloWSKloFsjsmRsb7Vn2FlyeP+00PVC6j7CRqczxpkyYoHuqIS0w1z Aq8HP5DDSH7+arijtPuJhVv9uaiD6YFLgSIQy4ZCZuMcdzKJz2j6KCw2kUXLehk4BU326O0G r9+AojZT8J3qvZYBpvCmIhGliKhZ7pYDKZWVseRw7rJS5UFnst5OBukBIjOaSVdp6JMpe99o caLjyow2By6DCEYgLCrquzuUxMQ8plEMfPD1yXBo00bLPatkuxIibM0G4IstKL5hSAKiaFCc 2f73ppp7eby3ZceyF4uCIxN3ABjW9ZCEAcEwC40S3rnh2wZhscBFZ+7sO7+Fgsd0w67zjpt+ YHFNv/chRJiPnDGGRt0jPWryaasDnQtAAf59LY3qd4GVHu8RA1G0Rz4hVw27yssHGycc4+/Z ZX7sPpgNKlpsToMaB5NWgc389HdqOG80Ia+sGkNj9ylp74MPbd0t3fzQnKXzBSHOCNuS67sc lUAw7HB+wa3BqgsAEQEAAYkEPgQYAQIACQUCU/YF9wIbAgIpCRDZFAuyVhMC8cFdIAQZAQIA BgUCU/YF9wAKCRC0OWJbLPHTQ14xD/9crEKZOwhIWX32UXvB/nWbhEx6+PQG2uWsnah7oc5D 7V+aY7M1jy5af8yhlhVdaxL5xUoepfOP08lkCEuSdrYbS5wBcQj4NE1QUoeAjJKbq4JwxUkX Baq2Lu91UZpdKxEVFfSkEzmeMaVvClGjGOtNCUKl8lwLuthU7dGTW74mJaW5jjlXldgzfzFd BkS3fsXfcmeDhHh5TpA4e3MYVBIJrq6Repv151g/zxdA02gjJgGvJlXTb6OgEZGNFr8LGJDh LP7MSksBw6IxCAJSicMESu5kXsJfcODlm4zFaV8QDBevI/s/TgOQ9KQ/EJQsG+XBAuh0dqpu ImmCdhlHx+YaGmwKO1/yhfWvg1h1xbVn98izeotmq1+0J1jt9tgM17MGvgHjmvqlaY+oUXfj OkHkcCGOvao5uAsddQhZcSLmLhrSot8WJI0z3NIM30yiNx/r6OMu47lzTobdYCU8/8m7Rhsq fyW68D+XR098NIlU2oYy1zUetw59WJLf2j5u6D6a9p10doY5lYUEeTjy9Ejs/cL+tQbGwgWh WwKVal1lAtZVaru0GMbSQQ2BycZsZ+H+sbVwpDNEOxQaQPMmEzwgv2Sk2hvR3dTnhUoUaVoR hQE3/+fVRbWHEEroh/+vXV6n4Ps5bDd+75NCQ/lfPZNzGxgxqbd/rd2wStVZpQXkhofMD/4k Z8IivHZYaTA+udUk3iRm0l0qnuX2M5eUbyHW0sZVPnL7Oa4OKXoOir1EWwzzq0GNZjHCh6Cz vLOb1+pllnMkBky0G/+txtgvj5T/366ErUF+lQfgNtENKY6In8tw06hPJbu1sUTQIs50Jg9h RNkDSIQ544ack0fzOusSPM+vo6OkvIHt8tV0fTO1muclwCX/5jb7zQIDgGiUIgS8y0M4hIkP KvdmgurPywi74nEoQQrKF6LpPYYHsDteWR/k2m2BOj0ciZDIIxVR09Y9moQIjBLJKN0J21XJ eAgam4uLV2p1kRDdw/ST5uMCqD4Qi5zrZyWilCci6jF1TR2VEt906E2+AZ3BEheRyn8yb2KO +cJD3kB4RzOyBC/Cq/CGAujfDkRiy1ypFF3TkZdya0NnMgka9LXwBV29sAw9vvrxHxGa+tO+ RpgKRywr4Al7QGiw7tRPbxkcatkxg67OcRyntfT0lbKlSTEQUxM06qvwFN7nobc9YiJJTeLu gfa4fCqhQCyquWVVoVP+MnLqkzu1F6lSB6dGIpiW0s3LwyE/WbCAVBraPoENlt69jI0WTXvH 4v71zEffYaGWqtrSize20x9xZf5c/Aukpx0UmsqheKeoSprKyRD/Wj/LgsuTE2Uod85U36Xk eFYetwQY1h3lok2Zb/3uFhWr0NqmT14EL7kCDQRT9gkSARAApxtQ4zUMC512kZ+gCiySFcIF /mAf7+l45689Tn7LI1xmPQrAYJDoqQVXcyh3utgtvBvDLmpQ+1BfEONDWc8KRP6Abo35YqBx 3udAkLZgr/RmEg3+Tiof+e1PJ2zRh5zmdei5MT8biE2zVd9DYSJHZ8ltEWIALC9lAsv9oa+2 L6naC+KFF3i0m5mxklgFoSthswUnonqvclsjYaiVPoSldDrreCPzmRCUd8znf//Z4BxtlTw3 SulF8weKLJ+Hlpw8lwb3sUl6yPS6pL6UV45gyWMe677bVUtxLYOu+kiv2B/+nrNRDs7B35y/ J4t8dtK0S3M/7xtinPiYRmsnJdk+sdAe8TgGkEaooF57k1aczcJlUTBQvlYAEg2NJnqaKg3S CJ4fEuT8rLjzuZmLkoHNumhH/mEbyKca82HvANu5C9clyQusJdU+MNRQLRmOAd/wxGLJ0xmA ye7Ozja86AIzbEmuNhNH9xNjwbwSJNZefV2SoZUv0+V9EfEVxTzraBNUZifqv6hernMQXGxs +lBjnyl624U8nnQWnA8PwJ2hI3DeQou1HypLFPeY9DfWv4xYdkyeOtGpueeBlqhtMoZ0kDw2 C3vzj77nWwBgpgn1Vpf4hG/sW/CRR6tuIQWWTvUM3ACa1pgEsBvIEBiVvPxyAtL+L+Lh1Sni 7w3HBk1EJvUAEQEAAYkCHwQYAQIACQUCU/YJEgIbDAAKCRDZFAuyVhMC8QndEACuN16mvivn WwLDdypvco5PF8w9yrfZDKW4ggf9TFVB9skzMNCuQc+tc+QM+ni2c4kKIdz2jmcg6QytgqVu m6V1OsNmpjADaQkVp5jL0tmg6/KA9Tvr07Kuv+Uo4tSrS/4djDjJnXHEp/tB+Fw7CArNtUtL lc8SuADCmMD+kBOVWktZyzkBkDfBXlTWl46T/8291lEspDWe5YW1ZAH/HdCR1rQNZWjNCpB2 Cic58CYMD1rSonCnbfUeyZYNNhNHZosl4dl7f+am87Q2x3pK0DLSoJRxWb7vZB0uo9CzCSm3 I++aYozF25xQoT+7zCx2cQi33jwvnJAK1o4VlNx36RfrxzBqc1uZGzJBCQu48UjmUSsTwWC3 HpE/D9sM+xACs803lFUIZC5H62G059cCPAXKgsFpNMKmBAWweBkVJAisoQeX50OP+/11ArV0 cv+fOTfJj0/KwFXJaaYh3LUQNILLBNxkSrhCLl8dUg53IbHx4NfIAgqxLWGfXM8DY1aFdU79 pac005PuhxCWkKTJz3gCmznnoat4GCnL5gy/m0Qk45l4PFqwWXVLo9AQg2Kp3mlIFZ6fsEKI AN5hxlbNvNb9V2Zo5bFZjPWPFTxOteM0omUAS+QopwU0yPLLGJVf2iCmItHcUXI+r2JwH1CJ jrHWeQEI2ucSKsNa8FllDmG/fQ== Message-ID: <39eb778e-64ae-ce81-ee66-3ff8eacd52b4@gmail.com> Date: Fri, 15 Mar 2019 14:18:25 +0100 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:60.0) Gecko/20100101 Thunderbird/60.5.1 MIME-Version: 1.0 In-Reply-To: <1546543042-156044-1-git-send-email-lsun@mellanox.com> Content-Language: en-US X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20190315_061832_769100_DC03163F X-CRM114-Status: GOOD ( 24.44 ) 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, linux-arm-kernel@lists.infradead.org Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+infradead-linux-arm-kernel=archiver.kernel.org@lists.infradead.org On 03/01/2019 20:17, Liming Sun wrote: > 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 | 1244 ++++++++++++++++++++++++++++++++++++ > drivers/soc/mellanox/tmfifo_regs.h | 76 +++ > 6 files changed, 1345 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/mellanox/tmfifo.c b/drivers/soc/mellanox/tmfifo.c > new file mode 100644 > index 0000000..2975229 > --- /dev/null > +++ b/drivers/soc/mellanox/tmfifo.c [..] > + > +/* Console Tx buffer size. */ > +#define TMFIFO_CONS_TX_BUF_SIZE (32 * 1024) > + > +/* House-keeping timer interval. */ > +static int tmfifo_timer_interval = HZ / 10; > +module_param(tmfifo_timer_interval, int, 0644); > +MODULE_PARM_DESC(tmfifo_timer_interval, "timer interval"); > + > +/* Global lock. */ > +static DEFINE_MUTEX(tmfifo_lock); Why do we need that? To synchronize between different tmfifo driver instances? > + > +/* 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 declaration. */ > +struct tmfifo; > + > +/* Virtual devices sharing the TM FIFO. */ > +#define TMFIFO_VDEV_MAX (VIRTIO_ID_CONSOLE + 1) > + > +/* 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 */ > +}; > + > +struct tmfifo_irq_info { > + struct tmfifo *fifo; /* tmfifo structure */ > + int irq; /* interrupt number */ > + int index; /* array index */ > +}; > + > +/* TMFIFO device structure */ > +struct tmfifo { > + struct tmfifo_vdev *vdev[TMFIFO_VDEV_MAX]; /* virtual devices */ > + struct platform_device *pdev; /* platform device */ > + struct mutex lock; >From what I understand we use this lock to syncronize between tmfifo_create_vdev, tmfifo_delete_vdev and tmfifo_work_handler. Create happens in probe and delete in remove, so we don't need a lock here. So the only reason I can see we need this lock here is, to make sure that we don't mess up between create a vdev and being already in the work handler. That can only happen, if an IRQ was triggered. If we enable the IRQs after creating the vdev, we don't need the lock at all. > + 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 */ > + struct tmfifo_irq_info irq_info[TM_IRQ_CNT]; /* irq info */ > + struct work_struct work; /* work struct for deferred process */ > + struct timer_list timer; /* keepalive timer */ > + struct tmfifo_vring *vring[2]; /* current Tx/Rx ring */ > + bool is_ready; /* ready flag */ > + spinlock_t spin_lock; /* spin lock */ > +}; > + > +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)) > + > +/* Return the available Tx buffer space. */ > +static inline int tmfifo_vdev_tx_buf_avail(struct tmfifo_vdev *vdev) > +{ > + return ((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)); Why do we need to subtract 8 from the available buffer size? > +} > + > +/* Update Tx buffer pointer after pushing data. */ > +static inline void tmfifo_vdev_tx_buf_push(struct tmfifo_vdev *vdev, u32 len) > +{ > + vdev->tx_tail += len; > + if (vdev->tx_tail >= TMFIFO_CONS_TX_BUF_SIZE) > + vdev->tx_tail -= TMFIFO_CONS_TX_BUF_SIZE; I would have expected vdev->tx_tail = (vdev->tx_tail + len) % TMFIFO_CONS_TX_BUF_SIZE; But I suppose your code executes faster. What I miss is some code to assure that no ring buffer overflow/underrun can happen. > +} > + > +/* Update Tx buffer pointer after popping data. */ > +static inline void tmfifo_vdev_tx_buf_pop(struct tmfifo_vdev *vdev, u32 len) > +{ > + vdev->tx_head += len; > + if (vdev->tx_head >= TMFIFO_CONS_TX_BUF_SIZE) > + vdev->tx_head -= TMFIFO_CONS_TX_BUF_SIZE; > +} > + [...] > + > +/* 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; You can pass strict tmfifo_vring* instead of virtqueue as function parameter, then you don't have to do this. > + 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) How can that happen? > + 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; > + [...] > + > +/* 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 (!fifo->is_ready) > + return; > + > + mutex_lock(&fifo->lock); > + So you don't want to queue up more work when remove is called. As is_ready is not atomic you could deadlock here: remove work_handler mutex_lock if(!is_ready) mutex_lock <- sleeps is_ready = false ... cancel_work_sync <- deadlock > + /* Tx. */ > + if (test_and_clear_bit(TM_TX_LWM_IRQ, &fifo->pend_events) && > + fifo->irq_info[TM_TX_LWM_IRQ].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_info[TM_RX_HWM_IRQ].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); > +} [...] > + > +/* 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) { Can't we use devm_request_mem_region and get rid of the release_mem_region here and in the remove function? Regards, Matthias > + 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); > + > + spin_lock_init(&fifo->spin_lock); > + 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_info[i].index = i; > + fifo->irq_info[i].fifo = fifo; > + fifo->irq_info[i].irq = platform_get_irq(pdev, i); > + ret = request_irq(fifo->irq_info[i].irq, tmfifo_irq_handler, 0, > + "tmfifo", &fifo->irq_info[i]); > + if (ret) { > + pr_err("Unable to request irq\n"); > + fifo->irq_info[i].irq = 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 = > + FIELD_GET(TMFIFO_TX_CTL__MAX_ENTRIES_MASK, ctl); > + ctl = (ctl & ~TMFIFO_TX_CTL__LWM_MASK) | > + FIELD_PREP(TMFIFO_TX_CTL__LWM_MASK, fifo->tx_fifo_size / 2); > + ctl = (ctl & ~TMFIFO_TX_CTL__HWM_MASK) | > + FIELD_PREP(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 = > + FIELD_GET(TMFIFO_RX_CTL__MAX_ENTRIES_MASK, ctl); > + ctl = (ctl & ~TMFIFO_RX_CTL__LWM_MASK) | > + FIELD_PREP(TMFIFO_RX_CTL__LWM_MASK, 0); > + ctl = (ctl & ~TMFIFO_RX_CTL__HWM_MASK) | > + FIELD_PREP(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); > + > + fifo->is_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; > + > + 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..9f21764 > --- /dev/null > +++ b/drivers/soc/mellanox/tmfifo_regs.h > @@ -0,0 +1,76 @@ > +/* SPDX-License-Identifier: GPL-2.0 */ > +/* > + * 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__) */ > _______________________________________________ linux-arm-kernel mailing list linux-arm-kernel@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-arm-kernel