Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 1 | /* |
Robert P. J. Day | 1cc0a9f | 2016-05-04 04:47:31 -0400 | [diff] [blame] | 2 | * sh_eth.c - Driver for Renesas ethernet controller. |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 3 | * |
Nobuhiro Iwamatsu | 3bb4cc3 | 2011-11-14 16:56:59 +0900 | [diff] [blame] | 4 | * Copyright (C) 2008, 2011 Renesas Solutions Corp. |
Nobuhiro Iwamatsu | f7ca1f7 | 2014-11-04 09:15:48 +0900 | [diff] [blame] | 5 | * Copyright (c) 2008, 2011, 2014 2014 Nobuhiro Iwamatsu |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 6 | * Copyright (c) 2007 Carlos Munoz <carlos@kenati.com> |
Nobuhiro Iwamatsu | f7ca1f7 | 2014-11-04 09:15:48 +0900 | [diff] [blame] | 7 | * Copyright (C) 2013, 2014 Renesas Electronics Corporation |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 8 | * |
Wolfgang Denk | 1a45966 | 2013-07-08 09:37:19 +0200 | [diff] [blame] | 9 | * SPDX-License-Identifier: GPL-2.0+ |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 10 | */ |
| 11 | |
| 12 | #include <config.h> |
| 13 | #include <common.h> |
| 14 | #include <malloc.h> |
| 15 | #include <net.h> |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 16 | #include <netdev.h> |
Yoshihiro Shimoda | bd1024b | 2011-10-11 18:10:14 +0900 | [diff] [blame] | 17 | #include <miiphy.h> |
Masahiro Yamada | 1221ce4 | 2016-09-21 11:28:55 +0900 | [diff] [blame] | 18 | #include <linux/errno.h> |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 19 | #include <asm/io.h> |
| 20 | |
| 21 | #include "sh_eth.h" |
| 22 | |
| 23 | #ifndef CONFIG_SH_ETHER_USE_PORT |
| 24 | # error "Please define CONFIG_SH_ETHER_USE_PORT" |
| 25 | #endif |
| 26 | #ifndef CONFIG_SH_ETHER_PHY_ADDR |
| 27 | # error "Please define CONFIG_SH_ETHER_PHY_ADDR" |
| 28 | #endif |
Nobuhiro Iwamatsu | 870cc23 | 2013-08-22 13:22:01 +0900 | [diff] [blame] | 29 | |
Nobuhiro Iwamatsu | 92f0713 | 2013-08-22 13:22:03 +0900 | [diff] [blame] | 30 | #if defined(CONFIG_SH_ETHER_CACHE_WRITEBACK) && !defined(CONFIG_SYS_DCACHE_OFF) |
| 31 | #define flush_cache_wback(addr, len) \ |
Nobuhiro Iwamatsu | aae5d23 | 2017-12-01 13:56:08 +0900 | [diff] [blame] | 32 | flush_dcache_range((u32)addr, \ |
| 33 | (u32)(addr + ALIGN(len, CONFIG_SH_ETHER_ALIGNE_SIZE))) |
Yoshihiro Shimoda | 68260aa | 2011-01-27 10:06:08 +0900 | [diff] [blame] | 34 | #else |
| 35 | #define flush_cache_wback(...) |
| 36 | #endif |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 37 | |
Nobuhiro Iwamatsu | 92f0713 | 2013-08-22 13:22:03 +0900 | [diff] [blame] | 38 | #if defined(CONFIG_SH_ETHER_CACHE_INVALIDATE) && defined(CONFIG_ARM) |
| 39 | #define invalidate_cache(addr, len) \ |
| 40 | { \ |
| 41 | u32 line_size = CONFIG_SH_ETHER_ALIGNE_SIZE; \ |
| 42 | u32 start, end; \ |
| 43 | \ |
| 44 | start = (u32)addr; \ |
| 45 | end = start + len; \ |
| 46 | start &= ~(line_size - 1); \ |
| 47 | end = ((end + line_size - 1) & ~(line_size - 1)); \ |
| 48 | \ |
| 49 | invalidate_dcache_range(start, end); \ |
| 50 | } |
| 51 | #else |
| 52 | #define invalidate_cache(...) |
| 53 | #endif |
| 54 | |
Nobuhiro Iwamatsu | 4ba62c7 | 2012-01-11 10:23:51 +0900 | [diff] [blame] | 55 | #define TIMEOUT_CNT 1000 |
| 56 | |
Marek Vasut | dca221b | 2018-01-21 14:27:51 +0100 | [diff] [blame] | 57 | static int sh_eth_send_common(struct sh_eth_dev *eth, void *packet, int len) |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 58 | { |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 59 | int port = eth->port, ret = 0, timeout; |
| 60 | struct sh_eth_info *port_info = ð->port_info[port]; |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 61 | |
| 62 | if (!packet || len > 0xffff) { |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 63 | printf(SHETHER_NAME ": %s: Invalid argument\n", __func__); |
| 64 | ret = -EINVAL; |
| 65 | goto err; |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 66 | } |
| 67 | |
| 68 | /* packet must be a 4 byte boundary */ |
Nobuhiro Iwamatsu | ee6ec5d | 2012-02-02 21:28:49 +0000 | [diff] [blame] | 69 | if ((int)packet & 3) { |
Nobuhiro Iwamatsu | dc14867 | 2017-12-01 08:08:00 +0900 | [diff] [blame] | 70 | printf(SHETHER_NAME ": %s: packet not 4 byte aligned\n" |
Nobuhiro Iwamatsu | e2752db | 2014-01-23 07:52:19 +0900 | [diff] [blame] | 71 | , __func__); |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 72 | ret = -EFAULT; |
| 73 | goto err; |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 74 | } |
| 75 | |
| 76 | /* Update tx descriptor */ |
Yoshihiro Shimoda | 68260aa | 2011-01-27 10:06:08 +0900 | [diff] [blame] | 77 | flush_cache_wback(packet, len); |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 78 | port_info->tx_desc_cur->td2 = ADDR_TO_PHY(packet); |
| 79 | port_info->tx_desc_cur->td1 = len << 16; |
| 80 | /* Must preserve the end of descriptor list indication */ |
| 81 | if (port_info->tx_desc_cur->td0 & TD_TDLE) |
| 82 | port_info->tx_desc_cur->td0 = TD_TACT | TD_TFP | TD_TDLE; |
| 83 | else |
| 84 | port_info->tx_desc_cur->td0 = TD_TACT | TD_TFP; |
| 85 | |
Nobuhiro Iwamatsu | f7ca1f7 | 2014-11-04 09:15:48 +0900 | [diff] [blame] | 86 | flush_cache_wback(port_info->tx_desc_cur, sizeof(struct tx_desc_s)); |
| 87 | |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 88 | /* Restart the transmitter if disabled */ |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 89 | if (!(sh_eth_read(port_info, EDTRR) & EDTRR_TRNS)) |
| 90 | sh_eth_write(port_info, EDTRR_TRNS, EDTRR); |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 91 | |
| 92 | /* Wait until packet is transmitted */ |
Nobuhiro Iwamatsu | 4ba62c7 | 2012-01-11 10:23:51 +0900 | [diff] [blame] | 93 | timeout = TIMEOUT_CNT; |
Nobuhiro Iwamatsu | 92f0713 | 2013-08-22 13:22:03 +0900 | [diff] [blame] | 94 | do { |
| 95 | invalidate_cache(port_info->tx_desc_cur, |
| 96 | sizeof(struct tx_desc_s)); |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 97 | udelay(100); |
Nobuhiro Iwamatsu | 92f0713 | 2013-08-22 13:22:03 +0900 | [diff] [blame] | 98 | } while (port_info->tx_desc_cur->td0 & TD_TACT && timeout--); |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 99 | |
| 100 | if (timeout < 0) { |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 101 | printf(SHETHER_NAME ": transmit timeout\n"); |
| 102 | ret = -ETIMEDOUT; |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 103 | goto err; |
| 104 | } |
| 105 | |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 106 | port_info->tx_desc_cur++; |
| 107 | if (port_info->tx_desc_cur >= port_info->tx_desc_base + NUM_TX_DESC) |
| 108 | port_info->tx_desc_cur = port_info->tx_desc_base; |
| 109 | |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 110 | err: |
| 111 | return ret; |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 112 | } |
| 113 | |
Marek Vasut | dca221b | 2018-01-21 14:27:51 +0100 | [diff] [blame] | 114 | static int sh_eth_send_legacy(struct eth_device *dev, void *packet, int len) |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 115 | { |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 116 | struct sh_eth_dev *eth = dev->priv; |
Marek Vasut | dca221b | 2018-01-21 14:27:51 +0100 | [diff] [blame] | 117 | |
| 118 | return sh_eth_send_common(eth, packet, len); |
| 119 | } |
| 120 | |
Marek Vasut | 52c15e2 | 2018-01-21 15:39:50 +0100 | [diff] [blame] | 121 | static int sh_eth_recv_start(struct sh_eth_dev *eth) |
| 122 | { |
| 123 | int port = eth->port, len = 0; |
| 124 | struct sh_eth_info *port_info = ð->port_info[port]; |
| 125 | |
| 126 | /* Check if the rx descriptor is ready */ |
| 127 | invalidate_cache(port_info->rx_desc_cur, sizeof(struct rx_desc_s)); |
| 128 | if (port_info->rx_desc_cur->rd0 & RD_RACT) |
| 129 | return -EINVAL; |
| 130 | |
| 131 | /* Check for errors */ |
| 132 | if (port_info->rx_desc_cur->rd0 & RD_RFE) |
| 133 | return -EINVAL; |
| 134 | |
| 135 | len = port_info->rx_desc_cur->rd1 & 0xffff; |
| 136 | |
| 137 | return len; |
| 138 | } |
| 139 | |
| 140 | static void sh_eth_recv_finish(struct sh_eth_dev *eth) |
| 141 | { |
| 142 | struct sh_eth_info *port_info = ð->port_info[eth->port]; |
| 143 | |
| 144 | /* Make current descriptor available again */ |
| 145 | if (port_info->rx_desc_cur->rd0 & RD_RDLE) |
| 146 | port_info->rx_desc_cur->rd0 = RD_RACT | RD_RDLE; |
| 147 | else |
| 148 | port_info->rx_desc_cur->rd0 = RD_RACT; |
| 149 | |
| 150 | flush_cache_wback(port_info->rx_desc_cur, |
| 151 | sizeof(struct rx_desc_s)); |
| 152 | |
| 153 | /* Point to the next descriptor */ |
| 154 | port_info->rx_desc_cur++; |
| 155 | if (port_info->rx_desc_cur >= |
| 156 | port_info->rx_desc_base + NUM_RX_DESC) |
| 157 | port_info->rx_desc_cur = port_info->rx_desc_base; |
| 158 | } |
| 159 | |
Marek Vasut | dca221b | 2018-01-21 14:27:51 +0100 | [diff] [blame] | 160 | static int sh_eth_recv_common(struct sh_eth_dev *eth) |
| 161 | { |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 162 | int port = eth->port, len = 0; |
| 163 | struct sh_eth_info *port_info = ð->port_info[port]; |
Marek Vasut | 52c15e2 | 2018-01-21 15:39:50 +0100 | [diff] [blame] | 164 | uchar *packet = (uchar *)ADDR_TO_P2(port_info->rx_desc_cur->rd2); |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 165 | |
Marek Vasut | 52c15e2 | 2018-01-21 15:39:50 +0100 | [diff] [blame] | 166 | len = sh_eth_recv_start(eth); |
| 167 | if (len > 0) { |
| 168 | invalidate_cache(packet, len); |
| 169 | net_process_received_packet(packet, len); |
| 170 | sh_eth_recv_finish(eth); |
| 171 | } else |
| 172 | len = 0; |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 173 | |
| 174 | /* Restart the receiver if disabled */ |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 175 | if (!(sh_eth_read(port_info, EDRRR) & EDRRR_R)) |
| 176 | sh_eth_write(port_info, EDRRR_R, EDRRR); |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 177 | |
| 178 | return len; |
| 179 | } |
| 180 | |
Marek Vasut | dca221b | 2018-01-21 14:27:51 +0100 | [diff] [blame] | 181 | static int sh_eth_recv_legacy(struct eth_device *dev) |
| 182 | { |
| 183 | struct sh_eth_dev *eth = dev->priv; |
| 184 | |
| 185 | return sh_eth_recv_common(eth); |
| 186 | } |
| 187 | |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 188 | static int sh_eth_reset(struct sh_eth_dev *eth) |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 189 | { |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 190 | struct sh_eth_info *port_info = ð->port_info[eth->port]; |
Nobuhiro Iwamatsu | 62cbddc | 2014-01-23 07:52:18 +0900 | [diff] [blame] | 191 | #if defined(SH_ETH_TYPE_GETHER) || defined(SH_ETH_TYPE_RZ) |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 192 | int ret = 0, i; |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 193 | |
| 194 | /* Start e-dmac transmitter and receiver */ |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 195 | sh_eth_write(port_info, EDSR_ENALL, EDSR); |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 196 | |
| 197 | /* Perform a software reset and wait for it to complete */ |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 198 | sh_eth_write(port_info, EDMR_SRST, EDMR); |
Nobuhiro Iwamatsu | e2752db | 2014-01-23 07:52:19 +0900 | [diff] [blame] | 199 | for (i = 0; i < TIMEOUT_CNT; i++) { |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 200 | if (!(sh_eth_read(port_info, EDMR) & EDMR_SRST)) |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 201 | break; |
| 202 | udelay(1000); |
| 203 | } |
| 204 | |
Nobuhiro Iwamatsu | 4ba62c7 | 2012-01-11 10:23:51 +0900 | [diff] [blame] | 205 | if (i == TIMEOUT_CNT) { |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 206 | printf(SHETHER_NAME ": Software reset timeout\n"); |
| 207 | ret = -EIO; |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 208 | } |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 209 | |
| 210 | return ret; |
Yoshihiro Shimoda | 903de46 | 2011-01-18 17:53:45 +0900 | [diff] [blame] | 211 | #else |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 212 | sh_eth_write(port_info, sh_eth_read(port_info, EDMR) | EDMR_SRST, EDMR); |
Yoshihiro Shimoda | 903de46 | 2011-01-18 17:53:45 +0900 | [diff] [blame] | 213 | udelay(3000); |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 214 | sh_eth_write(port_info, |
| 215 | sh_eth_read(port_info, EDMR) & ~EDMR_SRST, EDMR); |
Yoshihiro Shimoda | 903de46 | 2011-01-18 17:53:45 +0900 | [diff] [blame] | 216 | |
| 217 | return 0; |
| 218 | #endif |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 219 | } |
| 220 | |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 221 | static int sh_eth_tx_desc_init(struct sh_eth_dev *eth) |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 222 | { |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 223 | int port = eth->port, i, ret = 0; |
Nobuhiro Iwamatsu | 000889c | 2014-11-04 09:15:47 +0900 | [diff] [blame] | 224 | u32 alloc_desc_size = NUM_TX_DESC * sizeof(struct tx_desc_s); |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 225 | struct sh_eth_info *port_info = ð->port_info[port]; |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 226 | struct tx_desc_s *cur_tx_desc; |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 227 | |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 228 | /* |
Nobuhiro Iwamatsu | 703949e | 2014-11-04 09:15:46 +0900 | [diff] [blame] | 229 | * Allocate rx descriptors. They must be aligned to size of struct |
| 230 | * tx_desc_s. |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 231 | */ |
Nobuhiro Iwamatsu | 000889c | 2014-11-04 09:15:47 +0900 | [diff] [blame] | 232 | port_info->tx_desc_alloc = |
| 233 | memalign(sizeof(struct tx_desc_s), alloc_desc_size); |
| 234 | if (!port_info->tx_desc_alloc) { |
| 235 | printf(SHETHER_NAME ": memalign failed\n"); |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 236 | ret = -ENOMEM; |
| 237 | goto err; |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 238 | } |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 239 | |
Nobuhiro Iwamatsu | aae5d23 | 2017-12-01 13:56:08 +0900 | [diff] [blame] | 240 | flush_cache_wback(port_info->tx_desc_alloc, alloc_desc_size); |
Nobuhiro Iwamatsu | 000889c | 2014-11-04 09:15:47 +0900 | [diff] [blame] | 241 | |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 242 | /* Make sure we use a P2 address (non-cacheable) */ |
Nobuhiro Iwamatsu | 000889c | 2014-11-04 09:15:47 +0900 | [diff] [blame] | 243 | port_info->tx_desc_base = |
| 244 | (struct tx_desc_s *)ADDR_TO_P2((u32)port_info->tx_desc_alloc); |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 245 | port_info->tx_desc_cur = port_info->tx_desc_base; |
| 246 | |
| 247 | /* Initialize all descriptors */ |
| 248 | for (cur_tx_desc = port_info->tx_desc_base, i = 0; i < NUM_TX_DESC; |
| 249 | cur_tx_desc++, i++) { |
| 250 | cur_tx_desc->td0 = 0x00; |
| 251 | cur_tx_desc->td1 = 0x00; |
| 252 | cur_tx_desc->td2 = 0x00; |
| 253 | } |
| 254 | |
| 255 | /* Mark the end of the descriptors */ |
| 256 | cur_tx_desc--; |
| 257 | cur_tx_desc->td0 |= TD_TDLE; |
| 258 | |
Nobuhiro Iwamatsu | dc14867 | 2017-12-01 08:08:00 +0900 | [diff] [blame] | 259 | /* |
| 260 | * Point the controller to the tx descriptor list. Must use physical |
| 261 | * addresses |
| 262 | */ |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 263 | sh_eth_write(port_info, ADDR_TO_PHY(port_info->tx_desc_base), TDLAR); |
Nobuhiro Iwamatsu | 62cbddc | 2014-01-23 07:52:18 +0900 | [diff] [blame] | 264 | #if defined(SH_ETH_TYPE_GETHER) || defined(SH_ETH_TYPE_RZ) |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 265 | sh_eth_write(port_info, ADDR_TO_PHY(port_info->tx_desc_base), TDFAR); |
| 266 | sh_eth_write(port_info, ADDR_TO_PHY(cur_tx_desc), TDFXR); |
| 267 | sh_eth_write(port_info, 0x01, TDFFR);/* Last discriptor bit */ |
Yoshihiro Shimoda | 903de46 | 2011-01-18 17:53:45 +0900 | [diff] [blame] | 268 | #endif |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 269 | |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 270 | err: |
| 271 | return ret; |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 272 | } |
| 273 | |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 274 | static int sh_eth_rx_desc_init(struct sh_eth_dev *eth) |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 275 | { |
Nobuhiro Iwamatsu | dc14867 | 2017-12-01 08:08:00 +0900 | [diff] [blame] | 276 | int port = eth->port, i, ret = 0; |
Nobuhiro Iwamatsu | 000889c | 2014-11-04 09:15:47 +0900 | [diff] [blame] | 277 | u32 alloc_desc_size = NUM_RX_DESC * sizeof(struct rx_desc_s); |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 278 | struct sh_eth_info *port_info = ð->port_info[port]; |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 279 | struct rx_desc_s *cur_rx_desc; |
| 280 | u8 *rx_buf; |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 281 | |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 282 | /* |
Nobuhiro Iwamatsu | 703949e | 2014-11-04 09:15:46 +0900 | [diff] [blame] | 283 | * Allocate rx descriptors. They must be aligned to size of struct |
| 284 | * rx_desc_s. |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 285 | */ |
Nobuhiro Iwamatsu | 000889c | 2014-11-04 09:15:47 +0900 | [diff] [blame] | 286 | port_info->rx_desc_alloc = |
| 287 | memalign(sizeof(struct rx_desc_s), alloc_desc_size); |
| 288 | if (!port_info->rx_desc_alloc) { |
| 289 | printf(SHETHER_NAME ": memalign failed\n"); |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 290 | ret = -ENOMEM; |
| 291 | goto err; |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 292 | } |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 293 | |
Nobuhiro Iwamatsu | 000889c | 2014-11-04 09:15:47 +0900 | [diff] [blame] | 294 | flush_cache_wback(port_info->rx_desc_alloc, alloc_desc_size); |
| 295 | |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 296 | /* Make sure we use a P2 address (non-cacheable) */ |
Nobuhiro Iwamatsu | 000889c | 2014-11-04 09:15:47 +0900 | [diff] [blame] | 297 | port_info->rx_desc_base = |
| 298 | (struct rx_desc_s *)ADDR_TO_P2((u32)port_info->rx_desc_alloc); |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 299 | |
| 300 | port_info->rx_desc_cur = port_info->rx_desc_base; |
| 301 | |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 302 | /* |
Nobuhiro Iwamatsu | 000889c | 2014-11-04 09:15:47 +0900 | [diff] [blame] | 303 | * Allocate rx data buffers. They must be RX_BUF_ALIGNE_SIZE bytes |
| 304 | * aligned and in P2 area. |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 305 | */ |
Nobuhiro Iwamatsu | 000889c | 2014-11-04 09:15:47 +0900 | [diff] [blame] | 306 | port_info->rx_buf_alloc = |
| 307 | memalign(RX_BUF_ALIGNE_SIZE, NUM_RX_DESC * MAX_BUF_SIZE); |
| 308 | if (!port_info->rx_buf_alloc) { |
| 309 | printf(SHETHER_NAME ": alloc failed\n"); |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 310 | ret = -ENOMEM; |
Nobuhiro Iwamatsu | 000889c | 2014-11-04 09:15:47 +0900 | [diff] [blame] | 311 | goto err_buf_alloc; |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 312 | } |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 313 | |
Nobuhiro Iwamatsu | 000889c | 2014-11-04 09:15:47 +0900 | [diff] [blame] | 314 | port_info->rx_buf_base = (u8 *)ADDR_TO_P2((u32)port_info->rx_buf_alloc); |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 315 | |
| 316 | /* Initialize all descriptors */ |
| 317 | for (cur_rx_desc = port_info->rx_desc_base, |
| 318 | rx_buf = port_info->rx_buf_base, i = 0; |
| 319 | i < NUM_RX_DESC; cur_rx_desc++, rx_buf += MAX_BUF_SIZE, i++) { |
| 320 | cur_rx_desc->rd0 = RD_RACT; |
| 321 | cur_rx_desc->rd1 = MAX_BUF_SIZE << 16; |
Nobuhiro Iwamatsu | dc14867 | 2017-12-01 08:08:00 +0900 | [diff] [blame] | 322 | cur_rx_desc->rd2 = (u32)ADDR_TO_PHY(rx_buf); |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 323 | } |
| 324 | |
| 325 | /* Mark the end of the descriptors */ |
| 326 | cur_rx_desc--; |
| 327 | cur_rx_desc->rd0 |= RD_RDLE; |
| 328 | |
| 329 | /* Point the controller to the rx descriptor list */ |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 330 | sh_eth_write(port_info, ADDR_TO_PHY(port_info->rx_desc_base), RDLAR); |
Nobuhiro Iwamatsu | 62cbddc | 2014-01-23 07:52:18 +0900 | [diff] [blame] | 331 | #if defined(SH_ETH_TYPE_GETHER) || defined(SH_ETH_TYPE_RZ) |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 332 | sh_eth_write(port_info, ADDR_TO_PHY(port_info->rx_desc_base), RDFAR); |
| 333 | sh_eth_write(port_info, ADDR_TO_PHY(cur_rx_desc), RDFXR); |
| 334 | sh_eth_write(port_info, RDFFR_RDLF, RDFFR); |
Yoshihiro Shimoda | 903de46 | 2011-01-18 17:53:45 +0900 | [diff] [blame] | 335 | #endif |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 336 | |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 337 | return ret; |
| 338 | |
Nobuhiro Iwamatsu | 000889c | 2014-11-04 09:15:47 +0900 | [diff] [blame] | 339 | err_buf_alloc: |
| 340 | free(port_info->rx_desc_alloc); |
| 341 | port_info->rx_desc_alloc = NULL; |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 342 | |
| 343 | err: |
| 344 | return ret; |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 345 | } |
| 346 | |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 347 | static void sh_eth_tx_desc_free(struct sh_eth_dev *eth) |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 348 | { |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 349 | int port = eth->port; |
| 350 | struct sh_eth_info *port_info = ð->port_info[port]; |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 351 | |
Nobuhiro Iwamatsu | 000889c | 2014-11-04 09:15:47 +0900 | [diff] [blame] | 352 | if (port_info->tx_desc_alloc) { |
| 353 | free(port_info->tx_desc_alloc); |
| 354 | port_info->tx_desc_alloc = NULL; |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 355 | } |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 356 | } |
| 357 | |
| 358 | static void sh_eth_rx_desc_free(struct sh_eth_dev *eth) |
| 359 | { |
| 360 | int port = eth->port; |
| 361 | struct sh_eth_info *port_info = ð->port_info[port]; |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 362 | |
Nobuhiro Iwamatsu | 000889c | 2014-11-04 09:15:47 +0900 | [diff] [blame] | 363 | if (port_info->rx_desc_alloc) { |
| 364 | free(port_info->rx_desc_alloc); |
| 365 | port_info->rx_desc_alloc = NULL; |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 366 | } |
| 367 | |
Nobuhiro Iwamatsu | 000889c | 2014-11-04 09:15:47 +0900 | [diff] [blame] | 368 | if (port_info->rx_buf_alloc) { |
| 369 | free(port_info->rx_buf_alloc); |
| 370 | port_info->rx_buf_alloc = NULL; |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 371 | } |
| 372 | } |
| 373 | |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 374 | static int sh_eth_desc_init(struct sh_eth_dev *eth) |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 375 | { |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 376 | int ret = 0; |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 377 | |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 378 | ret = sh_eth_tx_desc_init(eth); |
| 379 | if (ret) |
| 380 | goto err_tx_init; |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 381 | |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 382 | ret = sh_eth_rx_desc_init(eth); |
| 383 | if (ret) |
| 384 | goto err_rx_init; |
| 385 | |
| 386 | return ret; |
| 387 | err_rx_init: |
| 388 | sh_eth_tx_desc_free(eth); |
| 389 | |
| 390 | err_tx_init: |
| 391 | return ret; |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 392 | } |
| 393 | |
Marek Vasut | 68ac92e | 2018-01-21 14:55:44 +0100 | [diff] [blame^] | 394 | static void sh_eth_write_hwaddr(struct sh_eth_info *port_info, |
| 395 | unsigned char *mac) |
| 396 | { |
| 397 | u32 val; |
| 398 | |
| 399 | val = (mac[0] << 24) | (mac[1] << 16) | (mac[2] << 8) | mac[3]; |
| 400 | sh_eth_write(port_info, val, MAHR); |
| 401 | |
| 402 | val = (mac[4] << 8) | mac[5]; |
| 403 | sh_eth_write(port_info, val, MALR); |
| 404 | } |
| 405 | |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 406 | static int sh_eth_phy_config(struct sh_eth_dev *eth) |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 407 | { |
Yoshihiro Shimoda | bd1024b | 2011-10-11 18:10:14 +0900 | [diff] [blame] | 408 | int port = eth->port, ret = 0; |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 409 | struct sh_eth_info *port_info = ð->port_info[port]; |
Yoshihiro Shimoda | bd1024b | 2011-10-11 18:10:14 +0900 | [diff] [blame] | 410 | struct eth_device *dev = port_info->dev; |
| 411 | struct phy_device *phydev; |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 412 | |
Nobuhiro Iwamatsu | ee6ec5d | 2012-02-02 21:28:49 +0000 | [diff] [blame] | 413 | phydev = phy_connect( |
| 414 | miiphy_get_dev_by_name(dev->name), |
Nobuhiro Iwamatsu | 4398d55 | 2012-05-15 15:49:39 +0000 | [diff] [blame] | 415 | port_info->phy_addr, dev, CONFIG_SH_ETHER_PHY_MODE); |
Yoshihiro Shimoda | bd1024b | 2011-10-11 18:10:14 +0900 | [diff] [blame] | 416 | port_info->phydev = phydev; |
| 417 | phy_config(phydev); |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 418 | |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 419 | return ret; |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 420 | } |
| 421 | |
Nobuhiro Iwamatsu | 9b5f9ec | 2017-12-01 08:08:47 +0900 | [diff] [blame] | 422 | static int sh_eth_config(struct sh_eth_dev *eth) |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 423 | { |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 424 | int port = eth->port, ret = 0; |
Yoshihiro Shimoda | bd1024b | 2011-10-11 18:10:14 +0900 | [diff] [blame] | 425 | u32 val; |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 426 | struct sh_eth_info *port_info = ð->port_info[port]; |
Mike Frysinger | c527ce9 | 2009-02-11 19:14:09 -0500 | [diff] [blame] | 427 | struct eth_device *dev = port_info->dev; |
Yoshihiro Shimoda | bd1024b | 2011-10-11 18:10:14 +0900 | [diff] [blame] | 428 | struct phy_device *phy; |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 429 | |
| 430 | /* Configure e-dmac registers */ |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 431 | sh_eth_write(port_info, (sh_eth_read(port_info, EDMR) & ~EMDR_DESC_R) | |
Nobuhiro Iwamatsu | f8b7507 | 2013-08-22 13:22:02 +0900 | [diff] [blame] | 432 | (EMDR_DESC | EDMR_EL), EDMR); |
| 433 | |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 434 | sh_eth_write(port_info, 0, EESIPR); |
| 435 | sh_eth_write(port_info, 0, TRSCER); |
| 436 | sh_eth_write(port_info, 0, TFTR); |
| 437 | sh_eth_write(port_info, (FIFO_SIZE_T | FIFO_SIZE_R), FDR); |
| 438 | sh_eth_write(port_info, RMCR_RST, RMCR); |
Nobuhiro Iwamatsu | 62cbddc | 2014-01-23 07:52:18 +0900 | [diff] [blame] | 439 | #if defined(SH_ETH_TYPE_GETHER) || defined(SH_ETH_TYPE_RZ) |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 440 | sh_eth_write(port_info, 0, RPADIR); |
Yoshihiro Shimoda | 903de46 | 2011-01-18 17:53:45 +0900 | [diff] [blame] | 441 | #endif |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 442 | sh_eth_write(port_info, (FIFO_F_D_RFF | FIFO_F_D_RFD), FCFTR); |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 443 | |
| 444 | /* Configure e-mac registers */ |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 445 | sh_eth_write(port_info, 0, ECSIPR); |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 446 | |
| 447 | /* Set Mac address */ |
Marek Vasut | 68ac92e | 2018-01-21 14:55:44 +0100 | [diff] [blame^] | 448 | sh_eth_write_hwaddr(port_info, dev->enetaddr); |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 449 | |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 450 | sh_eth_write(port_info, RFLR_RFL_MIN, RFLR); |
Yoshihiro Shimoda | 2623509 | 2012-06-26 16:38:06 +0000 | [diff] [blame] | 451 | #if defined(SH_ETH_TYPE_GETHER) |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 452 | sh_eth_write(port_info, 0, PIPR); |
Nobuhiro Iwamatsu | 62cbddc | 2014-01-23 07:52:18 +0900 | [diff] [blame] | 453 | #endif |
| 454 | #if defined(SH_ETH_TYPE_GETHER) || defined(SH_ETH_TYPE_RZ) |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 455 | sh_eth_write(port_info, APR_AP, APR); |
| 456 | sh_eth_write(port_info, MPR_MP, MPR); |
| 457 | sh_eth_write(port_info, TPAUSER_TPAUSE, TPAUSER); |
Nobuhiro Iwamatsu | 3bb4cc3 | 2011-11-14 16:56:59 +0900 | [diff] [blame] | 458 | #endif |
| 459 | |
Nobuhiro Iwamatsu | dcd5a59 | 2012-08-02 22:08:40 +0000 | [diff] [blame] | 460 | #if defined(CONFIG_CPU_SH7734) || defined(CONFIG_R8A7740) |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 461 | sh_eth_write(port_info, CONFIG_SH_ETHER_SH7734_MII, RMII_MII); |
Marek Vasut | effb790 | 2018-01-22 01:42:32 +0100 | [diff] [blame] | 462 | #elif defined(CONFIG_RCAR_GEN2) |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 463 | sh_eth_write(port_info, sh_eth_read(port_info, RMIIMR) | 0x1, RMIIMR); |
Nobuhiro Iwamatsu | 4398d55 | 2012-05-15 15:49:39 +0000 | [diff] [blame] | 464 | #endif |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 465 | /* Configure phy */ |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 466 | ret = sh_eth_phy_config(eth); |
| 467 | if (ret) { |
Nobuhiro Iwamatsu | 88a4c2e | 2009-06-25 16:33:04 +0900 | [diff] [blame] | 468 | printf(SHETHER_NAME ": phy config timeout\n"); |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 469 | goto err_phy_cfg; |
| 470 | } |
Yoshihiro Shimoda | bd1024b | 2011-10-11 18:10:14 +0900 | [diff] [blame] | 471 | phy = port_info->phydev; |
Timur Tabi | 11af8d6 | 2012-07-09 08:52:43 +0000 | [diff] [blame] | 472 | ret = phy_startup(phy); |
| 473 | if (ret) { |
| 474 | printf(SHETHER_NAME ": phy startup failure\n"); |
| 475 | return ret; |
| 476 | } |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 477 | |
Nobuhiro Iwamatsu | 3bb4cc3 | 2011-11-14 16:56:59 +0900 | [diff] [blame] | 478 | val = 0; |
| 479 | |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 480 | /* Set the transfer speed */ |
Yoshihiro Shimoda | bd1024b | 2011-10-11 18:10:14 +0900 | [diff] [blame] | 481 | if (phy->speed == 100) { |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 482 | printf(SHETHER_NAME ": 100Base/"); |
Yoshihiro Shimoda | 2623509 | 2012-06-26 16:38:06 +0000 | [diff] [blame] | 483 | #if defined(SH_ETH_TYPE_GETHER) |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 484 | sh_eth_write(port_info, GECMR_100B, GECMR); |
Yoshihiro Shimoda | e3bb325 | 2012-11-04 15:54:30 +0000 | [diff] [blame] | 485 | #elif defined(CONFIG_CPU_SH7757) || defined(CONFIG_CPU_SH7752) |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 486 | sh_eth_write(port_info, 1, RTRATE); |
Marek Vasut | effb790 | 2018-01-22 01:42:32 +0100 | [diff] [blame] | 487 | #elif defined(CONFIG_CPU_SH7724) || defined(CONFIG_RCAR_GEN2) |
Nobuhiro Iwamatsu | 3bb4cc3 | 2011-11-14 16:56:59 +0900 | [diff] [blame] | 488 | val = ECMR_RTM; |
| 489 | #endif |
Yoshihiro Shimoda | bd1024b | 2011-10-11 18:10:14 +0900 | [diff] [blame] | 490 | } else if (phy->speed == 10) { |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 491 | printf(SHETHER_NAME ": 10Base/"); |
Yoshihiro Shimoda | 2623509 | 2012-06-26 16:38:06 +0000 | [diff] [blame] | 492 | #if defined(SH_ETH_TYPE_GETHER) |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 493 | sh_eth_write(port_info, GECMR_10B, GECMR); |
Yoshihiro Shimoda | e3bb325 | 2012-11-04 15:54:30 +0000 | [diff] [blame] | 494 | #elif defined(CONFIG_CPU_SH7757) || defined(CONFIG_CPU_SH7752) |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 495 | sh_eth_write(port_info, 0, RTRATE); |
Yoshihiro Shimoda | 903de46 | 2011-01-18 17:53:45 +0900 | [diff] [blame] | 496 | #endif |
Nobuhiro Iwamatsu | 3bb4cc3 | 2011-11-14 16:56:59 +0900 | [diff] [blame] | 497 | } |
Yoshihiro Shimoda | 2623509 | 2012-06-26 16:38:06 +0000 | [diff] [blame] | 498 | #if defined(SH_ETH_TYPE_GETHER) |
Nobuhiro Iwamatsu | 4398d55 | 2012-05-15 15:49:39 +0000 | [diff] [blame] | 499 | else if (phy->speed == 1000) { |
| 500 | printf(SHETHER_NAME ": 1000Base/"); |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 501 | sh_eth_write(port_info, GECMR_1000B, GECMR); |
Nobuhiro Iwamatsu | 4398d55 | 2012-05-15 15:49:39 +0000 | [diff] [blame] | 502 | } |
| 503 | #endif |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 504 | |
| 505 | /* Check if full duplex mode is supported by the phy */ |
Yoshihiro Shimoda | bd1024b | 2011-10-11 18:10:14 +0900 | [diff] [blame] | 506 | if (phy->duplex) { |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 507 | printf("Full\n"); |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 508 | sh_eth_write(port_info, |
Nobuhiro Iwamatsu | dc14867 | 2017-12-01 08:08:00 +0900 | [diff] [blame] | 509 | val | (ECMR_CHG_DM | ECMR_RE | ECMR_TE | ECMR_DM), |
Yoshihiro Shimoda | 49afb8c | 2012-06-26 16:38:09 +0000 | [diff] [blame] | 510 | ECMR); |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 511 | } else { |
| 512 | printf("Half\n"); |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 513 | sh_eth_write(port_info, |
Nobuhiro Iwamatsu | dc14867 | 2017-12-01 08:08:00 +0900 | [diff] [blame] | 514 | val | (ECMR_CHG_DM | ECMR_RE | ECMR_TE), |
| 515 | ECMR); |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 516 | } |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 517 | |
| 518 | return ret; |
| 519 | |
| 520 | err_phy_cfg: |
| 521 | return ret; |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 522 | } |
| 523 | |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 524 | static void sh_eth_start(struct sh_eth_dev *eth) |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 525 | { |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 526 | struct sh_eth_info *port_info = ð->port_info[eth->port]; |
| 527 | |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 528 | /* |
| 529 | * Enable the e-dmac receiver only. The transmitter will be enabled when |
| 530 | * we have something to transmit |
| 531 | */ |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 532 | sh_eth_write(port_info, EDRRR_R, EDRRR); |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 533 | } |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 534 | |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 535 | static void sh_eth_stop(struct sh_eth_dev *eth) |
| 536 | { |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 537 | struct sh_eth_info *port_info = ð->port_info[eth->port]; |
| 538 | |
| 539 | sh_eth_write(port_info, ~EDRRR_R, EDRRR); |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 540 | } |
| 541 | |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 542 | int sh_eth_init(struct eth_device *dev, bd_t *bd) |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 543 | { |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 544 | int ret = 0; |
| 545 | struct sh_eth_dev *eth = dev->priv; |
| 546 | |
| 547 | ret = sh_eth_reset(eth); |
| 548 | if (ret) |
| 549 | goto err; |
| 550 | |
| 551 | ret = sh_eth_desc_init(eth); |
| 552 | if (ret) |
| 553 | goto err; |
| 554 | |
Nobuhiro Iwamatsu | 9b5f9ec | 2017-12-01 08:08:47 +0900 | [diff] [blame] | 555 | ret = sh_eth_config(eth); |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 556 | if (ret) |
| 557 | goto err_config; |
| 558 | |
| 559 | sh_eth_start(eth); |
| 560 | |
| 561 | return ret; |
| 562 | |
| 563 | err_config: |
| 564 | sh_eth_tx_desc_free(eth); |
| 565 | sh_eth_rx_desc_free(eth); |
| 566 | |
| 567 | err: |
| 568 | return ret; |
| 569 | } |
| 570 | |
| 571 | void sh_eth_halt(struct eth_device *dev) |
| 572 | { |
| 573 | struct sh_eth_dev *eth = dev->priv; |
Nobuhiro Iwamatsu | dc14867 | 2017-12-01 08:08:00 +0900 | [diff] [blame] | 574 | |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 575 | sh_eth_stop(eth); |
| 576 | } |
| 577 | |
| 578 | int sh_eth_initialize(bd_t *bd) |
| 579 | { |
Nobuhiro Iwamatsu | e2752db | 2014-01-23 07:52:19 +0900 | [diff] [blame] | 580 | int ret = 0; |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 581 | struct sh_eth_dev *eth = NULL; |
Nobuhiro Iwamatsu | e2752db | 2014-01-23 07:52:19 +0900 | [diff] [blame] | 582 | struct eth_device *dev = NULL; |
Nobuhiro Iwamatsu | dc14867 | 2017-12-01 08:08:00 +0900 | [diff] [blame] | 583 | struct mii_dev *mdiodev; |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 584 | |
Nobuhiro Iwamatsu | e2752db | 2014-01-23 07:52:19 +0900 | [diff] [blame] | 585 | eth = (struct sh_eth_dev *)malloc(sizeof(struct sh_eth_dev)); |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 586 | if (!eth) { |
| 587 | printf(SHETHER_NAME ": %s: malloc failed\n", __func__); |
| 588 | ret = -ENOMEM; |
| 589 | goto err; |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 590 | } |
| 591 | |
Nobuhiro Iwamatsu | e2752db | 2014-01-23 07:52:19 +0900 | [diff] [blame] | 592 | dev = (struct eth_device *)malloc(sizeof(struct eth_device)); |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 593 | if (!dev) { |
| 594 | printf(SHETHER_NAME ": %s: malloc failed\n", __func__); |
| 595 | ret = -ENOMEM; |
| 596 | goto err; |
| 597 | } |
Nobuhiro Iwamatsu | e2752db | 2014-01-23 07:52:19 +0900 | [diff] [blame] | 598 | memset(dev, 0, sizeof(struct eth_device)); |
| 599 | memset(eth, 0, sizeof(struct sh_eth_dev)); |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 600 | |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 601 | eth->port = CONFIG_SH_ETHER_USE_PORT; |
| 602 | eth->port_info[eth->port].phy_addr = CONFIG_SH_ETHER_PHY_ADDR; |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 603 | eth->port_info[eth->port].iobase = |
| 604 | (void __iomem *)(BASE_IO_ADDR + 0x800 * eth->port); |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 605 | |
Nobuhiro Iwamatsu | e2752db | 2014-01-23 07:52:19 +0900 | [diff] [blame] | 606 | dev->priv = (void *)eth; |
| 607 | dev->iobase = 0; |
| 608 | dev->init = sh_eth_init; |
| 609 | dev->halt = sh_eth_halt; |
Marek Vasut | dca221b | 2018-01-21 14:27:51 +0100 | [diff] [blame] | 610 | dev->send = sh_eth_send_legacy; |
| 611 | dev->recv = sh_eth_recv_legacy; |
Nobuhiro Iwamatsu | e2752db | 2014-01-23 07:52:19 +0900 | [diff] [blame] | 612 | eth->port_info[eth->port].dev = dev; |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 613 | |
Ben Whitten | 192bc69 | 2015-12-30 13:05:58 +0000 | [diff] [blame] | 614 | strcpy(dev->name, SHETHER_NAME); |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 615 | |
Nobuhiro Iwamatsu | e2752db | 2014-01-23 07:52:19 +0900 | [diff] [blame] | 616 | /* Register Device to EtherNet subsystem */ |
| 617 | eth_register(dev); |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 618 | |
Yoshihiro Shimoda | bd1024b | 2011-10-11 18:10:14 +0900 | [diff] [blame] | 619 | bb_miiphy_buses[0].priv = eth; |
Nobuhiro Iwamatsu | dc14867 | 2017-12-01 08:08:00 +0900 | [diff] [blame] | 620 | mdiodev = mdio_alloc(); |
Joe Hershberger | 5a49f17 | 2016-08-08 11:28:38 -0500 | [diff] [blame] | 621 | if (!mdiodev) |
| 622 | return -ENOMEM; |
| 623 | strncpy(mdiodev->name, dev->name, MDIO_NAME_LEN); |
| 624 | mdiodev->read = bb_miiphy_read; |
| 625 | mdiodev->write = bb_miiphy_write; |
| 626 | |
Nobuhiro Iwamatsu | dc14867 | 2017-12-01 08:08:00 +0900 | [diff] [blame] | 627 | ret = mdio_register(mdiodev); |
| 628 | if (ret < 0) |
| 629 | return ret; |
Yoshihiro Shimoda | bd1024b | 2011-10-11 18:10:14 +0900 | [diff] [blame] | 630 | |
Simon Glass | 35affd7 | 2017-08-03 12:22:14 -0600 | [diff] [blame] | 631 | if (!eth_env_get_enetaddr("ethaddr", dev->enetaddr)) |
Mike Frysinger | c527ce9 | 2009-02-11 19:14:09 -0500 | [diff] [blame] | 632 | puts("Please set MAC address\n"); |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 633 | |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 634 | return ret; |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 635 | |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 636 | err: |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 637 | if (dev) |
| 638 | free(dev); |
| 639 | |
| 640 | if (eth) |
| 641 | free(eth); |
| 642 | |
| 643 | printf(SHETHER_NAME ": Failed\n"); |
| 644 | return ret; |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 645 | } |
Yoshihiro Shimoda | bd1024b | 2011-10-11 18:10:14 +0900 | [diff] [blame] | 646 | |
| 647 | /******* for bb_miiphy *******/ |
| 648 | static int sh_eth_bb_init(struct bb_miiphy_bus *bus) |
| 649 | { |
| 650 | return 0; |
| 651 | } |
| 652 | |
| 653 | static int sh_eth_bb_mdio_active(struct bb_miiphy_bus *bus) |
| 654 | { |
| 655 | struct sh_eth_dev *eth = bus->priv; |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 656 | struct sh_eth_info *port_info = ð->port_info[eth->port]; |
Yoshihiro Shimoda | bd1024b | 2011-10-11 18:10:14 +0900 | [diff] [blame] | 657 | |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 658 | sh_eth_write(port_info, sh_eth_read(port_info, PIR) | PIR_MMD, PIR); |
Yoshihiro Shimoda | bd1024b | 2011-10-11 18:10:14 +0900 | [diff] [blame] | 659 | |
| 660 | return 0; |
| 661 | } |
| 662 | |
| 663 | static int sh_eth_bb_mdio_tristate(struct bb_miiphy_bus *bus) |
| 664 | { |
| 665 | struct sh_eth_dev *eth = bus->priv; |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 666 | struct sh_eth_info *port_info = ð->port_info[eth->port]; |
Yoshihiro Shimoda | bd1024b | 2011-10-11 18:10:14 +0900 | [diff] [blame] | 667 | |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 668 | sh_eth_write(port_info, sh_eth_read(port_info, PIR) & ~PIR_MMD, PIR); |
Yoshihiro Shimoda | bd1024b | 2011-10-11 18:10:14 +0900 | [diff] [blame] | 669 | |
| 670 | return 0; |
| 671 | } |
| 672 | |
| 673 | static int sh_eth_bb_set_mdio(struct bb_miiphy_bus *bus, int v) |
| 674 | { |
| 675 | struct sh_eth_dev *eth = bus->priv; |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 676 | struct sh_eth_info *port_info = ð->port_info[eth->port]; |
Yoshihiro Shimoda | bd1024b | 2011-10-11 18:10:14 +0900 | [diff] [blame] | 677 | |
| 678 | if (v) |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 679 | sh_eth_write(port_info, |
| 680 | sh_eth_read(port_info, PIR) | PIR_MDO, PIR); |
Yoshihiro Shimoda | bd1024b | 2011-10-11 18:10:14 +0900 | [diff] [blame] | 681 | else |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 682 | sh_eth_write(port_info, |
| 683 | sh_eth_read(port_info, PIR) & ~PIR_MDO, PIR); |
Yoshihiro Shimoda | bd1024b | 2011-10-11 18:10:14 +0900 | [diff] [blame] | 684 | |
| 685 | return 0; |
| 686 | } |
| 687 | |
| 688 | static int sh_eth_bb_get_mdio(struct bb_miiphy_bus *bus, int *v) |
| 689 | { |
| 690 | struct sh_eth_dev *eth = bus->priv; |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 691 | struct sh_eth_info *port_info = ð->port_info[eth->port]; |
Yoshihiro Shimoda | bd1024b | 2011-10-11 18:10:14 +0900 | [diff] [blame] | 692 | |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 693 | *v = (sh_eth_read(port_info, PIR) & PIR_MDI) >> 3; |
Yoshihiro Shimoda | bd1024b | 2011-10-11 18:10:14 +0900 | [diff] [blame] | 694 | |
| 695 | return 0; |
| 696 | } |
| 697 | |
| 698 | static int sh_eth_bb_set_mdc(struct bb_miiphy_bus *bus, int v) |
| 699 | { |
| 700 | struct sh_eth_dev *eth = bus->priv; |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 701 | struct sh_eth_info *port_info = ð->port_info[eth->port]; |
Yoshihiro Shimoda | bd1024b | 2011-10-11 18:10:14 +0900 | [diff] [blame] | 702 | |
| 703 | if (v) |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 704 | sh_eth_write(port_info, |
| 705 | sh_eth_read(port_info, PIR) | PIR_MDC, PIR); |
Yoshihiro Shimoda | bd1024b | 2011-10-11 18:10:14 +0900 | [diff] [blame] | 706 | else |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 707 | sh_eth_write(port_info, |
| 708 | sh_eth_read(port_info, PIR) & ~PIR_MDC, PIR); |
Yoshihiro Shimoda | bd1024b | 2011-10-11 18:10:14 +0900 | [diff] [blame] | 709 | |
| 710 | return 0; |
| 711 | } |
| 712 | |
| 713 | static int sh_eth_bb_delay(struct bb_miiphy_bus *bus) |
| 714 | { |
| 715 | udelay(10); |
| 716 | |
| 717 | return 0; |
| 718 | } |
| 719 | |
| 720 | struct bb_miiphy_bus bb_miiphy_buses[] = { |
| 721 | { |
| 722 | .name = "sh_eth", |
| 723 | .init = sh_eth_bb_init, |
| 724 | .mdio_active = sh_eth_bb_mdio_active, |
| 725 | .mdio_tristate = sh_eth_bb_mdio_tristate, |
| 726 | .set_mdio = sh_eth_bb_set_mdio, |
| 727 | .get_mdio = sh_eth_bb_get_mdio, |
| 728 | .set_mdc = sh_eth_bb_set_mdc, |
| 729 | .delay = sh_eth_bb_delay, |
| 730 | } |
| 731 | }; |
Nobuhiro Iwamatsu | dc14867 | 2017-12-01 08:08:00 +0900 | [diff] [blame] | 732 | |
Yoshihiro Shimoda | bd1024b | 2011-10-11 18:10:14 +0900 | [diff] [blame] | 733 | int bb_miiphy_buses_num = ARRAY_SIZE(bb_miiphy_buses); |