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 | |
Marek Vasut | 013af64 | 2018-01-21 15:10:21 +0100 | [diff] [blame^] | 406 | static int sh_eth_phy_config_legacy(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 | |
Marek Vasut | 013af64 | 2018-01-21 15:10:21 +0100 | [diff] [blame^] | 422 | static void sh_eth_mac_regs_config(struct sh_eth_dev *eth, unsigned char *mac) |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 423 | { |
Marek Vasut | 013af64 | 2018-01-21 15:10:21 +0100 | [diff] [blame^] | 424 | struct sh_eth_info *port_info = ð->port_info[eth->port]; |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 425 | |
| 426 | /* Configure e-dmac registers */ |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 427 | 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] | 428 | (EMDR_DESC | EDMR_EL), EDMR); |
| 429 | |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 430 | sh_eth_write(port_info, 0, EESIPR); |
| 431 | sh_eth_write(port_info, 0, TRSCER); |
| 432 | sh_eth_write(port_info, 0, TFTR); |
| 433 | sh_eth_write(port_info, (FIFO_SIZE_T | FIFO_SIZE_R), FDR); |
| 434 | sh_eth_write(port_info, RMCR_RST, RMCR); |
Nobuhiro Iwamatsu | 62cbddc | 2014-01-23 07:52:18 +0900 | [diff] [blame] | 435 | #if defined(SH_ETH_TYPE_GETHER) || defined(SH_ETH_TYPE_RZ) |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 436 | sh_eth_write(port_info, 0, RPADIR); |
Yoshihiro Shimoda | 903de46 | 2011-01-18 17:53:45 +0900 | [diff] [blame] | 437 | #endif |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 438 | 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] | 439 | |
| 440 | /* Configure e-mac registers */ |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 441 | sh_eth_write(port_info, 0, ECSIPR); |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 442 | |
| 443 | /* Set Mac address */ |
Marek Vasut | 013af64 | 2018-01-21 15:10:21 +0100 | [diff] [blame^] | 444 | sh_eth_write_hwaddr(port_info, mac); |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 445 | |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 446 | sh_eth_write(port_info, RFLR_RFL_MIN, RFLR); |
Yoshihiro Shimoda | 2623509 | 2012-06-26 16:38:06 +0000 | [diff] [blame] | 447 | #if defined(SH_ETH_TYPE_GETHER) |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 448 | sh_eth_write(port_info, 0, PIPR); |
Nobuhiro Iwamatsu | 62cbddc | 2014-01-23 07:52:18 +0900 | [diff] [blame] | 449 | #endif |
| 450 | #if defined(SH_ETH_TYPE_GETHER) || defined(SH_ETH_TYPE_RZ) |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 451 | sh_eth_write(port_info, APR_AP, APR); |
| 452 | sh_eth_write(port_info, MPR_MP, MPR); |
| 453 | sh_eth_write(port_info, TPAUSER_TPAUSE, TPAUSER); |
Nobuhiro Iwamatsu | 3bb4cc3 | 2011-11-14 16:56:59 +0900 | [diff] [blame] | 454 | #endif |
| 455 | |
Nobuhiro Iwamatsu | dcd5a59 | 2012-08-02 22:08:40 +0000 | [diff] [blame] | 456 | #if defined(CONFIG_CPU_SH7734) || defined(CONFIG_R8A7740) |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 457 | sh_eth_write(port_info, CONFIG_SH_ETHER_SH7734_MII, RMII_MII); |
Marek Vasut | effb790 | 2018-01-22 01:42:32 +0100 | [diff] [blame] | 458 | #elif defined(CONFIG_RCAR_GEN2) |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 459 | 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] | 460 | #endif |
Marek Vasut | 013af64 | 2018-01-21 15:10:21 +0100 | [diff] [blame^] | 461 | } |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 462 | |
Marek Vasut | 013af64 | 2018-01-21 15:10:21 +0100 | [diff] [blame^] | 463 | static int sh_eth_phy_regs_config(struct sh_eth_dev *eth) |
| 464 | { |
| 465 | struct sh_eth_info *port_info = ð->port_info[eth->port]; |
| 466 | struct phy_device *phy = port_info->phydev; |
| 467 | int ret = 0; |
| 468 | u32 val = 0; |
Nobuhiro Iwamatsu | 3bb4cc3 | 2011-11-14 16:56:59 +0900 | [diff] [blame] | 469 | |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 470 | /* Set the transfer speed */ |
Yoshihiro Shimoda | bd1024b | 2011-10-11 18:10:14 +0900 | [diff] [blame] | 471 | if (phy->speed == 100) { |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 472 | printf(SHETHER_NAME ": 100Base/"); |
Yoshihiro Shimoda | 2623509 | 2012-06-26 16:38:06 +0000 | [diff] [blame] | 473 | #if defined(SH_ETH_TYPE_GETHER) |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 474 | sh_eth_write(port_info, GECMR_100B, GECMR); |
Yoshihiro Shimoda | e3bb325 | 2012-11-04 15:54:30 +0000 | [diff] [blame] | 475 | #elif defined(CONFIG_CPU_SH7757) || defined(CONFIG_CPU_SH7752) |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 476 | sh_eth_write(port_info, 1, RTRATE); |
Marek Vasut | effb790 | 2018-01-22 01:42:32 +0100 | [diff] [blame] | 477 | #elif defined(CONFIG_CPU_SH7724) || defined(CONFIG_RCAR_GEN2) |
Nobuhiro Iwamatsu | 3bb4cc3 | 2011-11-14 16:56:59 +0900 | [diff] [blame] | 478 | val = ECMR_RTM; |
| 479 | #endif |
Yoshihiro Shimoda | bd1024b | 2011-10-11 18:10:14 +0900 | [diff] [blame] | 480 | } else if (phy->speed == 10) { |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 481 | printf(SHETHER_NAME ": 10Base/"); |
Yoshihiro Shimoda | 2623509 | 2012-06-26 16:38:06 +0000 | [diff] [blame] | 482 | #if defined(SH_ETH_TYPE_GETHER) |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 483 | sh_eth_write(port_info, GECMR_10B, GECMR); |
Yoshihiro Shimoda | e3bb325 | 2012-11-04 15:54:30 +0000 | [diff] [blame] | 484 | #elif defined(CONFIG_CPU_SH7757) || defined(CONFIG_CPU_SH7752) |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 485 | sh_eth_write(port_info, 0, RTRATE); |
Yoshihiro Shimoda | 903de46 | 2011-01-18 17:53:45 +0900 | [diff] [blame] | 486 | #endif |
Nobuhiro Iwamatsu | 3bb4cc3 | 2011-11-14 16:56:59 +0900 | [diff] [blame] | 487 | } |
Yoshihiro Shimoda | 2623509 | 2012-06-26 16:38:06 +0000 | [diff] [blame] | 488 | #if defined(SH_ETH_TYPE_GETHER) |
Nobuhiro Iwamatsu | 4398d55 | 2012-05-15 15:49:39 +0000 | [diff] [blame] | 489 | else if (phy->speed == 1000) { |
| 490 | printf(SHETHER_NAME ": 1000Base/"); |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 491 | sh_eth_write(port_info, GECMR_1000B, GECMR); |
Nobuhiro Iwamatsu | 4398d55 | 2012-05-15 15:49:39 +0000 | [diff] [blame] | 492 | } |
| 493 | #endif |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 494 | |
| 495 | /* Check if full duplex mode is supported by the phy */ |
Yoshihiro Shimoda | bd1024b | 2011-10-11 18:10:14 +0900 | [diff] [blame] | 496 | if (phy->duplex) { |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 497 | printf("Full\n"); |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 498 | sh_eth_write(port_info, |
Nobuhiro Iwamatsu | dc14867 | 2017-12-01 08:08:00 +0900 | [diff] [blame] | 499 | val | (ECMR_CHG_DM | ECMR_RE | ECMR_TE | ECMR_DM), |
Yoshihiro Shimoda | 49afb8c | 2012-06-26 16:38:09 +0000 | [diff] [blame] | 500 | ECMR); |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 501 | } else { |
| 502 | printf("Half\n"); |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 503 | sh_eth_write(port_info, |
Nobuhiro Iwamatsu | dc14867 | 2017-12-01 08:08:00 +0900 | [diff] [blame] | 504 | val | (ECMR_CHG_DM | ECMR_RE | ECMR_TE), |
| 505 | ECMR); |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 506 | } |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 507 | |
| 508 | return ret; |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 509 | } |
| 510 | |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 511 | static void sh_eth_start(struct sh_eth_dev *eth) |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 512 | { |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 513 | struct sh_eth_info *port_info = ð->port_info[eth->port]; |
| 514 | |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 515 | /* |
| 516 | * Enable the e-dmac receiver only. The transmitter will be enabled when |
| 517 | * we have something to transmit |
| 518 | */ |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 519 | sh_eth_write(port_info, EDRRR_R, EDRRR); |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 520 | } |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 521 | |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 522 | static void sh_eth_stop(struct sh_eth_dev *eth) |
| 523 | { |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 524 | struct sh_eth_info *port_info = ð->port_info[eth->port]; |
| 525 | |
| 526 | sh_eth_write(port_info, ~EDRRR_R, EDRRR); |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 527 | } |
| 528 | |
Marek Vasut | 013af64 | 2018-01-21 15:10:21 +0100 | [diff] [blame^] | 529 | static int sh_eth_init_common(struct sh_eth_dev *eth, unsigned char *mac) |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 530 | { |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 531 | int ret = 0; |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 532 | |
| 533 | ret = sh_eth_reset(eth); |
| 534 | if (ret) |
Marek Vasut | 013af64 | 2018-01-21 15:10:21 +0100 | [diff] [blame^] | 535 | return ret; |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 536 | |
| 537 | ret = sh_eth_desc_init(eth); |
| 538 | if (ret) |
Marek Vasut | 013af64 | 2018-01-21 15:10:21 +0100 | [diff] [blame^] | 539 | return ret; |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 540 | |
Marek Vasut | 013af64 | 2018-01-21 15:10:21 +0100 | [diff] [blame^] | 541 | sh_eth_mac_regs_config(eth, mac); |
| 542 | |
| 543 | return 0; |
| 544 | } |
| 545 | |
| 546 | static int sh_eth_start_common(struct sh_eth_dev *eth) |
| 547 | { |
| 548 | struct sh_eth_info *port_info = ð->port_info[eth->port]; |
| 549 | int ret; |
| 550 | |
| 551 | ret = phy_startup(port_info->phydev); |
| 552 | if (ret) { |
| 553 | printf(SHETHER_NAME ": phy startup failure\n"); |
| 554 | return ret; |
| 555 | } |
| 556 | |
| 557 | ret = sh_eth_phy_regs_config(eth); |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 558 | if (ret) |
Marek Vasut | 013af64 | 2018-01-21 15:10:21 +0100 | [diff] [blame^] | 559 | return ret; |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 560 | |
| 561 | sh_eth_start(eth); |
| 562 | |
Marek Vasut | 013af64 | 2018-01-21 15:10:21 +0100 | [diff] [blame^] | 563 | return 0; |
| 564 | } |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 565 | |
Marek Vasut | 013af64 | 2018-01-21 15:10:21 +0100 | [diff] [blame^] | 566 | static int sh_eth_init_legacy(struct eth_device *dev, bd_t *bd) |
| 567 | { |
| 568 | struct sh_eth_dev *eth = dev->priv; |
| 569 | int ret; |
| 570 | |
| 571 | ret = sh_eth_init_common(eth, dev->enetaddr); |
| 572 | if (ret) |
| 573 | return ret; |
| 574 | |
| 575 | ret = sh_eth_phy_config_legacy(eth); |
| 576 | if (ret) { |
| 577 | printf(SHETHER_NAME ": phy config timeout\n"); |
| 578 | goto err_start; |
| 579 | } |
| 580 | |
| 581 | ret = sh_eth_start_common(eth); |
| 582 | if (ret) |
| 583 | goto err_start; |
| 584 | |
| 585 | return 0; |
| 586 | |
| 587 | err_start: |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 588 | sh_eth_tx_desc_free(eth); |
| 589 | sh_eth_rx_desc_free(eth); |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 590 | return ret; |
| 591 | } |
| 592 | |
Marek Vasut | 013af64 | 2018-01-21 15:10:21 +0100 | [diff] [blame^] | 593 | void sh_eth_halt_legacy(struct eth_device *dev) |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 594 | { |
| 595 | struct sh_eth_dev *eth = dev->priv; |
Nobuhiro Iwamatsu | dc14867 | 2017-12-01 08:08:00 +0900 | [diff] [blame] | 596 | |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 597 | sh_eth_stop(eth); |
| 598 | } |
| 599 | |
| 600 | int sh_eth_initialize(bd_t *bd) |
| 601 | { |
Nobuhiro Iwamatsu | e2752db | 2014-01-23 07:52:19 +0900 | [diff] [blame] | 602 | int ret = 0; |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 603 | struct sh_eth_dev *eth = NULL; |
Nobuhiro Iwamatsu | e2752db | 2014-01-23 07:52:19 +0900 | [diff] [blame] | 604 | struct eth_device *dev = NULL; |
Nobuhiro Iwamatsu | dc14867 | 2017-12-01 08:08:00 +0900 | [diff] [blame] | 605 | struct mii_dev *mdiodev; |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 606 | |
Nobuhiro Iwamatsu | e2752db | 2014-01-23 07:52:19 +0900 | [diff] [blame] | 607 | eth = (struct sh_eth_dev *)malloc(sizeof(struct sh_eth_dev)); |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 608 | if (!eth) { |
| 609 | printf(SHETHER_NAME ": %s: malloc failed\n", __func__); |
| 610 | ret = -ENOMEM; |
| 611 | goto err; |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 612 | } |
| 613 | |
Nobuhiro Iwamatsu | e2752db | 2014-01-23 07:52:19 +0900 | [diff] [blame] | 614 | dev = (struct eth_device *)malloc(sizeof(struct eth_device)); |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 615 | if (!dev) { |
| 616 | printf(SHETHER_NAME ": %s: malloc failed\n", __func__); |
| 617 | ret = -ENOMEM; |
| 618 | goto err; |
| 619 | } |
Nobuhiro Iwamatsu | e2752db | 2014-01-23 07:52:19 +0900 | [diff] [blame] | 620 | memset(dev, 0, sizeof(struct eth_device)); |
| 621 | memset(eth, 0, sizeof(struct sh_eth_dev)); |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 622 | |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 623 | eth->port = CONFIG_SH_ETHER_USE_PORT; |
| 624 | eth->port_info[eth->port].phy_addr = CONFIG_SH_ETHER_PHY_ADDR; |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 625 | eth->port_info[eth->port].iobase = |
| 626 | (void __iomem *)(BASE_IO_ADDR + 0x800 * eth->port); |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 627 | |
Nobuhiro Iwamatsu | e2752db | 2014-01-23 07:52:19 +0900 | [diff] [blame] | 628 | dev->priv = (void *)eth; |
| 629 | dev->iobase = 0; |
Marek Vasut | 013af64 | 2018-01-21 15:10:21 +0100 | [diff] [blame^] | 630 | dev->init = sh_eth_init_legacy; |
| 631 | dev->halt = sh_eth_halt_legacy; |
Marek Vasut | dca221b | 2018-01-21 14:27:51 +0100 | [diff] [blame] | 632 | dev->send = sh_eth_send_legacy; |
| 633 | dev->recv = sh_eth_recv_legacy; |
Nobuhiro Iwamatsu | e2752db | 2014-01-23 07:52:19 +0900 | [diff] [blame] | 634 | eth->port_info[eth->port].dev = dev; |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 635 | |
Ben Whitten | 192bc69 | 2015-12-30 13:05:58 +0000 | [diff] [blame] | 636 | strcpy(dev->name, SHETHER_NAME); |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 637 | |
Nobuhiro Iwamatsu | e2752db | 2014-01-23 07:52:19 +0900 | [diff] [blame] | 638 | /* Register Device to EtherNet subsystem */ |
| 639 | eth_register(dev); |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 640 | |
Yoshihiro Shimoda | bd1024b | 2011-10-11 18:10:14 +0900 | [diff] [blame] | 641 | bb_miiphy_buses[0].priv = eth; |
Nobuhiro Iwamatsu | dc14867 | 2017-12-01 08:08:00 +0900 | [diff] [blame] | 642 | mdiodev = mdio_alloc(); |
Joe Hershberger | 5a49f17 | 2016-08-08 11:28:38 -0500 | [diff] [blame] | 643 | if (!mdiodev) |
| 644 | return -ENOMEM; |
| 645 | strncpy(mdiodev->name, dev->name, MDIO_NAME_LEN); |
| 646 | mdiodev->read = bb_miiphy_read; |
| 647 | mdiodev->write = bb_miiphy_write; |
| 648 | |
Nobuhiro Iwamatsu | dc14867 | 2017-12-01 08:08:00 +0900 | [diff] [blame] | 649 | ret = mdio_register(mdiodev); |
| 650 | if (ret < 0) |
| 651 | return ret; |
Yoshihiro Shimoda | bd1024b | 2011-10-11 18:10:14 +0900 | [diff] [blame] | 652 | |
Simon Glass | 35affd7 | 2017-08-03 12:22:14 -0600 | [diff] [blame] | 653 | if (!eth_env_get_enetaddr("ethaddr", dev->enetaddr)) |
Mike Frysinger | c527ce9 | 2009-02-11 19:14:09 -0500 | [diff] [blame] | 654 | puts("Please set MAC address\n"); |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 655 | |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 656 | return ret; |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 657 | |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 658 | err: |
Nobuhiro Iwamatsu | bd3980c | 2008-11-21 12:04:18 +0900 | [diff] [blame] | 659 | if (dev) |
| 660 | free(dev); |
| 661 | |
| 662 | if (eth) |
| 663 | free(eth); |
| 664 | |
| 665 | printf(SHETHER_NAME ": Failed\n"); |
| 666 | return ret; |
Nobuhiro Iwamatsu | 9751ee0 | 2008-06-11 21:05:00 +0900 | [diff] [blame] | 667 | } |
Yoshihiro Shimoda | bd1024b | 2011-10-11 18:10:14 +0900 | [diff] [blame] | 668 | |
| 669 | /******* for bb_miiphy *******/ |
| 670 | static int sh_eth_bb_init(struct bb_miiphy_bus *bus) |
| 671 | { |
| 672 | return 0; |
| 673 | } |
| 674 | |
| 675 | static int sh_eth_bb_mdio_active(struct bb_miiphy_bus *bus) |
| 676 | { |
| 677 | struct sh_eth_dev *eth = bus->priv; |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 678 | struct sh_eth_info *port_info = ð->port_info[eth->port]; |
Yoshihiro Shimoda | bd1024b | 2011-10-11 18:10:14 +0900 | [diff] [blame] | 679 | |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 680 | 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] | 681 | |
| 682 | return 0; |
| 683 | } |
| 684 | |
| 685 | static int sh_eth_bb_mdio_tristate(struct bb_miiphy_bus *bus) |
| 686 | { |
| 687 | struct sh_eth_dev *eth = bus->priv; |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 688 | struct sh_eth_info *port_info = ð->port_info[eth->port]; |
Yoshihiro Shimoda | bd1024b | 2011-10-11 18:10:14 +0900 | [diff] [blame] | 689 | |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 690 | 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] | 691 | |
| 692 | return 0; |
| 693 | } |
| 694 | |
| 695 | static int sh_eth_bb_set_mdio(struct bb_miiphy_bus *bus, int v) |
| 696 | { |
| 697 | struct sh_eth_dev *eth = bus->priv; |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 698 | struct sh_eth_info *port_info = ð->port_info[eth->port]; |
Yoshihiro Shimoda | bd1024b | 2011-10-11 18:10:14 +0900 | [diff] [blame] | 699 | |
| 700 | if (v) |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 701 | sh_eth_write(port_info, |
| 702 | sh_eth_read(port_info, PIR) | PIR_MDO, PIR); |
Yoshihiro Shimoda | bd1024b | 2011-10-11 18:10:14 +0900 | [diff] [blame] | 703 | else |
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_MDO, PIR); |
Yoshihiro Shimoda | bd1024b | 2011-10-11 18:10:14 +0900 | [diff] [blame] | 706 | |
| 707 | return 0; |
| 708 | } |
| 709 | |
| 710 | static int sh_eth_bb_get_mdio(struct bb_miiphy_bus *bus, int *v) |
| 711 | { |
| 712 | struct sh_eth_dev *eth = bus->priv; |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 713 | struct sh_eth_info *port_info = ð->port_info[eth->port]; |
Yoshihiro Shimoda | bd1024b | 2011-10-11 18:10:14 +0900 | [diff] [blame] | 714 | |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 715 | *v = (sh_eth_read(port_info, PIR) & PIR_MDI) >> 3; |
Yoshihiro Shimoda | bd1024b | 2011-10-11 18:10:14 +0900 | [diff] [blame] | 716 | |
| 717 | return 0; |
| 718 | } |
| 719 | |
| 720 | static int sh_eth_bb_set_mdc(struct bb_miiphy_bus *bus, int v) |
| 721 | { |
| 722 | struct sh_eth_dev *eth = bus->priv; |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 723 | struct sh_eth_info *port_info = ð->port_info[eth->port]; |
Yoshihiro Shimoda | bd1024b | 2011-10-11 18:10:14 +0900 | [diff] [blame] | 724 | |
| 725 | if (v) |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 726 | sh_eth_write(port_info, |
| 727 | sh_eth_read(port_info, PIR) | PIR_MDC, PIR); |
Yoshihiro Shimoda | bd1024b | 2011-10-11 18:10:14 +0900 | [diff] [blame] | 728 | else |
Nobuhiro Iwamatsu | fbfb511 | 2017-12-01 08:10:32 +0900 | [diff] [blame] | 729 | sh_eth_write(port_info, |
| 730 | sh_eth_read(port_info, PIR) & ~PIR_MDC, PIR); |
Yoshihiro Shimoda | bd1024b | 2011-10-11 18:10:14 +0900 | [diff] [blame] | 731 | |
| 732 | return 0; |
| 733 | } |
| 734 | |
| 735 | static int sh_eth_bb_delay(struct bb_miiphy_bus *bus) |
| 736 | { |
| 737 | udelay(10); |
| 738 | |
| 739 | return 0; |
| 740 | } |
| 741 | |
| 742 | struct bb_miiphy_bus bb_miiphy_buses[] = { |
| 743 | { |
| 744 | .name = "sh_eth", |
| 745 | .init = sh_eth_bb_init, |
| 746 | .mdio_active = sh_eth_bb_mdio_active, |
| 747 | .mdio_tristate = sh_eth_bb_mdio_tristate, |
| 748 | .set_mdio = sh_eth_bb_set_mdio, |
| 749 | .get_mdio = sh_eth_bb_get_mdio, |
| 750 | .set_mdc = sh_eth_bb_set_mdc, |
| 751 | .delay = sh_eth_bb_delay, |
| 752 | } |
| 753 | }; |
Nobuhiro Iwamatsu | dc14867 | 2017-12-01 08:08:00 +0900 | [diff] [blame] | 754 | |
Yoshihiro Shimoda | bd1024b | 2011-10-11 18:10:14 +0900 | [diff] [blame] | 755 | int bb_miiphy_buses_num = ARRAY_SIZE(bb_miiphy_buses); |