Giuseppe CAVALLARO | bfab27a | 2011-12-21 03:58:19 +0000 | [diff] [blame] | 1 | /******************************************************************************* |
| 2 | This contains the functions to handle the platform driver. |
| 3 | |
| 4 | Copyright (C) 2007-2011 STMicroelectronics Ltd |
| 5 | |
| 6 | This program is free software; you can redistribute it and/or modify it |
| 7 | under the terms and conditions of the GNU General Public License, |
| 8 | version 2, as published by the Free Software Foundation. |
| 9 | |
| 10 | This program is distributed in the hope it will be useful, but WITHOUT |
| 11 | ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| 12 | FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for |
| 13 | more details. |
| 14 | |
| 15 | You should have received a copy of the GNU General Public License along with |
| 16 | this program; if not, write to the Free Software Foundation, Inc., |
| 17 | 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA. |
| 18 | |
| 19 | The full GNU General Public License is included in this distribution in |
| 20 | the file called "COPYING". |
| 21 | |
| 22 | Author: Giuseppe Cavallaro <peppe.cavallaro@st.com> |
| 23 | *******************************************************************************/ |
| 24 | |
| 25 | #include <linux/platform_device.h> |
Paul Gortmaker | f0e9fc5 | 2015-04-30 21:47:42 -0400 | [diff] [blame] | 26 | #include <linux/module.h> |
Giuseppe CAVALLARO | bfab27a | 2011-12-21 03:58:19 +0000 | [diff] [blame] | 27 | #include <linux/io.h> |
Stefan Roese | 6a22845 | 2012-03-13 04:56:37 +0000 | [diff] [blame] | 28 | #include <linux/of.h> |
| 29 | #include <linux/of_net.h> |
Chen-Yu Tsai | 022066f | 2014-01-17 21:24:46 +0800 | [diff] [blame] | 30 | #include <linux/of_device.h> |
Mathieu Olivari | 5790cf3 | 2015-05-27 11:02:47 -0700 | [diff] [blame] | 31 | #include <linux/of_mdio.h> |
Andy Shevchenko | f10f9fb | 2014-11-07 16:46:42 +0200 | [diff] [blame] | 32 | |
Giuseppe CAVALLARO | bfab27a | 2011-12-21 03:58:19 +0000 | [diff] [blame] | 33 | #include "stmmac.h" |
Andy Shevchenko | f10f9fb | 2014-11-07 16:46:42 +0200 | [diff] [blame] | 34 | #include "stmmac_platform.h" |
Giuseppe CAVALLARO | bfab27a | 2011-12-21 03:58:19 +0000 | [diff] [blame] | 35 | |
Stefan Roese | 6a22845 | 2012-03-13 04:56:37 +0000 | [diff] [blame] | 36 | #ifdef CONFIG_OF |
Vince Bridgers | 3b57de9 | 2014-07-31 15:49:17 -0500 | [diff] [blame] | 37 | |
Giuseppe CAVALLARO | 732fdf0 | 2014-11-18 09:47:01 +0100 | [diff] [blame] | 38 | /** |
| 39 | * dwmac1000_validate_mcast_bins - validates the number of Multicast filter bins |
| 40 | * @mcast_bins: Multicast filtering bins |
| 41 | * Description: |
| 42 | * this function validates the number of Multicast filtering bins specified |
Vince Bridgers | 3b57de9 | 2014-07-31 15:49:17 -0500 | [diff] [blame] | 43 | * by the configuration through the device tree. The Synopsys GMAC supports |
| 44 | * 64 bins, 128 bins, or 256 bins. "bins" refer to the division of CRC |
| 45 | * number space. 64 bins correspond to 6 bits of the CRC, 128 corresponds |
| 46 | * to 7 bits, and 256 refers to 8 bits of the CRC. Any other setting is |
| 47 | * invalid and will cause the filtering algorithm to use Multicast |
| 48 | * promiscuous mode. |
| 49 | */ |
| 50 | static int dwmac1000_validate_mcast_bins(int mcast_bins) |
| 51 | { |
| 52 | int x = mcast_bins; |
| 53 | |
| 54 | switch (x) { |
| 55 | case HASH_TABLE_SIZE: |
| 56 | case 128: |
| 57 | case 256: |
| 58 | break; |
| 59 | default: |
| 60 | x = 0; |
| 61 | pr_info("Hash table entries set to unexpected value %d", |
| 62 | mcast_bins); |
| 63 | break; |
| 64 | } |
| 65 | return x; |
| 66 | } |
| 67 | |
Giuseppe CAVALLARO | 732fdf0 | 2014-11-18 09:47:01 +0100 | [diff] [blame] | 68 | /** |
| 69 | * dwmac1000_validate_ucast_entries - validate the Unicast address entries |
| 70 | * @ucast_entries: number of Unicast address entries |
| 71 | * Description: |
| 72 | * This function validates the number of Unicast address entries supported |
Vince Bridgers | 3b57de9 | 2014-07-31 15:49:17 -0500 | [diff] [blame] | 73 | * by a particular Synopsys 10/100/1000 controller. The Synopsys controller |
| 74 | * supports 1, 32, 64, or 128 Unicast filter entries for it's Unicast filter |
| 75 | * logic. This function validates a valid, supported configuration is |
| 76 | * selected, and defaults to 1 Unicast address if an unsupported |
| 77 | * configuration is selected. |
| 78 | */ |
| 79 | static int dwmac1000_validate_ucast_entries(int ucast_entries) |
| 80 | { |
| 81 | int x = ucast_entries; |
| 82 | |
| 83 | switch (x) { |
| 84 | case 1: |
| 85 | case 32: |
| 86 | case 64: |
| 87 | case 128: |
| 88 | break; |
| 89 | default: |
| 90 | x = 1; |
| 91 | pr_info("Unicast table entries set to unexpected value %d\n", |
| 92 | ucast_entries); |
| 93 | break; |
| 94 | } |
| 95 | return x; |
| 96 | } |
| 97 | |
Giuseppe CAVALLARO | 732fdf0 | 2014-11-18 09:47:01 +0100 | [diff] [blame] | 98 | /** |
Giuseppe Cavallaro | afea036 | 2016-02-29 14:27:28 +0100 | [diff] [blame] | 99 | * stmmac_axi_setup - parse DT parameters for programming the AXI register |
| 100 | * @pdev: platform device |
| 101 | * @priv: driver private struct. |
| 102 | * Description: |
| 103 | * if required, from device-tree the AXI internal register can be tuned |
| 104 | * by using platform parameters. |
| 105 | */ |
| 106 | static struct stmmac_axi *stmmac_axi_setup(struct platform_device *pdev) |
| 107 | { |
| 108 | struct device_node *np; |
| 109 | struct stmmac_axi *axi; |
| 110 | |
| 111 | np = of_parse_phandle(pdev->dev.of_node, "snps,axi-config", 0); |
| 112 | if (!np) |
| 113 | return NULL; |
| 114 | |
Wu Fengguang | 4c3e962 | 2016-03-03 09:55:19 +0800 | [diff] [blame] | 115 | axi = kzalloc(sizeof(*axi), GFP_KERNEL); |
Peter Chen | 4613b27 | 2016-08-01 15:02:42 +0800 | [diff] [blame] | 116 | if (!axi) { |
| 117 | of_node_put(np); |
Giuseppe Cavallaro | afea036 | 2016-02-29 14:27:28 +0100 | [diff] [blame] | 118 | return ERR_PTR(-ENOMEM); |
Peter Chen | 4613b27 | 2016-08-01 15:02:42 +0800 | [diff] [blame] | 119 | } |
Giuseppe Cavallaro | afea036 | 2016-02-29 14:27:28 +0100 | [diff] [blame] | 120 | |
| 121 | axi->axi_lpi_en = of_property_read_bool(np, "snps,lpi_en"); |
| 122 | axi->axi_xit_frm = of_property_read_bool(np, "snps,xit_frm"); |
| 123 | axi->axi_kbbe = of_property_read_bool(np, "snps,axi_kbbe"); |
| 124 | axi->axi_axi_all = of_property_read_bool(np, "snps,axi_all"); |
| 125 | axi->axi_fb = of_property_read_bool(np, "snps,axi_fb"); |
| 126 | axi->axi_mb = of_property_read_bool(np, "snps,axi_mb"); |
| 127 | axi->axi_rb = of_property_read_bool(np, "snps,axi_rb"); |
| 128 | |
| 129 | of_property_read_u32(np, "snps,wr_osr_lmt", &axi->axi_wr_osr_lmt); |
| 130 | of_property_read_u32(np, "snps,rd_osr_lmt", &axi->axi_rd_osr_lmt); |
| 131 | of_property_read_u32_array(np, "snps,blen", axi->axi_blen, AXI_BLEN); |
Peter Chen | 4613b27 | 2016-08-01 15:02:42 +0800 | [diff] [blame] | 132 | of_node_put(np); |
Giuseppe Cavallaro | afea036 | 2016-02-29 14:27:28 +0100 | [diff] [blame] | 133 | |
| 134 | return axi; |
| 135 | } |
| 136 | |
| 137 | /** |
Giuseppe CAVALLARO | a7657f1 | 2016-04-01 09:07:16 +0200 | [diff] [blame] | 138 | * stmmac_dt_phy - parse device-tree driver parameters to allocate PHY resources |
| 139 | * @plat: driver data platform structure |
| 140 | * @np: device tree node |
| 141 | * @dev: device pointer |
| 142 | * Description: |
| 143 | * The mdio bus will be allocated in case of a phy transceiver is on board; |
| 144 | * it will be NULL if the fixed-link is configured. |
| 145 | * If there is the "snps,dwmac-mdio" sub-node the mdio will be allocated |
| 146 | * in any case (for DSA, mdio must be registered even if fixed-link). |
| 147 | * The table below sums the supported configurations: |
| 148 | * ------------------------------- |
| 149 | * snps,phy-addr | Y |
| 150 | * ------------------------------- |
| 151 | * phy-handle | Y |
| 152 | * ------------------------------- |
| 153 | * fixed-link | N |
| 154 | * ------------------------------- |
| 155 | * snps,dwmac-mdio | |
| 156 | * even if | Y |
| 157 | * fixed-link | |
| 158 | * ------------------------------- |
| 159 | * |
| 160 | * It returns 0 in case of success otherwise -ENODEV. |
| 161 | */ |
| 162 | static int stmmac_dt_phy(struct plat_stmmacenet_data *plat, |
| 163 | struct device_node *np, struct device *dev) |
| 164 | { |
| 165 | bool mdio = true; |
| 166 | |
| 167 | /* If phy-handle property is passed from DT, use it as the PHY */ |
| 168 | plat->phy_node = of_parse_phandle(np, "phy-handle", 0); |
| 169 | if (plat->phy_node) |
| 170 | dev_dbg(dev, "Found phy-handle subnode\n"); |
| 171 | |
| 172 | /* If phy-handle is not specified, check if we have a fixed-phy */ |
| 173 | if (!plat->phy_node && of_phy_is_fixed_link(np)) { |
| 174 | if ((of_phy_register_fixed_link(np) < 0)) |
| 175 | return -ENODEV; |
| 176 | |
| 177 | dev_dbg(dev, "Found fixed-link subnode\n"); |
| 178 | plat->phy_node = of_node_get(np); |
| 179 | mdio = false; |
| 180 | } |
| 181 | |
| 182 | /* If snps,dwmac-mdio is passed from DT, always register the MDIO */ |
| 183 | for_each_child_of_node(np, plat->mdio_node) { |
| 184 | if (of_device_is_compatible(plat->mdio_node, "snps,dwmac-mdio")) |
| 185 | break; |
| 186 | } |
| 187 | |
| 188 | if (plat->mdio_node) { |
| 189 | dev_dbg(dev, "Found MDIO subnode\n"); |
| 190 | mdio = true; |
| 191 | } |
| 192 | |
| 193 | if (mdio) |
| 194 | plat->mdio_bus_data = |
| 195 | devm_kzalloc(dev, sizeof(struct stmmac_mdio_bus_data), |
| 196 | GFP_KERNEL); |
| 197 | return 0; |
| 198 | } |
| 199 | |
| 200 | /** |
Giuseppe CAVALLARO | 732fdf0 | 2014-11-18 09:47:01 +0100 | [diff] [blame] | 201 | * stmmac_probe_config_dt - parse device-tree driver parameters |
| 202 | * @pdev: platform_device structure |
| 203 | * @plat: driver data platform structure |
| 204 | * @mac: MAC address to use |
| 205 | * Description: |
| 206 | * this function is to read the driver parameters from device-tree and |
| 207 | * set some private fields that will be used by the main at runtime. |
| 208 | */ |
Joachim Eastwood | 402dae0 | 2015-07-17 00:26:09 +0200 | [diff] [blame] | 209 | struct plat_stmmacenet_data * |
Joachim Eastwood | b0003ea | 2015-07-17 00:26:08 +0200 | [diff] [blame] | 210 | stmmac_probe_config_dt(struct platform_device *pdev, const char **mac) |
Stefan Roese | 6a22845 | 2012-03-13 04:56:37 +0000 | [diff] [blame] | 211 | { |
| 212 | struct device_node *np = pdev->dev.of_node; |
Joachim Eastwood | 4ed2d8f | 2015-07-17 00:26:06 +0200 | [diff] [blame] | 213 | struct plat_stmmacenet_data *plat; |
Srinivas Kandagatla | 25c83b5 | 2013-07-04 10:35:41 +0100 | [diff] [blame] | 214 | struct stmmac_dma_cfg *dma_cfg; |
Stefan Roese | 6a22845 | 2012-03-13 04:56:37 +0000 | [diff] [blame] | 215 | |
Joachim Eastwood | 4ed2d8f | 2015-07-17 00:26:06 +0200 | [diff] [blame] | 216 | plat = devm_kzalloc(&pdev->dev, sizeof(*plat), GFP_KERNEL); |
| 217 | if (!plat) |
Joachim Eastwood | b0003ea | 2015-07-17 00:26:08 +0200 | [diff] [blame] | 218 | return ERR_PTR(-ENOMEM); |
Joachim Eastwood | 4ed2d8f | 2015-07-17 00:26:06 +0200 | [diff] [blame] | 219 | |
Stefan Roese | 6a22845 | 2012-03-13 04:56:37 +0000 | [diff] [blame] | 220 | *mac = of_get_mac_address(np); |
| 221 | plat->interface = of_get_phy_mode(np); |
Srinivas Kandagatla | 25c83b5 | 2013-07-04 10:35:41 +0100 | [diff] [blame] | 222 | |
Srinivas Kandagatla | 9cbadf0 | 2014-01-16 10:51:43 +0000 | [diff] [blame] | 223 | /* Get max speed of operation from device tree */ |
| 224 | if (of_property_read_u32(np, "max-speed", &plat->max_speed)) |
| 225 | plat->max_speed = -1; |
| 226 | |
Srinivas Kandagatla | 25c83b5 | 2013-07-04 10:35:41 +0100 | [diff] [blame] | 227 | plat->bus_id = of_alias_get_id(np, "ethernet"); |
| 228 | if (plat->bus_id < 0) |
| 229 | plat->bus_id = 0; |
| 230 | |
Chen-Yu Tsai | 436f7ec | 2014-01-17 21:24:45 +0800 | [diff] [blame] | 231 | /* Default to phy auto-detection */ |
| 232 | plat->phy_addr = -1; |
| 233 | |
| 234 | /* "snps,phy-addr" is not a standard property. Mark it as deprecated |
| 235 | * and warn of its use. Remove this when phy node support is added. |
| 236 | */ |
| 237 | if (of_property_read_u32(np, "snps,phy-addr", &plat->phy_addr) == 0) |
| 238 | dev_warn(&pdev->dev, "snps,phy-addr property is deprecated\n"); |
Srinivas Kandagatla | 25c83b5 | 2013-07-04 10:35:41 +0100 | [diff] [blame] | 239 | |
Giuseppe CAVALLARO | a7657f1 | 2016-04-01 09:07:16 +0200 | [diff] [blame] | 240 | /* To Configure PHY by using all device-tree supported properties */ |
| 241 | if (stmmac_dt_phy(plat, np, &pdev->dev)) |
| 242 | return ERR_PTR(-ENODEV); |
Stefan Roese | 6a22845 | 2012-03-13 04:56:37 +0000 | [diff] [blame] | 243 | |
Vince Bridgers | e7877f5 | 2015-04-15 11:17:40 -0500 | [diff] [blame] | 244 | of_property_read_u32(np, "tx-fifo-depth", &plat->tx_fifo_size); |
| 245 | |
| 246 | of_property_read_u32(np, "rx-fifo-depth", &plat->rx_fifo_size); |
| 247 | |
Giuseppe CAVALLARO | 8c2a7a5 | 2014-10-14 08:11:54 +0200 | [diff] [blame] | 248 | plat->force_sf_dma_mode = |
| 249 | of_property_read_bool(np, "snps,force_sf_dma_mode"); |
Chen-Yu Tsai | 6aedb8c | 2014-01-17 21:24:44 +0800 | [diff] [blame] | 250 | |
Vince Bridgers | 2618abb | 2014-01-20 05:39:01 -0600 | [diff] [blame] | 251 | /* Set the maxmtu to a default of JUMBO_LEN in case the |
| 252 | * parameter is not present in the device tree. |
| 253 | */ |
| 254 | plat->maxmtu = JUMBO_LEN; |
| 255 | |
Joachim Eastwood | 4ed2d8f | 2015-07-17 00:26:06 +0200 | [diff] [blame] | 256 | /* Set default value for multicast hash bins */ |
| 257 | plat->multicast_filter_bins = HASH_TABLE_SIZE; |
| 258 | |
| 259 | /* Set default value for unicast filter entries */ |
| 260 | plat->unicast_filter_entries = 1; |
| 261 | |
Stefan Roese | 6a22845 | 2012-03-13 04:56:37 +0000 | [diff] [blame] | 262 | /* |
| 263 | * Currently only the properties needed on SPEAr600 |
| 264 | * are provided. All other properties should be added |
| 265 | * once needed on other platforms. |
| 266 | */ |
Dinh Nguyen | 84c9f8c4 | 2012-07-18 13:28:26 +0000 | [diff] [blame] | 267 | if (of_device_is_compatible(np, "st,spear600-gmac") || |
| 268 | of_device_is_compatible(np, "snps,dwmac-3.70a") || |
| 269 | of_device_is_compatible(np, "snps,dwmac")) { |
Vince Bridgers | 2618abb | 2014-01-20 05:39:01 -0600 | [diff] [blame] | 270 | /* Note that the max-frame-size parameter as defined in the |
| 271 | * ePAPR v1.1 spec is defined as max-frame-size, it's |
| 272 | * actually used as the IEEE definition of MAC Client |
| 273 | * data, or MTU. The ePAPR specification is confusing as |
| 274 | * the definition is max-frame-size, but usage examples |
| 275 | * are clearly MTUs |
| 276 | */ |
| 277 | of_property_read_u32(np, "max-frame-size", &plat->maxmtu); |
Vince Bridgers | 3b57de9 | 2014-07-31 15:49:17 -0500 | [diff] [blame] | 278 | of_property_read_u32(np, "snps,multicast-filter-bins", |
| 279 | &plat->multicast_filter_bins); |
| 280 | of_property_read_u32(np, "snps,perfect-filter-entries", |
| 281 | &plat->unicast_filter_entries); |
| 282 | plat->unicast_filter_entries = dwmac1000_validate_ucast_entries( |
| 283 | plat->unicast_filter_entries); |
| 284 | plat->multicast_filter_bins = dwmac1000_validate_mcast_bins( |
| 285 | plat->multicast_filter_bins); |
Stefan Roese | 6a22845 | 2012-03-13 04:56:37 +0000 | [diff] [blame] | 286 | plat->has_gmac = 1; |
| 287 | plat->pmt = 1; |
| 288 | } |
| 289 | |
Alexandre TORGUE | ee2ae1e | 2016-04-01 11:37:33 +0200 | [diff] [blame] | 290 | if (of_device_is_compatible(np, "snps,dwmac-4.00") || |
| 291 | of_device_is_compatible(np, "snps,dwmac-4.10a")) { |
| 292 | plat->has_gmac4 = 1; |
| 293 | plat->pmt = 1; |
| 294 | plat->tso_en = of_property_read_bool(np, "snps,tso"); |
| 295 | } |
| 296 | |
Srinivas Kandagatla | 25c83b5 | 2013-07-04 10:35:41 +0100 | [diff] [blame] | 297 | if (of_device_is_compatible(np, "snps,dwmac-3.610") || |
| 298 | of_device_is_compatible(np, "snps,dwmac-3.710")) { |
| 299 | plat->enh_desc = 1; |
| 300 | plat->bugged_jumbo = 1; |
| 301 | plat->force_sf_dma_mode = 1; |
| 302 | } |
| 303 | |
Byungho An | 64c3b25 | 2013-08-24 15:31:43 +0900 | [diff] [blame] | 304 | if (of_find_property(np, "snps,pbl", NULL)) { |
| 305 | dma_cfg = devm_kzalloc(&pdev->dev, sizeof(*dma_cfg), |
| 306 | GFP_KERNEL); |
Mathieu Olivari | 2773238 | 2015-05-27 11:02:48 -0700 | [diff] [blame] | 307 | if (!dma_cfg) { |
Peter Chen | 4613b27 | 2016-08-01 15:02:42 +0800 | [diff] [blame] | 308 | of_node_put(plat->phy_node); |
Joachim Eastwood | b0003ea | 2015-07-17 00:26:08 +0200 | [diff] [blame] | 309 | return ERR_PTR(-ENOMEM); |
Mathieu Olivari | 2773238 | 2015-05-27 11:02:48 -0700 | [diff] [blame] | 310 | } |
Byungho An | 64c3b25 | 2013-08-24 15:31:43 +0900 | [diff] [blame] | 311 | plat->dma_cfg = dma_cfg; |
| 312 | of_property_read_u32(np, "snps,pbl", &dma_cfg->pbl); |
Giuseppe Cavallaro | afea036 | 2016-02-29 14:27:28 +0100 | [diff] [blame] | 313 | dma_cfg->aal = of_property_read_bool(np, "snps,aal"); |
Byungho An | 64c3b25 | 2013-08-24 15:31:43 +0900 | [diff] [blame] | 314 | dma_cfg->fixed_burst = |
| 315 | of_property_read_bool(np, "snps,fixed-burst"); |
| 316 | dma_cfg->mixed_burst = |
| 317 | of_property_read_bool(np, "snps,mixed-burst"); |
| 318 | } |
Sonic Zhang | e2a240c | 2013-08-28 18:55:39 +0800 | [diff] [blame] | 319 | plat->force_thresh_dma_mode = of_property_read_bool(np, "snps,force_thresh_dma_mode"); |
| 320 | if (plat->force_thresh_dma_mode) { |
| 321 | plat->force_sf_dma_mode = 0; |
| 322 | pr_warn("force_sf_dma_mode is ignored if force_thresh_dma_mode is set."); |
Olof Johansson | 356f9e7 | 2013-09-05 18:01:41 -0700 | [diff] [blame] | 323 | } |
Srinivas Kandagatla | 25c83b5 | 2013-07-04 10:35:41 +0100 | [diff] [blame] | 324 | |
Giuseppe CAVALLARO | 02e57b9 | 2016-06-24 15:16:26 +0200 | [diff] [blame] | 325 | of_property_read_u32(np, "snps,ps-speed", &plat->mac_port_sel_speed); |
| 326 | |
Giuseppe Cavallaro | afea036 | 2016-02-29 14:27:28 +0100 | [diff] [blame] | 327 | plat->axi = stmmac_axi_setup(pdev); |
| 328 | |
Joachim Eastwood | b0003ea | 2015-07-17 00:26:08 +0200 | [diff] [blame] | 329 | return plat; |
Stefan Roese | 6a22845 | 2012-03-13 04:56:37 +0000 | [diff] [blame] | 330 | } |
| 331 | #else |
Joachim Eastwood | 402dae0 | 2015-07-17 00:26:09 +0200 | [diff] [blame] | 332 | struct plat_stmmacenet_data * |
Joachim Eastwood | b0003ea | 2015-07-17 00:26:08 +0200 | [diff] [blame] | 333 | stmmac_probe_config_dt(struct platform_device *pdev, const char **mac) |
Stefan Roese | 6a22845 | 2012-03-13 04:56:37 +0000 | [diff] [blame] | 334 | { |
Joachim Eastwood | b0003ea | 2015-07-17 00:26:08 +0200 | [diff] [blame] | 335 | return ERR_PTR(-ENOSYS); |
Stefan Roese | 6a22845 | 2012-03-13 04:56:37 +0000 | [diff] [blame] | 336 | } |
| 337 | #endif /* CONFIG_OF */ |
Joachim Eastwood | 402dae0 | 2015-07-17 00:26:09 +0200 | [diff] [blame] | 338 | EXPORT_SYMBOL_GPL(stmmac_probe_config_dt); |
Stefan Roese | 6a22845 | 2012-03-13 04:56:37 +0000 | [diff] [blame] | 339 | |
Joachim Eastwood | 402dae0 | 2015-07-17 00:26:09 +0200 | [diff] [blame] | 340 | int stmmac_get_platform_resources(struct platform_device *pdev, |
| 341 | struct stmmac_resources *stmmac_res) |
Giuseppe CAVALLARO | bfab27a | 2011-12-21 03:58:19 +0000 | [diff] [blame] | 342 | { |
Giuseppe CAVALLARO | bfab27a | 2011-12-21 03:58:19 +0000 | [diff] [blame] | 343 | struct resource *res; |
Joachim Eastwood | e56788c | 2015-05-20 20:03:07 +0200 | [diff] [blame] | 344 | |
Joachim Eastwood | f396cb0 | 2015-07-17 00:26:07 +0200 | [diff] [blame] | 345 | memset(stmmac_res, 0, sizeof(*stmmac_res)); |
Alexey Brodkin | 8f02d8d | 2015-03-03 13:46:44 +0300 | [diff] [blame] | 346 | |
| 347 | /* Get IRQ information early to have an ability to ask for deferred |
| 348 | * probe if needed before we went too far with resource allocation. |
| 349 | */ |
Joachim Eastwood | f396cb0 | 2015-07-17 00:26:07 +0200 | [diff] [blame] | 350 | stmmac_res->irq = platform_get_irq_byname(pdev, "macirq"); |
| 351 | if (stmmac_res->irq < 0) { |
| 352 | if (stmmac_res->irq != -EPROBE_DEFER) { |
| 353 | dev_err(&pdev->dev, |
Alexey Brodkin | 8f02d8d | 2015-03-03 13:46:44 +0300 | [diff] [blame] | 354 | "MAC IRQ configuration information not found\n"); |
| 355 | } |
Joachim Eastwood | f396cb0 | 2015-07-17 00:26:07 +0200 | [diff] [blame] | 356 | return stmmac_res->irq; |
Alexey Brodkin | 8f02d8d | 2015-03-03 13:46:44 +0300 | [diff] [blame] | 357 | } |
| 358 | |
| 359 | /* On some platforms e.g. SPEAr the wake up irq differs from the mac irq |
| 360 | * The external wake up irq can be passed through the platform code |
| 361 | * named as "eth_wake_irq" |
| 362 | * |
| 363 | * In case the wake up interrupt is not passed from the platform |
| 364 | * so the driver will continue to use the mac irq (ndev->irq) |
| 365 | */ |
Joachim Eastwood | f396cb0 | 2015-07-17 00:26:07 +0200 | [diff] [blame] | 366 | stmmac_res->wol_irq = platform_get_irq_byname(pdev, "eth_wake_irq"); |
| 367 | if (stmmac_res->wol_irq < 0) { |
| 368 | if (stmmac_res->wol_irq == -EPROBE_DEFER) |
Alexey Brodkin | 8f02d8d | 2015-03-03 13:46:44 +0300 | [diff] [blame] | 369 | return -EPROBE_DEFER; |
Joachim Eastwood | f396cb0 | 2015-07-17 00:26:07 +0200 | [diff] [blame] | 370 | stmmac_res->wol_irq = stmmac_res->irq; |
Alexey Brodkin | 8f02d8d | 2015-03-03 13:46:44 +0300 | [diff] [blame] | 371 | } |
| 372 | |
Joachim Eastwood | f396cb0 | 2015-07-17 00:26:07 +0200 | [diff] [blame] | 373 | stmmac_res->lpi_irq = platform_get_irq_byname(pdev, "eth_lpi"); |
| 374 | if (stmmac_res->lpi_irq == -EPROBE_DEFER) |
Alexey Brodkin | 8f02d8d | 2015-03-03 13:46:44 +0300 | [diff] [blame] | 375 | return -EPROBE_DEFER; |
Giuseppe CAVALLARO | bfab27a | 2011-12-21 03:58:19 +0000 | [diff] [blame] | 376 | |
| 377 | res = platform_get_resource(pdev, IORESOURCE_MEM, 0); |
Joachim Eastwood | f396cb0 | 2015-07-17 00:26:07 +0200 | [diff] [blame] | 378 | stmmac_res->addr = devm_ioremap_resource(&pdev->dev, res); |
Joachim Eastwood | f396cb0 | 2015-07-17 00:26:07 +0200 | [diff] [blame] | 379 | |
Fengguang Wu | a04c0aef | 2015-07-29 00:08:48 +0200 | [diff] [blame] | 380 | return PTR_ERR_OR_ZERO(stmmac_res->addr); |
Joachim Eastwood | f396cb0 | 2015-07-17 00:26:07 +0200 | [diff] [blame] | 381 | } |
Joachim Eastwood | 402dae0 | 2015-07-17 00:26:09 +0200 | [diff] [blame] | 382 | EXPORT_SYMBOL_GPL(stmmac_get_platform_resources); |
Joachim Eastwood | f396cb0 | 2015-07-17 00:26:07 +0200 | [diff] [blame] | 383 | |
| 384 | /** |
Giuseppe CAVALLARO | bfab27a | 2011-12-21 03:58:19 +0000 | [diff] [blame] | 385 | * stmmac_pltfr_remove |
| 386 | * @pdev: platform device pointer |
| 387 | * Description: this function calls the main to free the net resources |
| 388 | * and calls the platforms hook and release the resources (e.g. mem). |
| 389 | */ |
Joachim Eastwood | 902b160 | 2015-05-14 12:10:58 +0200 | [diff] [blame] | 390 | int stmmac_pltfr_remove(struct platform_device *pdev) |
Giuseppe CAVALLARO | bfab27a | 2011-12-21 03:58:19 +0000 | [diff] [blame] | 391 | { |
| 392 | struct net_device *ndev = platform_get_drvdata(pdev); |
| 393 | struct stmmac_priv *priv = netdev_priv(ndev); |
Joachim Eastwood | f4e7bd8 | 2016-05-01 22:58:19 +0200 | [diff] [blame] | 394 | int ret = stmmac_dvr_remove(&pdev->dev); |
Giuseppe CAVALLARO | bfab27a | 2011-12-21 03:58:19 +0000 | [diff] [blame] | 395 | |
| 396 | if (priv->plat->exit) |
Chen-Yu Tsai | 938dfda | 2014-01-17 21:24:42 +0800 | [diff] [blame] | 397 | priv->plat->exit(pdev, priv->plat->bsp_priv); |
| 398 | |
Giuseppe CAVALLARO | bfab27a | 2011-12-21 03:58:19 +0000 | [diff] [blame] | 399 | return ret; |
| 400 | } |
Joachim Eastwood | 902b160 | 2015-05-14 12:10:58 +0200 | [diff] [blame] | 401 | EXPORT_SYMBOL_GPL(stmmac_pltfr_remove); |
Giuseppe CAVALLARO | bfab27a | 2011-12-21 03:58:19 +0000 | [diff] [blame] | 402 | |
Andy Shevchenko | b2e2f0c | 2014-11-10 12:38:59 +0200 | [diff] [blame] | 403 | #ifdef CONFIG_PM_SLEEP |
Giuseppe CAVALLARO | 732fdf0 | 2014-11-18 09:47:01 +0100 | [diff] [blame] | 404 | /** |
| 405 | * stmmac_pltfr_suspend |
| 406 | * @dev: device pointer |
| 407 | * Description: this function is invoked when suspend the driver and it direcly |
| 408 | * call the main suspend function and then, if required, on some platform, it |
| 409 | * can call an exit helper. |
| 410 | */ |
Giuseppe CAVALLARO | bfab27a | 2011-12-21 03:58:19 +0000 | [diff] [blame] | 411 | static int stmmac_pltfr_suspend(struct device *dev) |
| 412 | { |
Srinivas Kandagatla | 33a23e2 | 2014-01-16 10:52:44 +0000 | [diff] [blame] | 413 | int ret; |
Giuseppe CAVALLARO | bfab27a | 2011-12-21 03:58:19 +0000 | [diff] [blame] | 414 | struct net_device *ndev = dev_get_drvdata(dev); |
Srinivas Kandagatla | 33a23e2 | 2014-01-16 10:52:44 +0000 | [diff] [blame] | 415 | struct stmmac_priv *priv = netdev_priv(ndev); |
| 416 | struct platform_device *pdev = to_platform_device(dev); |
Giuseppe CAVALLARO | bfab27a | 2011-12-21 03:58:19 +0000 | [diff] [blame] | 417 | |
Joachim Eastwood | f4e7bd8 | 2016-05-01 22:58:19 +0200 | [diff] [blame] | 418 | ret = stmmac_suspend(dev); |
Vincent Palatin | cecbc55 | 2016-06-15 11:32:21 -0700 | [diff] [blame] | 419 | if (priv->plat->suspend) |
| 420 | priv->plat->suspend(pdev, priv->plat->bsp_priv); |
| 421 | else if (priv->plat->exit) |
Chen-Yu Tsai | 938dfda | 2014-01-17 21:24:42 +0800 | [diff] [blame] | 422 | priv->plat->exit(pdev, priv->plat->bsp_priv); |
Srinivas Kandagatla | 33a23e2 | 2014-01-16 10:52:44 +0000 | [diff] [blame] | 423 | |
| 424 | return ret; |
Giuseppe CAVALLARO | bfab27a | 2011-12-21 03:58:19 +0000 | [diff] [blame] | 425 | } |
| 426 | |
Giuseppe CAVALLARO | 732fdf0 | 2014-11-18 09:47:01 +0100 | [diff] [blame] | 427 | /** |
| 428 | * stmmac_pltfr_resume |
| 429 | * @dev: device pointer |
| 430 | * Description: this function is invoked when resume the driver before calling |
| 431 | * the main resume function, on some platforms, it can call own init helper |
| 432 | * if required. |
| 433 | */ |
Giuseppe CAVALLARO | bfab27a | 2011-12-21 03:58:19 +0000 | [diff] [blame] | 434 | static int stmmac_pltfr_resume(struct device *dev) |
| 435 | { |
| 436 | struct net_device *ndev = dev_get_drvdata(dev); |
Srinivas Kandagatla | 33a23e2 | 2014-01-16 10:52:44 +0000 | [diff] [blame] | 437 | struct stmmac_priv *priv = netdev_priv(ndev); |
| 438 | struct platform_device *pdev = to_platform_device(dev); |
| 439 | |
Vincent Palatin | cecbc55 | 2016-06-15 11:32:21 -0700 | [diff] [blame] | 440 | if (priv->plat->resume) |
| 441 | priv->plat->resume(pdev, priv->plat->bsp_priv); |
| 442 | else if (priv->plat->init) |
Chen-Yu Tsai | 938dfda | 2014-01-17 21:24:42 +0800 | [diff] [blame] | 443 | priv->plat->init(pdev, priv->plat->bsp_priv); |
Giuseppe CAVALLARO | bfab27a | 2011-12-21 03:58:19 +0000 | [diff] [blame] | 444 | |
Joachim Eastwood | f4e7bd8 | 2016-05-01 22:58:19 +0200 | [diff] [blame] | 445 | return stmmac_resume(dev); |
Giuseppe CAVALLARO | bfab27a | 2011-12-21 03:58:19 +0000 | [diff] [blame] | 446 | } |
Andy Shevchenko | b2e2f0c | 2014-11-10 12:38:59 +0200 | [diff] [blame] | 447 | #endif /* CONFIG_PM_SLEEP */ |
Giuseppe CAVALLARO | bfab27a | 2011-12-21 03:58:19 +0000 | [diff] [blame] | 448 | |
Joachim Eastwood | 902b160 | 2015-05-14 12:10:58 +0200 | [diff] [blame] | 449 | SIMPLE_DEV_PM_OPS(stmmac_pltfr_pm_ops, stmmac_pltfr_suspend, |
| 450 | stmmac_pltfr_resume); |
| 451 | EXPORT_SYMBOL_GPL(stmmac_pltfr_pm_ops); |
Joachim Eastwood | ea11154 | 2015-07-31 19:13:22 +0200 | [diff] [blame] | 452 | |
| 453 | MODULE_DESCRIPTION("STMMAC 10/100/1000 Ethernet platform support"); |
| 454 | MODULE_AUTHOR("Giuseppe Cavallaro <peppe.cavallaro@st.com>"); |
| 455 | MODULE_LICENSE("GPL"); |