From patchwork Wed Jun 10 15:21:51 2015 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Madalin Bucur X-Patchwork-Id: 482760 Return-Path: X-Original-To: patchwork-incoming@ozlabs.org Delivered-To: patchwork-incoming@ozlabs.org Received: from lists.ozlabs.org (lists.ozlabs.org [IPv6:2401:3900:2:1::3]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 61DE4140290 for ; Thu, 11 Jun 2015 01:37:00 +1000 (AEST) Received: from ozlabs.org (lists.ozlabs.org [IPv6:2401:3900:2:1::3]) by lists.ozlabs.org (Postfix) with ESMTP id 470D11A2BB4 for ; Thu, 11 Jun 2015 01:37:00 +1000 (AEST) X-Original-To: linuxppc-dev@lists.ozlabs.org Delivered-To: linuxppc-dev@lists.ozlabs.org Received: from na01-bl2-obe.outbound.protection.outlook.com (mail-bl2on0123.outbound.protection.outlook.com [65.55.169.123]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-SHA384 (256/256 bits)) (No client certificate requested) by lists.ozlabs.org (Postfix) with ESMTPS id 91B231A0EBB for ; Thu, 11 Jun 2015 01:23:33 +1000 (AEST) Received: from BY2PR03CA002.namprd03.prod.outlook.com (10.255.93.19) by BLUPR03MB552.namprd03.prod.outlook.com (10.141.77.145) with Microsoft SMTP Server (TLS) id 15.1.184.17; Wed, 10 Jun 2015 15:23:26 +0000 Received: from BN1AFFO11FD056.protection.gbl (10.255.93.4) by BY2PR03CA002.outlook.office365.com (10.255.93.19) with Microsoft SMTP Server (TLS) id 15.1.190.14 via Frontend Transport; Wed, 10 Jun 2015 15:23:25 +0000 Authentication-Results: spf=fail (sender IP is 192.88.168.50) smtp.mailfrom=freescale.com; freescale.mail.onmicrosoft.com; dkim=none (message not signed) header.d=none; Received-SPF: Fail (protection.outlook.com: domain of freescale.com does not designate 192.88.168.50 as permitted sender) receiver=protection.outlook.com; client-ip=192.88.168.50; helo=tx30smr01.am.freescale.net; Received: from tx30smr01.am.freescale.net (192.88.168.50) by BN1AFFO11FD056.mail.protection.outlook.com (10.58.53.71) with Microsoft SMTP Server (TLS) id 15.1.190.9 via Frontend Transport; Wed, 10 Jun 2015 15:23:25 +0000 Received: from localhost.localdomain (fsr-fed1764-003.ea.freescale.net [10.171.73.45]) by tx30smr01.am.freescale.net (8.14.3/8.14.0) with ESMTP id t5AFN4BZ007791; Wed, 10 Jun 2015 08:23:23 -0700 From: Madalin Bucur To: , , Subject: [PATCH 12/12] fsl/fman: Add FMan MAC driver Date: Wed, 10 Jun 2015 18:21:51 +0300 Message-ID: <1433949712-5648-12-git-send-email-madalin.bucur@freescale.com> X-Mailer: git-send-email 1.5.6.5 In-Reply-To: <1433949712-5648-11-git-send-email-madalin.bucur@freescale.com> References: <1433949712-5648-1-git-send-email-madalin.bucur@freescale.com> <1433949712-5648-2-git-send-email-madalin.bucur@freescale.com> <1433949712-5648-3-git-send-email-madalin.bucur@freescale.com> <1433949712-5648-4-git-send-email-madalin.bucur@freescale.com> <1433949712-5648-5-git-send-email-madalin.bucur@freescale.com> <1433949712-5648-6-git-send-email-madalin.bucur@freescale.com> <1433949712-5648-7-git-send-email-madalin.bucur@freescale.com> <1433949712-5648-8-git-send-email-madalin.bucur@freescale.com> <1433949712-5648-9-git-send-email-madalin.bucur@freescale.com> <1433949712-5648-10-git-send-email-madalin.bucur@freescale.com> <1433949712-5648-11-git-send-email-madalin.bucur@freescale.com> X-EOPAttributedMessage: 0 X-Microsoft-Exchange-Diagnostics: 1; BN1AFFO11FD056; 1:fIu+r7/dj7wNa+xsL1yOxdGg6HVIGUFDmuz6oq24CpwRKP3+roh9grgtch8TPMyKKzQGV2oe5JCND6fJ4GfXqRfFu8lH3dVowaguPnera2iAuMwaCbNryl4OxMjeKBmYkRYCIg932U/LxcvYAVD8JEFS5RQ97oPA9hpYw/nzwir/dhIdb72Rusdy5ojOKrPc+4hxCs3xo/PJNN06nvWcuNCyfPBJh5yndbuVjzkKU2LTIhVZwDP+9oCebcfyOEOHupMVc1gKTQcB56AkLXinTsbgRwbVe8hZRTuR9R5IwFpE1lvmF9/tDncNtyg9hisC9TyFpJDsLQMjrbEhpJAT8g== X-Forefront-Antispam-Report: CIP:192.88.168.50; CTRY:US; IPV:NLI; EFV:NLI; SFV:NSPM; SFS:(10019020)(6009001)(339900001)(199003)(189002)(48376002)(19580395003)(47776003)(104016003)(33646002)(46102003)(53806999)(50986999)(76176999)(19580405001)(87936001)(6806004)(2201001)(49486002)(86362001)(85426001)(229853001)(189998001)(77096005)(5001920100001)(5001960100002)(107886002)(2950100001)(105606002)(50226001)(5001770100001)(77156002)(5890100001)(62966003)(36756003)(43066003)(2004002)(2101003)(4001430100001)(579004); DIR:OUT; SFP:1102; SCL:1; SRVR:BLUPR03MB552; H:tx30smr01.am.freescale.net; FPR:; SPF:Fail; MLV:sfv; A:1; MX:1; LANG:en; MIME-Version: 1.0 X-Microsoft-Exchange-Diagnostics: 1; BLUPR03MB552; 2:wYaHGy0kxgMzMk/52Qb90h1ZNPsHv001Xjc0MpR7Yd6X+sKRHmcIdH5ZNZmwHJi/; 2:eVVmlpb2BDo6HSJN3dBhaJ7M3cOT17Cbn4W6rCQaRCF2YDUDFmdusPSSxyjt8zCZTwYjp0qZOcjgg6hWMYUE8DFIz+QzcSDTFsfhgUbf0HbIcFqRwsb2WFvHky3jpXZDafPQcHjyD44Z3lnTiNKxEq4MdHb3OqMj/FkppTJVcmz9RF93aF23rmLAaFjJ6KzQtvGZjfPksrV6xlSVnQHv2yclcCOadTBL6CK+fi9rGok=; 6:0/Jn/IBYr08tR1oBqizcDaXPtbkFZCAtO9Ao7IwbVbIrgabG5rc+3xVwOfDW00muI+Mxbs1WrXKVpyuPeCi+P5wxJC5tMRb9KWXdI3v+XQGC4qab5UxS61VwoWdlblP7UqC3Qgf9/eFTEDDL7yBozZ4fWO1QEx7UIyGiGA3nszy6eZLCUA/eZcPEleLxLPH906lndwbbMKBfVH168S8sP13aY0b2A4h6PtcMNs6arPkrAvwrnhK1bxB7V1JdLDY1aDrw+P01y5NDiAPwqR3DVhrbzEQu6mzAvuupis0Tx4t07CJx0/3fNwUiKR30NiXkKZOO5w7u6vR7wOOF/4fdQw==; 3:fSzGpZceVTR23zr1CjYJv2oS/a4bzpsBBBNYrNc8ynWKcdE/HYHbTkjvRUcRXqSJRUp8EfaVAMMN7HErtWYKq77A2ltwHy8JgoaYVBiflznqsmUgxBNGKHawmR63l89fUlNoHA73ImoVYwQKf86oPUuJffvFRM9xS9a/PFHLw6Ba4OoEoMmaqert/62L1GAY6ph2gtYZC5E8Yxv6at8QPUqmT9r/pW9I6TtPqLcG+h60QETRAnNVcWHiPDiliFOcjY/Xp1YeT3cMiZaUCUkXry5WPdSifR/uR80Wr1fOhm+wOzBIeObseBmkeEqF1CHq X-Microsoft-Antispam: UriScan:;BCL:0;PCL:0;RULEID:;SRVR:BLUPR03MB552; X-Microsoft-Antispam-PRVS: X-Exchange-Antispam-Report-Test: UriScan:; X-Exchange-Antispam-Report-CFA-Test: BCL:0; PCL:0; RULEID:(601004)(520003)(5005006)(3002001); SRVR:BLUPR03MB552; BCL:0; PCL:0; RULEID:; SRVR:BLUPR03MB552; X-Forefront-PRVS: 06036BD506 X-Microsoft-Exchange-Diagnostics: =?us-ascii?Q?1; BLUPR03MB552; 9:Jf3z+/VHzSaLlK1vPfMFn9WTjuwiE1LFbG2xv3ZjonU?= =?us-ascii?Q?B3KmAqEM0A9EYM7jiqIOzkEzzhLtlfT+z6rg0IuPL/zd+8LEHbYaa2+i8ep4?= =?us-ascii?Q?T3cdJDq88NhK1ibo6y/1UN2lXzeCut8H9assso50HE/iel4E1vFId/FfpS8O?= =?us-ascii?Q?rYjUR8G+BZzCNqYfaBzjeqrzKAe0DjW4R+tFdRhduzpVZyjYEP0s0cQvc4W6?= =?us-ascii?Q?zs3WPDPK3STmEgUhZnmhg7qFmhLGJLt0qhB7FO2m1jjfbLI7Q6V3EK/YzOSX?= =?us-ascii?Q?8aqHNoMLVv4iN7I4EPwuLdO+S6INjQl2iMdvwhxAj+DfHTihNVPie5gTBRD9?= =?us-ascii?Q?oQBANREBnfwNxh8WAK1x4W/7eqqJQTQ9dEYXJNEppUmWpDGdRp51lnortNwq?= =?us-ascii?Q?5G2QD4YLLPQCx8dVJhiLEbZaLsN9dEeshBqlsKwG1JvX4iIl5IUFW7i4GEJV?= =?us-ascii?Q?KkZH871xQsOTpXIlVyVG77bcxNkYLYjFUbWZYs2GgADDATFY47e/OxsnIaPd?= =?us-ascii?Q?caflcnFkbSIUqTZBzdhCVpvjCnwBG2LC1MXFY5UDRyc4o9DY+pUgrxf+Y2cE?= =?us-ascii?Q?Xn2kKGrrXiaGJW3MUZDhkW0CyVwtGBCC++8XmbLQtSTmTWUoLyEObuiTVczU?= =?us-ascii?Q?rgZ8sqh1T9FIljnguy4/T2s4KNy0KfUT3AfYCtDMwtmVzCSXWBS8NUEvubgn?= =?us-ascii?Q?ffoWl1KX2JzWmECG07ub85QHel9VDI4lo262coRqlX//AFec1iylZqMUfwDS?= =?us-ascii?Q?HHq4E4vc/MgIa4Cxj/DbbicvEZ4gUAjCmmm+T958huG71cUPsiKUuaII2Buu?= =?us-ascii?Q?zQe+2vXP2xzvEQoHfT1zz2PxRXVr71brBXye1bJA1G2N5SvnGJBCyCU/6kSu?= =?us-ascii?Q?+eUhWn+cCsMsuyS16CMbX7mznITtOdT0mavBYIASUAJEVqFcRo2QRAovNXQo?= =?us-ascii?Q?lv+9/IsqsmuYuCs+Wl1znWEKqgC17Bl86WA2GGVdCmlgnffAMQGqoQ4VI62p?= =?us-ascii?Q?xwLI7XHy07Cvblt+hR+y9nLrvh3BiN7asWA/wIwAL1w=3D=3D?= X-Microsoft-Exchange-Diagnostics: 1; BLUPR03MB552; 3:Csu5JoVn2ijDBMB6zo6Js/CecPdXKImVpUjeRqBr9WTHlSXg+PeSUHKa4356gBB3RgnGWvSWCKyNehFpV0xvQgdKFFR16j1F2QzknFj98GPsgg5bD87XauaP/5kzM7qhufc3FDqrKnuvXu+2JNkFDw==; 10:I2KH0Wp6A0Fqq7ppW49Ioh11lpj9X6xdVICieIiwWIwFNCdWSvnuPU1jk4XLofmxQIjElLh50MaC9oRbGlDpzLEPDxxoYqz825DVTN8T2t0=; 6:k/cwxaqHbGu4xA6PRJSdeE0kP9qc1QvBS11oQySCqR0T28Bt8CzSaRzBwbIF74I9 X-OriginatorOrg: freescale.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 10 Jun 2015 15:23:25.0818 (UTC) X-MS-Exchange-CrossTenant-Id: 710a03f5-10f6-4d38-9ff4-a80b81da590d X-MS-Exchange-CrossTenant-OriginalAttributedTenantConnectingIp: TenantId=710a03f5-10f6-4d38-9ff4-a80b81da590d; Ip=[192.88.168.50]; Helo=[tx30smr01.am.freescale.net] X-MS-Exchange-CrossTenant-FromEntityHeader: HybridOnPrem X-MS-Exchange-Transport-CrossTenantHeadersStamped: BLUPR03MB552 X-BeenThere: linuxppc-dev@lists.ozlabs.org X-Mailman-Version: 2.1.20 Precedence: list List-Id: Linux on PowerPC Developers Mail List List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Reply-To: madalin.bucur@freescale.com Cc: scottwood@freescale.com, Igal Liberman , Madalin Bucur Errors-To: linuxppc-dev-bounces+patchwork-incoming=ozlabs.org@lists.ozlabs.org Sender: "Linuxppc-dev" From: Igal Liberman This patch adds the Ethernet MAC driver support. Signed-off-by: Igal Liberman Signed-off-by: Madalin Bucur --- drivers/net/ethernet/freescale/fman/inc/mac.h | 136 ++++ drivers/net/ethernet/freescale/fman/mac/Makefile | 3 +- drivers/net/ethernet/freescale/fman/mac/mac-api.c | 765 ++++++++++++++++++++++ drivers/net/ethernet/freescale/fman/mac/mac.c | 526 +++++++++++++++ 4 files changed, 1429 insertions(+), 1 deletion(-) create mode 100644 drivers/net/ethernet/freescale/fman/inc/mac.h create mode 100644 drivers/net/ethernet/freescale/fman/mac/mac-api.c create mode 100644 drivers/net/ethernet/freescale/fman/mac/mac.c diff --git a/drivers/net/ethernet/freescale/fman/inc/mac.h b/drivers/net/ethernet/freescale/fman/inc/mac.h new file mode 100644 index 0000000..0111f4c --- /dev/null +++ b/drivers/net/ethernet/freescale/fman/inc/mac.h @@ -0,0 +1,136 @@ +/* Copyright 2008-2015 Freescale Semiconductor, Inc. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of Freescale Semiconductor nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * + * ALTERNATIVELY, this software may be distributed under the terms of the + * GNU General Public License ("GPL") as published by the Free Software + * Foundation, either version 2 of that License or (at your option) any + * later version. + * + * THIS SOFTWARE IS PROVIDED BY Freescale Semiconductor ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL Freescale Semiconductor BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef __MAC_H +#define __MAC_H + +#include /* struct device, BUS_ID_SIZE */ +#include /* ETH_ALEN */ +#include /* phy_interface_t, struct phy_device */ +#include + +#include "enet_ext.h" + +#include "fsl_fman_drv.h" /* struct port_device */ +#include "fm_port_ext.h" + +struct fm_mac_dev; +enum fm_mac_exceptions; + +enum {DTSEC, XGMAC, MEMAC}; + +struct mac_device { + struct device *dev; + void *priv; + u8 cell_index; + struct resource *res; + void __iomem *vaddr; + u8 addr[ETH_ALEN]; + bool promisc; + + struct fm *fm_dev; + struct fm_port_drv_t *port_dev[2]; + + phy_interface_t phy_if; + u32 if_support; + bool link; + u16 speed; + u16 max_speed; + struct device_node *phy_node; + char fixed_bus_id[MII_BUS_ID_SIZE + 3]; + struct device_node *tbi_node; + struct phy_device *phy_dev; + void *fm; + /* List of multicast addresses */ + struct list_head mc_addr_list; + struct platform_device *eth_dev; + + bool autoneg_pause; + bool rx_pause_req; + bool tx_pause_req; + bool rx_pause_active; + bool tx_pause_active; + + int (*init_phy)(struct net_device *net_dev, struct mac_device *mac_dev); + int (*init)(struct mac_device *mac_dev); + int (*start)(struct mac_device *mac_dev); + int (*stop)(struct mac_device *mac_dev); + int (*set_promisc)(struct fm_mac_dev *fm_mac_dev, bool enable); + int (*change_addr)(struct fm_mac_dev *fm_mac_dev, + enet_addr_t *p_enet_addr); + int (*set_multi)(struct net_device *net_dev, + struct mac_device *mac_dev); + int (*uninit)(struct fm_mac_dev *fm_mac_dev); + int (*set_rx_pause)(struct fm_mac_dev *fm_mac_dev, bool en); + int (*set_tx_pause)(struct fm_mac_dev *fm_mac_dev, u8 priority, + u16 pause_time, u16 thresh_time); + int (*set_exception)(struct fm_mac_dev *fm_mac_dev, + enum fm_mac_exceptions exception, + bool enable); + int (*add_hash_mac_addr)(struct fm_mac_dev *fm_mac_dev, + enet_addr_t *p_eth_addr); + int (*remove_hash_mac_addr)(struct fm_mac_dev *fm_mac_dev, + enet_addr_t *p_eth_addr); +}; + +struct mac_address { + u8 addr[ETH_ALEN]; + struct list_head list; +}; + +struct dpaa_eth_data { + struct device_node *mac_node; + struct mac_device *mac_dev; + int mac_hw_id; + int fman_hw_id; +}; + +#define get_fm_handle(net_dev) \ + (((struct dpa_priv_s *)netdev_priv(net_dev))->mac_dev->fm_dev) + +#define for_each_port_device(i, port_dev) \ + for (i = 0; i < ARRAY_SIZE(port_dev); i++) + +static inline __attribute((nonnull)) void *macdev_priv( + const struct mac_device *mac_dev) +{ + return (void *)mac_dev + sizeof(*mac_dev); +} + +extern const char *mac_driver_description; +extern const size_t mac_sizeof_priv[]; +extern void (*const mac_setup[])(struct mac_device *mac_dev); + +int set_mac_active_pause(struct mac_device *mac_dev, bool rx, bool tx); +void get_pause_cfg(struct mac_device *mac_dev, bool *rx_pause, bool *tx_pause); +struct fm_mac_dev *get_mac_handle(struct mac_device *mac_dev); + +#endif /* __MAC_H */ diff --git a/drivers/net/ethernet/freescale/fman/mac/Makefile b/drivers/net/ethernet/freescale/fman/mac/Makefile index bfd04ea..af3c82f 100644 --- a/drivers/net/ethernet/freescale/fman/mac/Makefile +++ b/drivers/net/ethernet/freescale/fman/mac/Makefile @@ -1,7 +1,8 @@ -obj-y += fsl_fman_mac.o +obj-y += fsl_fman_mac.o fsl_mac.o fsl_fman_mac-objs := fman_dtsec.o fman_dtsec_mii_acc.o \ fm_dtsec.o fm_dtsec_mii_acc.o \ fman_memac.o fman_memac_mii_acc.o \ fm_memac.o fm_memac_mii_acc.o \ fman_tgec.o fm_tgec.o +fsl_mac-objs += mac.o mac-api.o diff --git a/drivers/net/ethernet/freescale/fman/mac/mac-api.c b/drivers/net/ethernet/freescale/fman/mac/mac-api.c new file mode 100644 index 0000000..bf8fa29 --- /dev/null +++ b/drivers/net/ethernet/freescale/fman/mac/mac-api.c @@ -0,0 +1,765 @@ +/* Copyright 2008-2015 Freescale Semiconductor, Inc. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of Freescale Semiconductor nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * + * ALTERNATIVELY, this software may be distributed under the terms of the + * GNU General Public License ("GPL") as published by the Free Software + * Foundation, either version 2 of that License or (at your option) any + * later version. + * + * THIS SOFTWARE IS PROVIDED BY Freescale Semiconductor ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL Freescale Semiconductor BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifdef CONFIG_FSL_DPAA_ETH_DEBUG +#define pr_fmt(fmt) \ + KBUILD_MODNAME ": %s:%hu:%s() " fmt, \ + KBUILD_BASENAME ".c", __LINE__, __func__ +#else +#define pr_fmt(fmt) \ + KBUILD_MODNAME ": " fmt +#endif + +#include +#include +#include +#include +#include +#include +#include + +#include "mac.h" +#include "fsl_fman_drv.h" +#include "fm_mac.h" +#include "fm_dtsec.h" +#include "fm_tgec.h" +#include "fm_memac.h" + +#define MAC_DESCRIPTION "FSL FMan MAC API based driver" + +MODULE_LICENSE("Dual BSD/GPL"); + +MODULE_AUTHOR("Emil Medve "); + +MODULE_DESCRIPTION(MAC_DESCRIPTION); + +struct mac_priv_s { + struct fm_mac_dev *fm_mac; +}; + +const char *mac_driver_description __initconst = MAC_DESCRIPTION; +const size_t mac_sizeof_priv[] = { + [DTSEC] = sizeof(struct mac_priv_s), + [XGMAC] = sizeof(struct mac_priv_s), + [MEMAC] = sizeof(struct mac_priv_s) +}; + +static const enet_mode_t _100[] = { + [PHY_INTERFACE_MODE_MII] = ENET_MODE_MII_100, + [PHY_INTERFACE_MODE_RMII] = ENET_MODE_RMII_100 +}; + +static const enet_mode_t _1000[] = { + [PHY_INTERFACE_MODE_GMII] = ENET_MODE_GMII_1000, + [PHY_INTERFACE_MODE_SGMII] = ENET_MODE_SGMII_1000, + [PHY_INTERFACE_MODE_TBI] = ENET_MODE_TBI_1000, + [PHY_INTERFACE_MODE_RGMII] = ENET_MODE_RGMII_1000, + [PHY_INTERFACE_MODE_RGMII_ID] = ENET_MODE_RGMII_1000, + [PHY_INTERFACE_MODE_RGMII_RXID] = ENET_MODE_RGMII_1000, + [PHY_INTERFACE_MODE_RGMII_TXID] = ENET_MODE_RGMII_1000, + [PHY_INTERFACE_MODE_RTBI] = ENET_MODE_RTBI_1000 +}; + +static enet_mode_t __cold __attribute__((nonnull)) +macdev2enetinterface(const struct mac_device *mac_dev) +{ + switch (mac_dev->max_speed) { + case SPEED_100: + return _100[mac_dev->phy_if]; + case SPEED_1000: + return _1000[mac_dev->phy_if]; + case SPEED_10000: + return ENET_MODE_XGMII_10000; + default: + return ENET_MODE_MII_100; + } +} + +struct fm_mac_dev *get_mac_handle(struct mac_device *mac_dev) +{ + const struct mac_priv_s *priv; + + priv = macdev_priv(mac_dev); + + return priv->fm_mac; +} + +static void mac_exception(void *_mac_dev, enum fm_mac_exceptions ex) +{ + struct mac_device *mac_dev; + + mac_dev = (struct mac_device *)_mac_dev; + + if (FM_MAC_EX_10G_RX_FIFO_OVFL == ex) { + /* don't flag RX FIFO after the first */ + mac_dev->set_exception(get_mac_handle(mac_dev), + FM_MAC_EX_10G_RX_FIFO_OVFL, false); + dev_err(mac_dev->dev, "10G MAC got RX FIFO Error = %x\n", + ex); + } + + dev_dbg(mac_dev->dev, "%s:%s() -> %d\n", KBUILD_BASENAME ".c", + __func__, ex); +} + +static int __cold tgec_initialization(struct mac_device *mac_dev) +{ + int err; + struct mac_priv_s *priv; + struct fm_mac_params_t param; + u32 version; + + priv = macdev_priv(mac_dev); + + param.base_addr = (typeof(param.base_addr))(uintptr_t)devm_ioremap( + mac_dev->dev, mac_dev->res->start, 0x2000); + param.enet_mode = macdev2enetinterface(mac_dev); + memcpy(¶m.addr, mac_dev->addr, + min(sizeof(param.addr), sizeof(mac_dev->addr))); + param.mac_id = mac_dev->cell_index; + param.h_fm = (void *)mac_dev->fm; + param.f_exception = mac_exception; + param.f_event = mac_exception; + param.dev_id = mac_dev; + + priv->fm_mac = tgec_config(¶m); + if (unlikely(!priv->fm_mac)) { + err = -EINVAL; + goto _return; + } + + err = tgec_cfg_max_frame_len(priv->fm_mac, fm_get_max_frm()); + if (unlikely(err < 0)) + goto _return_fm_mac_free; + + err = tgec_init(priv->fm_mac); + if (unlikely(err < 0)) + goto _return_fm_mac_free; + + /* For 1G MAC, disable by default the MIB counters overflow interrupt */ + if (macdev2enetinterface(mac_dev) != ENET_MODE_XGMII_10000) { + err = mac_dev->set_exception(get_mac_handle(mac_dev), + FM_MAC_EX_1G_RX_MIB_CNT_OVFL, + false); + if (unlikely(err < 0)) + goto _return_fm_mac_free; + } + + /* For 10G MAC, disable Tx ECC exception */ + if (macdev2enetinterface(mac_dev) == ENET_MODE_XGMII_10000) { + err = mac_dev->set_exception(get_mac_handle(mac_dev), + FM_MAC_EX_10G_TX_ECC_ER, false); + if (unlikely(err < 0)) + goto _return_fm_mac_free; + } + + err = tgec_get_version(priv->fm_mac, &version); + if (unlikely(err < 0)) + goto _return_fm_mac_free; + + dev_info(mac_dev->dev, "FMan %s version: 0x%08x\n", + ((macdev2enetinterface(mac_dev) != ENET_MODE_XGMII_10000) ? + "dTSEC" : "XGEC"), version); + + goto _return; + +_return_fm_mac_free: + tgec_free(get_mac_handle(mac_dev)); + +_return: + return err; +} + +static int __cold dtsec_initialization(struct mac_device *mac_dev) +{ + int err; + struct mac_priv_s *priv; + struct fm_mac_params_t param; + u32 version; + + priv = macdev_priv(mac_dev); + + param.base_addr = (typeof(param.base_addr))(uintptr_t)devm_ioremap( + mac_dev->dev, mac_dev->res->start, 0x2000); + param.enet_mode = macdev2enetinterface(mac_dev); + memcpy(¶m.addr, mac_dev->addr, + min(sizeof(param.addr), sizeof(mac_dev->addr))); + param.mac_id = mac_dev->cell_index; + param.h_fm = (void *)mac_dev->fm; + param.f_exception = mac_exception; + param.f_event = mac_exception; + param.dev_id = mac_dev; + + priv->fm_mac = dtsec_config(¶m); + if (unlikely(!priv->fm_mac)) { + err = -EINVAL; + goto _return; + } + + err = dtsec_cfg_max_frame_len(priv->fm_mac, fm_get_max_frm()); + if (unlikely(err < 0)) + goto _return_fm_mac_free; + + err = dtsec_cfg_pad_and_crc(priv->fm_mac, true); + if (unlikely(err < 0)) + goto _return_fm_mac_free; + + err = dtsec_init(priv->fm_mac); + if (unlikely(err < 0)) + goto _return_fm_mac_free; + + /* For 1G MAC, disable by default the MIB counters overflow interrupt */ + if (macdev2enetinterface(mac_dev) != ENET_MODE_XGMII_10000) { + err = mac_dev->set_exception(get_mac_handle(mac_dev), + FM_MAC_EX_1G_RX_MIB_CNT_OVFL, + false); + if (unlikely(err < 0)) + goto _return_fm_mac_free; + } + + /* For 10G MAC, disable Tx ECC exception */ + if (macdev2enetinterface(mac_dev) == ENET_MODE_XGMII_10000) { + err = mac_dev->set_exception(get_mac_handle(mac_dev), + FM_MAC_EX_10G_TX_ECC_ER, false); + if (unlikely(err < 0)) + goto _return_fm_mac_free; + } + + err = dtsec_get_version(priv->fm_mac, &version); + if (unlikely(err < 0)) + goto _return_fm_mac_free; + + dev_info(mac_dev->dev, "FMan %s version: 0x%08x\n", + ((macdev2enetinterface(mac_dev) != ENET_MODE_XGMII_10000) ? + "dTSEC" : "XGEC"), version); + + goto _return; + +_return_fm_mac_free: + dtsec_free(get_mac_handle(mac_dev)); + +_return: + return err; +} + +static int __cold memac_initialization(struct mac_device *mac_dev) +{ + int _errno; + struct mac_priv_s *priv; + struct fm_mac_params_t param; + + priv = macdev_priv(mac_dev); + + param.base_addr = (typeof(param.base_addr))(uintptr_t)devm_ioremap( + mac_dev->dev, mac_dev->res->start, 0x2000); + param.enet_mode = macdev2enetinterface(mac_dev); + memcpy(¶m.addr, mac_dev->addr, sizeof(mac_dev->addr)); + param.mac_id = mac_dev->cell_index; + param.h_fm = (void *)mac_dev->fm; + param.f_exception = mac_exception; + param.f_event = mac_exception; + param.dev_id = mac_dev; + + priv->fm_mac = memac_config(¶m); + if (unlikely(!priv->fm_mac)) { + _errno = -EINVAL; + goto _return; + } + + _errno = memac_cfg_max_frame_len(priv->fm_mac, fm_get_max_frm()); + if (unlikely(_errno < 0)) + goto _return_fm_mac_free; + + _errno = memac_cfg_reset_on_init(priv->fm_mac, true); + if (unlikely(_errno < 0)) + goto _return_fm_mac_free; + + _errno = memac_init(priv->fm_mac); + if (unlikely(_errno < 0)) + goto _return_fm_mac_free; + + dev_info(mac_dev->dev, "FMan MEMAC\n"); + + goto _return; + +_return_fm_mac_free: + memac_free(priv->fm_mac); + +_return: + return _errno; +} + +static int __cold dtsec_start(struct mac_device *mac_dev) +{ + int err; + struct phy_device *phy_dev = mac_dev->phy_dev; + + err = dtsec_enable(get_mac_handle(mac_dev), + COMM_MODE_RX_AND_TX); + + if (!err && phy_dev) + phy_start(phy_dev); + + return err; +} + +static int __cold tgec_start(struct mac_device *mac_dev) +{ + int err; + struct phy_device *phy_dev = mac_dev->phy_dev; + + err = tgec_enable(get_mac_handle(mac_dev), + COMM_MODE_RX_AND_TX); + + if (!err && phy_dev) { + if (phy_dev->drv->read_status) + phy_dev->drv->read_status(phy_dev); + } + + return err; +} + +static int __cold memac_start(struct mac_device *mac_dev) +{ + int err; + struct phy_device *phy_dev = mac_dev->phy_dev; + + err = memac_enable(get_mac_handle(mac_dev), + COMM_MODE_RX_AND_TX); + + if (!err && phy_dev) { + if (macdev2enetinterface(mac_dev) != ENET_MODE_XGMII_10000) + phy_start(phy_dev); + else if (phy_dev->drv->read_status) + phy_dev->drv->read_status(phy_dev); + } + + return err; +} + +static int __cold dtsec_stop(struct mac_device *mac_dev) +{ + if (mac_dev->phy_dev) + phy_stop(mac_dev->phy_dev); + + return dtsec_disable(get_mac_handle(mac_dev), + COMM_MODE_RX_AND_TX); +} + +static int __cold tgec_stop(struct mac_device *mac_dev) +{ + return tgec_disable(get_mac_handle(mac_dev), + COMM_MODE_RX_AND_TX); +} + +static int __cold memac_stop(struct mac_device *mac_dev) +{ + if (mac_dev->phy_dev && (macdev2enetinterface(mac_dev) != + ENET_MODE_XGMII_10000)) + phy_stop(mac_dev->phy_dev); + + return memac_disable(get_mac_handle(mac_dev), + COMM_MODE_RX_AND_TX); +} + +static int __cold set_multi(struct net_device *net_dev, + struct mac_device *mac_dev) +{ + struct mac_priv_s *mac_priv; + struct mac_address *old_addr, *tmp; + struct netdev_hw_addr *ha; + int err; + enet_addr_t *addr; + + mac_priv = macdev_priv(mac_dev); + + /* Clear previous address list */ + list_for_each_entry_safe(old_addr, tmp, &mac_dev->mc_addr_list, list) { + addr = (enet_addr_t *)old_addr->addr; + err = mac_dev->remove_hash_mac_addr(mac_priv->fm_mac, addr); + if (err < 0) + return err; + + list_del(&old_addr->list); + kfree(old_addr); + } + + /* Add all the addresses from the new list */ + netdev_for_each_mc_addr(ha, net_dev) { + addr = (enet_addr_t *)ha->addr; + err = mac_dev->add_hash_mac_addr(mac_priv->fm_mac, addr); + if (err < 0) + return err; + + tmp = kmalloc(sizeof(*tmp), GFP_ATOMIC); + if (!tmp) + return -ENOMEM; + + ether_addr_copy(tmp->addr, ha->addr); + list_add(&tmp->list, &mac_dev->mc_addr_list); + } + return 0; +} + +/* Avoid redundant calls to FMD, if the MAC driver already contains the desired + * active PAUSE settings. Otherwise, the new active settings should be reflected + * in FMan. + */ +int set_mac_active_pause(struct mac_device *mac_dev, bool rx, bool tx) +{ + struct fm_mac_dev *fm_mac_dev = get_mac_handle(mac_dev); + int _errno = 0; + + if (unlikely(rx != mac_dev->rx_pause_active)) { + _errno = mac_dev->set_rx_pause(fm_mac_dev, rx); + if (likely(_errno == 0)) + mac_dev->rx_pause_active = rx; + } + + if (unlikely(tx != mac_dev->tx_pause_active)) { + u16 pause_time = (tx ? FSL_FM_PAUSE_TIME_ENABLE : + FSL_FM_PAUSE_TIME_DISABLE); + + _errno = mac_dev->set_tx_pause(fm_mac_dev, 0, + pause_time, 0); + + if (likely(_errno == 0)) + mac_dev->tx_pause_active = tx; + } + + return _errno; +} +EXPORT_SYMBOL(set_mac_active_pause); + +/* Determine the MAC RX/TX PAUSE frames settings based on PHY + * autonegotiation or values set by eththool. + */ +void get_pause_cfg(struct mac_device *mac_dev, bool *rx_pause, bool *tx_pause) +{ + struct phy_device *phy_dev = mac_dev->phy_dev; + u16 lcl_adv, rmt_adv; + u8 flowctrl; + + *rx_pause = *tx_pause = false; + + if (!phy_dev->duplex) + return; + + /* If PAUSE autonegotiation is disabled, the TX/RX PAUSE settings + * are those set by ethtool. + */ + if (!mac_dev->autoneg_pause) { + *rx_pause = mac_dev->rx_pause_req; + *tx_pause = mac_dev->tx_pause_req; + return; + } + + /* Else if PAUSE autonegotiation is enabled, the TX/RX PAUSE + * settings depend on the result of the link negotiation. + */ + + /* get local capabilities */ + lcl_adv = 0; + if (phy_dev->advertising & ADVERTISED_Pause) + lcl_adv |= ADVERTISE_PAUSE_CAP; + if (phy_dev->advertising & ADVERTISED_Asym_Pause) + lcl_adv |= ADVERTISE_PAUSE_ASYM; + + /* get link partner capabilities */ + rmt_adv = 0; + if (phy_dev->pause) + rmt_adv |= LPA_PAUSE_CAP; + if (phy_dev->asym_pause) + rmt_adv |= LPA_PAUSE_ASYM; + + /* Calculate TX/RX settings based on local and peer advertised + * symmetric/asymmetric PAUSE capabilities. + */ + flowctrl = mii_resolve_flowctrl_fdx(lcl_adv, rmt_adv); + if (flowctrl & FLOW_CTRL_RX) + *rx_pause = true; + if (flowctrl & FLOW_CTRL_TX) + *tx_pause = true; +} +EXPORT_SYMBOL(get_pause_cfg); + +static void adjust_link_dtsec(struct net_device *net_dev) +{ + struct device *dev = net_dev->dev.parent; + struct dpaa_eth_data *eth_data = dev->platform_data; + struct mac_device *mac_dev = eth_data->mac_dev; + struct phy_device *phy_dev = mac_dev->phy_dev; + struct fm_mac_dev *fm_mac_dev; + bool rx_pause, tx_pause; + int err; + + fm_mac_dev = get_mac_handle(mac_dev); + if (!phy_dev->link) { + /* TODO: move in dtsec_an_errata() */ + dtsec_restart_autoneg(fm_mac_dev); + + return; + } + + dtsec_adjust_link(fm_mac_dev, phy_dev->speed); + + get_pause_cfg(mac_dev, &rx_pause, &tx_pause); + err = set_mac_active_pause(mac_dev, rx_pause, tx_pause); + if (unlikely(err < 0)) + netdev_err(net_dev, "set_mac_active_pause() = %d\n", err); +} + +static void adjust_link_memac(struct net_device *net_dev) +{ + struct device *dev = net_dev->dev.parent; + struct dpaa_eth_data *eth_data = dev->platform_data; + struct mac_device *mac_dev = eth_data->mac_dev; + struct phy_device *phy_dev = mac_dev->phy_dev; + struct fm_mac_dev *fm_mac_dev; + bool rx_pause, tx_pause; + int err; + + fm_mac_dev = get_mac_handle(mac_dev); + memac_adjust_link(fm_mac_dev, phy_dev->speed); + + get_pause_cfg(mac_dev, &rx_pause, &tx_pause); + err = set_mac_active_pause(mac_dev, rx_pause, tx_pause); + if (unlikely(err < 0)) + netdev_err(net_dev, "set_mac_active_pause() = %d\n", err); +} + +/* Initializes driver's PHY state, and attaches to the PHY. + * Returns 0 on success. + */ +static int dtsec_init_phy(struct net_device *net_dev, + struct mac_device *mac_dev) +{ + struct phy_device *phy_dev; + + if (!mac_dev->phy_node) + phy_dev = phy_connect(net_dev, mac_dev->fixed_bus_id, + &adjust_link_dtsec, mac_dev->phy_if); + else + phy_dev = of_phy_connect(net_dev, mac_dev->phy_node, + &adjust_link_dtsec, 0, + mac_dev->phy_if); + if (unlikely(!phy_dev) || IS_ERR(phy_dev)) { + netdev_err(net_dev, "Could not connect to PHY %s\n", + mac_dev->phy_node ? + mac_dev->phy_node->full_name : + mac_dev->fixed_bus_id); + return (!phy_dev) ? -ENODEV : PTR_ERR(phy_dev); + } + + /* Remove any features not supported by the controller */ + phy_dev->supported &= mac_dev->if_support; + /* Enable the symmetric and asymmetric PAUSE frame advertisements, + * as most of the PHY drivers do not enable them by default. + */ + phy_dev->supported |= (SUPPORTED_Pause | SUPPORTED_Asym_Pause); + phy_dev->advertising = phy_dev->supported; + + mac_dev->phy_dev = phy_dev; + + return 0; +} + +static int xgmac_init_phy(struct net_device *net_dev, + struct mac_device *mac_dev) +{ + struct phy_device *phy_dev; + + if (!mac_dev->phy_node) + phy_dev = phy_attach(net_dev, mac_dev->fixed_bus_id, + mac_dev->phy_if); + else + phy_dev = of_phy_attach(net_dev, mac_dev->phy_node, 0, + mac_dev->phy_if); + if (unlikely(!phy_dev) || IS_ERR(phy_dev)) { + netdev_err(net_dev, "Could not attach to PHY %s\n", + mac_dev->phy_node ? + mac_dev->phy_node->full_name : + mac_dev->fixed_bus_id); + return (!phy_dev) ? -ENODEV : PTR_ERR(phy_dev); + } + + phy_dev->supported &= mac_dev->if_support; + /* Enable the symmetric and asymmetric PAUSE frame advertisements, + * as most of the PHY drivers do not enable them by default. + */ + phy_dev->supported |= (SUPPORTED_Pause | SUPPORTED_Asym_Pause); + phy_dev->advertising = phy_dev->supported; + + mac_dev->phy_dev = phy_dev; + + return 0; +} + +static int memac_init_phy(struct net_device *net_dev, + struct mac_device *mac_dev) +{ + struct phy_device *phy_dev; + + if (macdev2enetinterface(mac_dev) == ENET_MODE_XGMII_10000) { + if (!mac_dev->phy_node) { + mac_dev->phy_dev = NULL; + return 0; + } + + phy_dev = of_phy_attach(net_dev, mac_dev->phy_node, 0, + mac_dev->phy_if); + } else { + if (!mac_dev->phy_node) + phy_dev = phy_connect(net_dev, mac_dev->fixed_bus_id, + &adjust_link_memac, + mac_dev->phy_if); + else + phy_dev = of_phy_connect(net_dev, mac_dev->phy_node, + &adjust_link_memac, 0, + mac_dev->phy_if); + } + + if (unlikely(!phy_dev) || IS_ERR(phy_dev)) { + netdev_err(net_dev, "Could not connect to PHY %s\n", + mac_dev->phy_node ? + mac_dev->phy_node->full_name : + mac_dev->fixed_bus_id); + return (!phy_dev) ? -ENODEV : PTR_ERR(phy_dev); + } + + /* Remove any features not supported by the controller */ + phy_dev->supported &= mac_dev->if_support; + /* Enable the symmetric and asymmetric PAUSE frame advertisements, + * as most of the PHY drivers do not enable them by default. + */ + phy_dev->supported |= (SUPPORTED_Pause | SUPPORTED_Asym_Pause); + phy_dev->advertising = phy_dev->supported; + + mac_dev->phy_dev = phy_dev; + + return 0; +} + +static int __cold dtsec_uninit(struct fm_mac_dev *fm_mac_dev) +{ + int err, err1; + + err = dtsec_disable(fm_mac_dev, COMM_MODE_RX_AND_TX); + err1 = dtsec_free(fm_mac_dev); + + if (unlikely(err1 < 0)) + err = err1; + + return err; +} + +static int __cold tgec_uninit(struct fm_mac_dev *fm_mac_dev) +{ + int err, err1; + + err = tgec_disable(fm_mac_dev, COMM_MODE_RX_AND_TX); + err1 = tgec_free(fm_mac_dev); + + if (unlikely(err1 < 0)) + err = err1; + + return err; +} + +static int __cold memac_uninit(struct fm_mac_dev *fm_mac_dev) +{ + int err, err1; + + err = memac_disable(fm_mac_dev, COMM_MODE_RX_AND_TX); + err1 = memac_free(fm_mac_dev); + + if (unlikely(err1 < 0)) + err = err1; + + return err; +} + +static void __cold setup_dtsec(struct mac_device *mac_dev) +{ + mac_dev->init_phy = dtsec_init_phy; + mac_dev->init = dtsec_initialization; + mac_dev->start = dtsec_start; + mac_dev->stop = dtsec_stop; + mac_dev->set_promisc = dtsec_set_promiscuous; + mac_dev->change_addr = dtsec_modify_mac_address; + mac_dev->add_hash_mac_addr = dtsec_add_hash_mac_address; + mac_dev->remove_hash_mac_addr = dtsec_del_hash_mac_address; + mac_dev->set_multi = set_multi; + mac_dev->uninit = dtsec_uninit; + mac_dev->set_tx_pause = dtsec_set_tx_pause_frames; + mac_dev->set_rx_pause = dtsec_accept_rx_pause_frames; + mac_dev->set_exception = dtsec_set_exception; +} + +static void __cold setup_xgmac(struct mac_device *mac_dev) +{ + mac_dev->init_phy = xgmac_init_phy; + mac_dev->init = tgec_initialization; + mac_dev->start = tgec_start; + mac_dev->stop = tgec_stop; + mac_dev->set_promisc = tgec_set_promiscuous; + mac_dev->change_addr = tgec_modify_mac_address; + mac_dev->add_hash_mac_addr = tgec_add_hash_mac_address; + mac_dev->remove_hash_mac_addr = tgec_del_hash_mac_address; + mac_dev->set_multi = set_multi; + mac_dev->uninit = tgec_uninit; + mac_dev->set_tx_pause = tgec_set_tx_pause_frames; + mac_dev->set_rx_pause = tgec_accept_rx_pause_frames; + mac_dev->set_exception = tgec_set_exception; +} + +static void __cold setup_memac(struct mac_device *mac_dev) +{ + mac_dev->init_phy = memac_init_phy; + mac_dev->init = memac_initialization; + mac_dev->start = memac_start; + mac_dev->stop = memac_stop; + mac_dev->set_promisc = memac_set_promiscuous; + mac_dev->change_addr = memac_modify_mac_address; + mac_dev->add_hash_mac_addr = memac_add_hash_mac_address; + mac_dev->remove_hash_mac_addr = memac_del_hash_mac_address; + mac_dev->set_multi = set_multi; + mac_dev->uninit = memac_uninit; + mac_dev->set_tx_pause = memac_set_tx_pause_frames; + mac_dev->set_rx_pause = memac_accept_rx_pause_frames; + mac_dev->set_exception = memac_set_exception; +} + +void (*const mac_setup[])(struct mac_device *mac_dev) = { + [DTSEC] = setup_dtsec, + [XGMAC] = setup_xgmac, + [MEMAC] = setup_memac +}; diff --git a/drivers/net/ethernet/freescale/fman/mac/mac.c b/drivers/net/ethernet/freescale/fman/mac/mac.c new file mode 100644 index 0000000..d1f12092 --- /dev/null +++ b/drivers/net/ethernet/freescale/fman/mac/mac.c @@ -0,0 +1,526 @@ +/* Copyright 2008-2015 Freescale Semiconductor, Inc. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of Freescale Semiconductor nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * + * ALTERNATIVELY, this software may be distributed under the terms of the + * GNU General Public License ("GPL") as published by the Free Software + * Foundation, either version 2 of that License or (at your option) any + * later version. + * + * THIS SOFTWARE IS PROVIDED BY Freescale Semiconductor ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL Freescale Semiconductor BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifdef CONFIG_FSL_DPAA_ETH_DEBUG +#define pr_fmt(fmt) \ + KBUILD_MODNAME ": %s:%hu:%s() " fmt, \ + KBUILD_BASENAME ".c", __LINE__, __func__ +#else +#define pr_fmt(fmt) \ + KBUILD_MODNAME ": " fmt +#endif + +#include +#include +#include +#include +#include +#include +#include + +#include "mac.h" + +#define DTSEC_SUPPORTED \ + (SUPPORTED_10baseT_Half \ + | SUPPORTED_10baseT_Full \ + | SUPPORTED_100baseT_Half \ + | SUPPORTED_100baseT_Full \ + | SUPPORTED_Autoneg \ + | SUPPORTED_Pause \ + | SUPPORTED_Asym_Pause \ + | SUPPORTED_MII) + +static DEFINE_MUTEX(eth_lock); + +static const char phy_str[][11] = { + [PHY_INTERFACE_MODE_MII] = "mii", + [PHY_INTERFACE_MODE_GMII] = "gmii", + [PHY_INTERFACE_MODE_SGMII] = "sgmii", + [PHY_INTERFACE_MODE_TBI] = "tbi", + [PHY_INTERFACE_MODE_RMII] = "rmii", + [PHY_INTERFACE_MODE_RGMII] = "rgmii", + [PHY_INTERFACE_MODE_RGMII_ID] = "rgmii-id", + [PHY_INTERFACE_MODE_RGMII_RXID] = "rgmii-rxid", + [PHY_INTERFACE_MODE_RGMII_TXID] = "rgmii-txid", + [PHY_INTERFACE_MODE_RTBI] = "rtbi", + [PHY_INTERFACE_MODE_XGMII] = "xgmii" +}; + +static phy_interface_t __pure __attribute__((nonnull)) str2phy(const char *str) +{ + int i; + + for (i = 0; i < ARRAY_SIZE(phy_str); i++) + if (strcmp(str, phy_str[i]) == 0) + return (phy_interface_t)i; + + return PHY_INTERFACE_MODE_MII; +} + +static const u16 phy2speed[] = { + [PHY_INTERFACE_MODE_MII] = SPEED_100, + [PHY_INTERFACE_MODE_GMII] = SPEED_1000, + [PHY_INTERFACE_MODE_SGMII] = SPEED_1000, + [PHY_INTERFACE_MODE_TBI] = SPEED_1000, + [PHY_INTERFACE_MODE_RMII] = SPEED_100, + [PHY_INTERFACE_MODE_RGMII] = SPEED_1000, + [PHY_INTERFACE_MODE_RGMII_ID] = SPEED_1000, + [PHY_INTERFACE_MODE_RGMII_RXID] = SPEED_1000, + [PHY_INTERFACE_MODE_RGMII_TXID] = SPEED_1000, + [PHY_INTERFACE_MODE_RTBI] = SPEED_1000, + [PHY_INTERFACE_MODE_XGMII] = SPEED_10000 +}; + +static struct mac_device * __cold +alloc_macdev(struct device *dev, size_t sizeof_priv, + void (*setup)(struct mac_device *mac_dev)) +{ + struct mac_device *mac_dev; + + mac_dev = devm_kzalloc(dev, sizeof(*mac_dev) + sizeof_priv, GFP_KERNEL); + if (unlikely(!mac_dev)) { + mac_dev = ERR_PTR(-ENOMEM); + } else { + mac_dev->dev = dev; + dev_set_drvdata(dev, mac_dev); + setup(mac_dev); + } + + return mac_dev; +} + +static int __cold free_macdev(struct mac_device *mac_dev) +{ + dev_set_drvdata(mac_dev->dev, NULL); + + return mac_dev->uninit(get_mac_handle(mac_dev)); +} + +static struct platform_device *dpaa_eth_add_device(int fman_id, + struct mac_device *mac_dev, + struct device_node *node) +{ + struct platform_device *pdev; + struct dpaa_eth_data data; + static int dpaa_eth_dev_cnt; + int ret; + + data.mac_dev = mac_dev; + data.mac_hw_id = mac_dev->cell_index; + data.fman_hw_id = fman_id; + data.mac_node = node; + + mutex_lock(ð_lock); + + pdev = platform_device_alloc("dpaa-ethernet", dpaa_eth_dev_cnt); + if (!pdev) { + ret = -ENOMEM; + goto no_mem; + } + + ret = platform_device_add_data(pdev, &data, sizeof(data)); + if (ret) + goto err; + + ret = platform_device_add(pdev); + if (ret) + goto err; + + dpaa_eth_dev_cnt++; + mutex_unlock(ð_lock); + + return pdev; + +err: + platform_device_put(pdev); +no_mem: + mutex_unlock(ð_lock); + + return ERR_PTR(ret); +} + +static void dpaa_eth_remove_device(struct platform_device *pdev) +{ + platform_device_unregister(pdev); +} + +static const struct of_device_id mac_match[] = { + [DTSEC] = { + .compatible = "fsl,fman-dtsec" + }, + [XGMAC] = { + .compatible = "fsl,fman-xgec" + }, + [MEMAC] = { + .compatible = "fsl,fman-memac" + }, + {} +}; +MODULE_DEVICE_TABLE(of, mac_match); + +static int __cold mac_probe(struct platform_device *_of_dev) +{ + int _errno, i, lenp; + struct device *dev; + struct device_node *mac_node, *dev_node; + struct mac_device *mac_dev; + struct platform_device *of_dev; + struct resource res; + const u8 *mac_addr; + const char *char_prop; + const u32 *uint32_prop; + const struct of_device_id *match; + u8 fman_id; + + const phandle *phandle_prop; + + dev = &_of_dev->dev; + mac_node = dev->of_node; + + match = of_match_device(mac_match, dev); + if (!match) + return -EINVAL; + + for (i = 0; i < ARRAY_SIZE(mac_match) - 1 && match != mac_match + i; + i++) + ; + BUG_ON(i >= ARRAY_SIZE(mac_match) - 1); + + mac_dev = alloc_macdev(dev, mac_sizeof_priv[i], mac_setup[i]); + if (IS_ERR(mac_dev)) { + _errno = PTR_ERR(mac_dev); + dev_err(dev, "alloc_macdev() = %d\n", _errno); + goto _return; + } + + INIT_LIST_HEAD(&mac_dev->mc_addr_list); + + /* Get the FM node */ + dev_node = of_get_parent(mac_node); + if (unlikely(!dev_node)) { + dev_err(dev, "of_get_parent(%s) failed\n", + mac_node->full_name); + _errno = -EINVAL; + goto _return_dev_set_drvdata; + } + + of_dev = of_find_device_by_node(dev_node); + if (unlikely(!of_dev)) { + dev_err(dev, "of_find_device_by_node(%s) failed\n", + dev_node->full_name); + _errno = -EINVAL; + goto _return_of_node_put; + } + + /* Get the FMan cell-index */ + uint32_prop = of_get_property(dev_node, "cell-index", &lenp); + if (unlikely(!uint32_prop)) { + dev_err(dev, "of_get_property(%s, cell-index) failed\n", + dev_node->full_name); + _errno = -EINVAL; + goto _return_of_node_put; + } + BUG_ON(lenp != sizeof(u32)); + fman_id = (u8)*uint32_prop + 1; /* cell-index 0 => FMan id 1 */ + + mac_dev->fm_dev = fm_bind(&of_dev->dev); + if (unlikely(!mac_dev->fm_dev)) { + dev_err(dev, "fm_bind(%s) failed\n", dev_node->full_name); + _errno = -ENODEV; + goto _return_of_node_put; + } + + mac_dev->fm = (void *)fm_get_handle(mac_dev->fm_dev); + of_node_put(dev_node); + + /* Get the address of the memory mapped registers */ + _errno = of_address_to_resource(mac_node, 0, &res); + if (unlikely(_errno < 0)) { + dev_err(dev, "of_address_to_resource(%s) = %d\n", + mac_node->full_name, _errno); + goto _return_dev_set_drvdata; + } + + mac_dev->res = + __devm_request_region(dev, fm_get_mem_region(mac_dev->fm_dev), + res.start, res.end + 1 - res.start, + "mac"); + if (unlikely(!mac_dev->res)) { + dev_err(dev, "__devm_request_mem_region(mac) failed\n"); + _errno = -EBUSY; + goto _return_dev_set_drvdata; + } + + mac_dev->vaddr = devm_ioremap(dev, mac_dev->res->start, + mac_dev->res->end + 1 + - mac_dev->res->start); + if (unlikely(!mac_dev->vaddr)) { + dev_err(dev, "devm_ioremap() failed\n"); + _errno = -EIO; + goto _return_dev_set_drvdata; + } + +#define TBIPA_OFFSET 0x1c +#define TBIPA_DEFAULT_ADDR 5 /* override if used as external PHY addr. */ + mac_dev->tbi_node = of_parse_phandle(mac_node, "tbi-handle", 0); + if (mac_dev->tbi_node) { + u32 tbiaddr = TBIPA_DEFAULT_ADDR; + + uint32_prop = of_get_property(mac_dev->tbi_node, "reg", NULL); + if (uint32_prop) + tbiaddr = *uint32_prop; + out_be32(mac_dev->vaddr + TBIPA_OFFSET, tbiaddr); + } + + if (!of_device_is_available(mac_node)) { + devm_iounmap(dev, mac_dev->vaddr); + __devm_release_region(dev, fm_get_mem_region(mac_dev->fm_dev), + res.start, res.end + 1 - res.start); + fm_unbind(mac_dev->fm_dev); + devm_kfree(dev, mac_dev); + dev_set_drvdata(dev, NULL); + return -ENODEV; + } + + /* Get the cell-index */ + uint32_prop = of_get_property(mac_node, "cell-index", &lenp); + if (unlikely(!uint32_prop)) { + dev_err(dev, "of_get_property(%s, cell-index) failed\n", + mac_node->full_name); + _errno = -EINVAL; + goto _return_dev_set_drvdata; + } + BUG_ON(lenp != sizeof(u32)); + mac_dev->cell_index = (u8)*uint32_prop; + + /* Get the MAC address */ + mac_addr = of_get_mac_address(mac_node); + if (unlikely(!mac_addr)) { + dev_err(dev, "of_get_mac_address(%s) failed\n", + mac_node->full_name); + _errno = -EINVAL; + goto _return_dev_set_drvdata; + } + memcpy(mac_dev->addr, mac_addr, sizeof(mac_dev->addr)); + + /* Get the port handles */ + phandle_prop = of_get_property(mac_node, "fsl,fman-ports", &lenp); + if (unlikely(!phandle_prop)) { + dev_err(dev, "of_get_property(%s, fsl,fman-ports) failed\n", + mac_node->full_name); + _errno = -EINVAL; + goto _return_dev_set_drvdata; + } + BUG_ON(lenp != sizeof(phandle) * ARRAY_SIZE(mac_dev->port_dev)); + + for_each_port_device(i, mac_dev->port_dev) { + /* Find the port node */ + dev_node = of_find_node_by_phandle(phandle_prop[i]); + if (unlikely(!dev_node)) { + dev_err(dev, "of_find_node_by_phandle() failed\n"); + _errno = -EINVAL; + goto _return_of_node_put; + } + + of_dev = of_find_device_by_node(dev_node); + if (unlikely(!of_dev)) { + dev_err(dev, "of_find_device_by_node(%s) failed\n", + dev_node->full_name); + _errno = -EINVAL; + goto _return_of_node_put; + } + + mac_dev->port_dev[i] = fm_port_bind(&of_dev->dev); + if (unlikely(!mac_dev->port_dev[i])) { + dev_err(dev, "dev_get_drvdata(%s) failed\n", + dev_node->full_name); + _errno = -EINVAL; + goto _return_of_node_put; + } + of_node_put(dev_node); + } + + /* Get the PHY connection type */ + char_prop = (const char *)of_get_property(mac_node, + "phy-connection-type", NULL); + if (unlikely(!char_prop)) { + dev_warn(dev, + "of_get_property(%s, phy-connection-type) failed. Defaulting to MII\n", + mac_node->full_name); + mac_dev->phy_if = PHY_INTERFACE_MODE_MII; + } else { + mac_dev->phy_if = str2phy(char_prop); + } + + mac_dev->link = false; + mac_dev->speed = phy2speed[mac_dev->phy_if]; + mac_dev->max_speed = mac_dev->speed; + mac_dev->if_support = DTSEC_SUPPORTED; + /* We don't support half-duplex in SGMII mode */ + if (strstr(char_prop, "sgmii")) + mac_dev->if_support &= ~(SUPPORTED_10baseT_Half | + SUPPORTED_100baseT_Half); + + /* Gigabit support (no half-duplex) */ + if (mac_dev->max_speed == 1000) + mac_dev->if_support |= SUPPORTED_1000baseT_Full; + + /* The 10G interface only supports one mode */ + if (strstr(char_prop, "xgmii")) + mac_dev->if_support = SUPPORTED_10000baseT_Full; + + /* Get the rest of the PHY information */ + mac_dev->phy_node = of_parse_phandle(mac_node, "phy-handle", 0); + if (!mac_dev->phy_node) { + int sz; + const u32 *phy_id = of_get_property(mac_node, "fixed-link", + &sz); + if (!phy_id || sz < sizeof(*phy_id)) { + dev_err(dev, "No PHY (or fixed link) found\n"); + _errno = -EINVAL; + goto _return_dev_set_drvdata; + } + + sprintf(mac_dev->fixed_bus_id, PHY_ID_FMT, "fixed-0", + phy_id[0]); + } + + _errno = mac_dev->init(mac_dev); + if (unlikely(_errno < 0)) { + dev_err(dev, "mac_dev->init() = %d\n", _errno); + goto _return_dev_set_drvdata; + } + + /* pause frame autonegotiation enabled*/ + mac_dev->autoneg_pause = true; + + /* by intializing the values to false, force FMD to enable PAUSE frames + * on RX and TX + */ + mac_dev->rx_pause_req = true; + mac_dev->tx_pause_req = true; + mac_dev->rx_pause_active = false; + mac_dev->tx_pause_active = false; + _errno = set_mac_active_pause(mac_dev, true, true); + if (unlikely(_errno < 0)) + dev_err(dev, "set_mac_active_pause() = %d\n", _errno); + + dev_info(dev, + "FMan MAC address: %02hx:%02hx:%02hx:%02hx:%02hx:%02hx\n", + mac_dev->addr[0], mac_dev->addr[1], mac_dev->addr[2], + mac_dev->addr[3], mac_dev->addr[4], mac_dev->addr[5]); + + mac_dev->eth_dev = dpaa_eth_add_device(fman_id, mac_dev, + mac_node); + if (IS_ERR(mac_dev->eth_dev)) { + dev_err(dev, "failed to add Ethernet platform device for MAC %d\n", + mac_dev->cell_index); + mac_dev->eth_dev = NULL; + } + + goto _return; + +_return_of_node_put: + of_node_put(dev_node); +_return_dev_set_drvdata: + dev_set_drvdata(dev, NULL); +_return: + return _errno; +} + +static int __cold mac_remove(struct platform_device *of_dev) +{ + int i, _errno; + struct device *dev; + struct mac_device *mac_dev; + + dev = &of_dev->dev; + mac_dev = (struct mac_device *)dev_get_drvdata(dev); + + dpaa_eth_remove_device(mac_dev->eth_dev); + + for_each_port_device(i, mac_dev->port_dev) + fm_port_unbind(mac_dev->port_dev[i]); + + fm_unbind(mac_dev->fm_dev); + + _errno = free_macdev(mac_dev); + + return _errno; +} + +static struct platform_driver mac_driver = { + .driver = { + .name = KBUILD_MODNAME, + .of_match_table = mac_match, + }, + .probe = mac_probe, + .remove = mac_remove +}; + +static int __init __cold mac_load(void) +{ + int _errno; + + pr_debug(KBUILD_MODNAME ": -> %s:%s()\n", + KBUILD_BASENAME ".c", __func__); + + pr_info(KBUILD_MODNAME ": %s\n", + mac_driver_description); + + _errno = platform_driver_register(&mac_driver); + if (unlikely(_errno < 0)) { + pr_err(KBUILD_MODNAME ": %s:%hu:%s(): platform_driver_register() = %d\n", + KBUILD_BASENAME ".c", __LINE__, __func__, _errno); + goto _return; + } + + goto _return; + +_return: + pr_debug(KBUILD_MODNAME ": %s:%s() ->\n", + KBUILD_BASENAME ".c", __func__); + + return _errno; +} +module_init(mac_load); + +static void __exit __cold mac_unload(void) +{ + pr_debug(KBUILD_MODNAME ": -> %s:%s()\n", + KBUILD_BASENAME ".c", __func__); + + platform_driver_unregister(&mac_driver); + + pr_debug(KBUILD_MODNAME ": %s:%s() ->\n", + KBUILD_BASENAME ".c", __func__); +} +module_exit(mac_unload);