1 /* 2 * Faraday FTMAC100 Ethernet 3 * 4 * (C) Copyright 2009 Faraday Technology 5 * Po-Yu Chuang <ratbert@faraday-tech.com> 6 * 7 * SPDX-License-Identifier: GPL-2.0+ 8 */ 9 10 #include <config.h> 11 #include <common.h> 12 #include <malloc.h> 13 #include <net.h> 14 #include <linux/io.h> 15 16 #include "ftmac100.h" 17 #ifdef CONFIG_DM_ETH 18 #include <dm.h> 19 DECLARE_GLOBAL_DATA_PTR; 20 #endif 21 #define ETH_ZLEN 60 22 23 struct ftmac100_data { 24 struct ftmac100_txdes txdes[1]; 25 struct ftmac100_rxdes rxdes[PKTBUFSRX]; 26 int rx_index; 27 const char *name; 28 phys_addr_t iobase; 29 }; 30 31 /* 32 * Reset MAC 33 */ 34 static void ftmac100_reset(struct ftmac100_data *priv) 35 { 36 struct ftmac100 *ftmac100 = (struct ftmac100 *)priv->iobase; 37 38 debug ("%s()\n", __func__); 39 40 writel (FTMAC100_MACCR_SW_RST, &ftmac100->maccr); 41 42 while (readl (&ftmac100->maccr) & FTMAC100_MACCR_SW_RST) 43 ; 44 } 45 46 /* 47 * Set MAC address 48 */ 49 static void ftmac100_set_mac(struct ftmac100_data *priv , 50 const unsigned char *mac) 51 { 52 struct ftmac100 *ftmac100 = (struct ftmac100 *)priv->iobase; 53 unsigned int maddr = mac[0] << 8 | mac[1]; 54 unsigned int laddr = mac[2] << 24 | mac[3] << 16 | mac[4] << 8 | mac[5]; 55 56 debug ("%s(%x %x)\n", __func__, maddr, laddr); 57 58 writel (maddr, &ftmac100->mac_madr); 59 writel (laddr, &ftmac100->mac_ladr); 60 } 61 62 /* 63 * Disable MAC 64 */ 65 static void _ftmac100_halt(struct ftmac100_data *priv) 66 { 67 struct ftmac100 *ftmac100 = (struct ftmac100 *)priv->iobase; 68 debug ("%s()\n", __func__); 69 writel (0, &ftmac100->maccr); 70 } 71 72 /* 73 * Initialize MAC 74 */ 75 static int _ftmac100_init(struct ftmac100_data *priv, unsigned char enetaddr[6]) 76 { 77 struct ftmac100 *ftmac100 = (struct ftmac100 *)priv->iobase; 78 struct ftmac100_txdes *txdes = priv->txdes; 79 struct ftmac100_rxdes *rxdes = priv->rxdes; 80 unsigned int maccr; 81 int i; 82 83 debug ("%s()\n", __func__); 84 85 ftmac100_reset(priv); 86 87 /* set the ethernet address */ 88 ftmac100_set_mac(priv, enetaddr); 89 90 91 /* disable all interrupts */ 92 93 writel (0, &ftmac100->imr); 94 95 /* initialize descriptors */ 96 97 priv->rx_index = 0; 98 99 txdes[0].txdes1 = FTMAC100_TXDES1_EDOTR; 100 rxdes[PKTBUFSRX - 1].rxdes1 = FTMAC100_RXDES1_EDORR; 101 102 for (i = 0; i < PKTBUFSRX; i++) { 103 /* RXBUF_BADR */ 104 rxdes[i].rxdes2 = (unsigned int)net_rx_packets[i]; 105 rxdes[i].rxdes1 |= FTMAC100_RXDES1_RXBUF_SIZE (PKTSIZE_ALIGN); 106 rxdes[i].rxdes0 = FTMAC100_RXDES0_RXDMA_OWN; 107 } 108 109 /* transmit ring */ 110 111 writel ((unsigned int)txdes, &ftmac100->txr_badr); 112 113 /* receive ring */ 114 115 writel ((unsigned int)rxdes, &ftmac100->rxr_badr); 116 117 /* poll receive descriptor automatically */ 118 119 writel (FTMAC100_APTC_RXPOLL_CNT (1), &ftmac100->aptc); 120 121 /* enable transmitter, receiver */ 122 123 maccr = FTMAC100_MACCR_XMT_EN | 124 FTMAC100_MACCR_RCV_EN | 125 FTMAC100_MACCR_XDMA_EN | 126 FTMAC100_MACCR_RDMA_EN | 127 FTMAC100_MACCR_CRC_APD | 128 FTMAC100_MACCR_ENRX_IN_HALFTX | 129 FTMAC100_MACCR_RX_RUNT | 130 FTMAC100_MACCR_RX_BROADPKT; 131 132 writel (maccr, &ftmac100->maccr); 133 134 return 0; 135 } 136 137 /* 138 * Free receiving buffer 139 */ 140 static int _ftmac100_free_pkt(struct ftmac100_data *priv) 141 { 142 struct ftmac100_rxdes *curr_des; 143 curr_des = &priv->rxdes[priv->rx_index]; 144 /* release buffer to DMA */ 145 curr_des->rxdes0 |= FTMAC100_RXDES0_RXDMA_OWN; 146 priv->rx_index = (priv->rx_index + 1) % PKTBUFSRX; 147 return 0; 148 } 149 150 /* 151 * Receive a data block via Ethernet 152 */ 153 static int __ftmac100_recv(struct ftmac100_data *priv) 154 { 155 struct ftmac100_rxdes *curr_des; 156 unsigned short rxlen; 157 158 curr_des = &priv->rxdes[priv->rx_index]; 159 160 if (curr_des->rxdes0 & FTMAC100_RXDES0_RXDMA_OWN) 161 return 0; 162 163 if (curr_des->rxdes0 & (FTMAC100_RXDES0_RX_ERR | 164 FTMAC100_RXDES0_CRC_ERR | 165 FTMAC100_RXDES0_FTL | 166 FTMAC100_RXDES0_RUNT | 167 FTMAC100_RXDES0_RX_ODD_NB)) { 168 return 0; 169 } 170 171 rxlen = FTMAC100_RXDES0_RFL (curr_des->rxdes0); 172 173 debug ("%s(): RX buffer %d, %x received\n", 174 __func__, priv->rx_index, rxlen); 175 176 return rxlen; 177 } 178 179 /* 180 * Send a data block via Ethernet 181 */ 182 static int _ftmac100_send(struct ftmac100_data *priv, void *packet, int length) 183 { 184 struct ftmac100 *ftmac100 = (struct ftmac100 *)priv->iobase; 185 struct ftmac100_txdes *curr_des = priv->txdes; 186 ulong start; 187 188 if (curr_des->txdes0 & FTMAC100_TXDES0_TXDMA_OWN) { 189 debug ("%s(): no TX descriptor available\n", __func__); 190 return -1; 191 } 192 193 debug ("%s(%x, %x)\n", __func__, (int)packet, length); 194 195 length = (length < ETH_ZLEN) ? ETH_ZLEN : length; 196 197 /* initiate a transmit sequence */ 198 199 curr_des->txdes2 = (unsigned int)packet; /* TXBUF_BADR */ 200 201 curr_des->txdes1 &= FTMAC100_TXDES1_EDOTR; 202 curr_des->txdes1 |= FTMAC100_TXDES1_FTS | 203 FTMAC100_TXDES1_LTS | 204 FTMAC100_TXDES1_TXBUF_SIZE (length); 205 206 curr_des->txdes0 = FTMAC100_TXDES0_TXDMA_OWN; 207 208 /* start transmit */ 209 210 writel (1, &ftmac100->txpd); 211 212 /* wait for transfer to succeed */ 213 214 start = get_timer(0); 215 while (curr_des->txdes0 & FTMAC100_TXDES0_TXDMA_OWN) { 216 if (get_timer(start) >= 5) { 217 debug ("%s(): timed out\n", __func__); 218 return -1; 219 } 220 } 221 222 debug ("%s(): packet sent\n", __func__); 223 224 return 0; 225 } 226 227 #ifndef CONFIG_DM_ETH 228 /* 229 * disable transmitter, receiver 230 */ 231 static void ftmac100_halt(struct eth_device *dev) 232 { 233 struct ftmac100_data *priv = dev->priv; 234 return _ftmac100_halt(priv); 235 } 236 237 static int ftmac100_init(struct eth_device *dev, bd_t *bd) 238 { 239 struct ftmac100_data *priv = dev->priv; 240 return _ftmac100_init(priv , dev->enetaddr); 241 } 242 243 static int _ftmac100_recv(struct ftmac100_data *priv) 244 { 245 struct ftmac100_rxdes *curr_des; 246 unsigned short len; 247 curr_des = &priv->rxdes[priv->rx_index]; 248 len = __ftmac100_recv(priv); 249 if (len) { 250 /* pass the packet up to the protocol layers. */ 251 net_process_received_packet((void *)curr_des->rxdes2, len); 252 _ftmac100_free_pkt(priv); 253 } 254 return len ? 1 : 0; 255 } 256 257 /* 258 * Get a data block via Ethernet 259 */ 260 static int ftmac100_recv(struct eth_device *dev) 261 { 262 struct ftmac100_data *priv = dev->priv; 263 return _ftmac100_recv(priv); 264 } 265 266 /* 267 * Send a data block via Ethernet 268 */ 269 static int ftmac100_send(struct eth_device *dev, void *packet, int length) 270 { 271 struct ftmac100_data *priv = dev->priv; 272 return _ftmac100_send(priv , packet , length); 273 } 274 275 int ftmac100_initialize (bd_t *bd) 276 { 277 struct eth_device *dev; 278 struct ftmac100_data *priv; 279 dev = malloc (sizeof *dev); 280 if (!dev) { 281 printf ("%s(): failed to allocate dev\n", __func__); 282 goto out; 283 } 284 /* Transmit and receive descriptors should align to 16 bytes */ 285 priv = memalign (16, sizeof (struct ftmac100_data)); 286 if (!priv) { 287 printf ("%s(): failed to allocate priv\n", __func__); 288 goto free_dev; 289 } 290 memset (dev, 0, sizeof (*dev)); 291 memset (priv, 0, sizeof (*priv)); 292 293 strcpy(dev->name, "FTMAC100"); 294 dev->iobase = CONFIG_FTMAC100_BASE; 295 dev->init = ftmac100_init; 296 dev->halt = ftmac100_halt; 297 dev->send = ftmac100_send; 298 dev->recv = ftmac100_recv; 299 dev->priv = priv; 300 priv->iobase = dev->iobase; 301 eth_register (dev); 302 303 return 1; 304 305 free_dev: 306 free (dev); 307 out: 308 return 0; 309 } 310 #endif 311 312 #ifdef CONFIG_DM_ETH 313 static int ftmac100_start(struct udevice *dev) 314 { 315 struct eth_pdata *plat = dev_get_platdata(dev); 316 struct ftmac100_data *priv = dev_get_priv(dev); 317 318 return _ftmac100_init(priv, plat->enetaddr); 319 } 320 321 static void ftmac100_stop(struct udevice *dev) 322 { 323 struct ftmac100_data *priv = dev_get_priv(dev); 324 _ftmac100_halt(priv); 325 } 326 327 static int ftmac100_send(struct udevice *dev, void *packet, int length) 328 { 329 struct ftmac100_data *priv = dev_get_priv(dev); 330 int ret; 331 ret = _ftmac100_send(priv , packet , length); 332 return ret ? 0 : -ETIMEDOUT; 333 } 334 335 static int ftmac100_recv(struct udevice *dev, int flags, uchar **packetp) 336 { 337 struct ftmac100_data *priv = dev_get_priv(dev); 338 struct ftmac100_rxdes *curr_des; 339 curr_des = &priv->rxdes[priv->rx_index]; 340 int len; 341 len = __ftmac100_recv(priv); 342 if (len) 343 *packetp = (void *)curr_des->rxdes2; 344 345 return len ? len : -EAGAIN; 346 } 347 348 static int ftmac100_free_pkt(struct udevice *dev, uchar *packet, int length) 349 { 350 struct ftmac100_data *priv = dev_get_priv(dev); 351 _ftmac100_free_pkt(priv); 352 return 0; 353 } 354 355 int ftmac100_read_rom_hwaddr(struct udevice *dev) 356 { 357 struct eth_pdata *pdata = dev_get_platdata(dev); 358 eth_env_get_enetaddr("ethaddr", pdata->enetaddr); 359 return 0; 360 } 361 362 static const char *dtbmacaddr(u32 ifno) 363 { 364 int node, len; 365 char enet[16]; 366 const char *mac; 367 const char *path; 368 if (gd->fdt_blob == NULL) { 369 printf("%s: don't have a valid gd->fdt_blob!\n", __func__); 370 return NULL; 371 } 372 node = fdt_path_offset(gd->fdt_blob, "/aliases"); 373 if (node < 0) 374 return NULL; 375 376 sprintf(enet, "ethernet%d", ifno); 377 path = fdt_getprop(gd->fdt_blob, node, enet, NULL); 378 if (!path) { 379 printf("no alias for %s\n", enet); 380 return NULL; 381 } 382 node = fdt_path_offset(gd->fdt_blob, path); 383 mac = fdt_getprop(gd->fdt_blob, node, "mac-address", &len); 384 if (mac && is_valid_ethaddr((u8 *)mac)) 385 return mac; 386 387 return NULL; 388 } 389 390 static int ftmac100_ofdata_to_platdata(struct udevice *dev) 391 { 392 struct ftmac100_data *priv = dev_get_priv(dev); 393 struct eth_pdata *pdata = dev_get_platdata(dev); 394 const char *mac; 395 pdata->iobase = devfdt_get_addr(dev); 396 priv->iobase = pdata->iobase; 397 mac = dtbmacaddr(0); 398 if (mac) 399 memcpy(pdata->enetaddr , mac , 6); 400 401 return 0; 402 } 403 404 static int ftmac100_probe(struct udevice *dev) 405 { 406 struct ftmac100_data *priv = dev_get_priv(dev); 407 priv->name = dev->name; 408 return 0; 409 } 410 411 static int ftmac100_bind(struct udevice *dev) 412 { 413 return device_set_name(dev, dev->name); 414 } 415 416 static const struct eth_ops ftmac100_ops = { 417 .start = ftmac100_start, 418 .send = ftmac100_send, 419 .recv = ftmac100_recv, 420 .stop = ftmac100_stop, 421 .free_pkt = ftmac100_free_pkt, 422 }; 423 424 static const struct udevice_id ftmac100_ids[] = { 425 { .compatible = "andestech,atmac100" }, 426 { } 427 }; 428 429 U_BOOT_DRIVER(ftmac100) = { 430 .name = "nds32_mac", 431 .id = UCLASS_ETH, 432 .of_match = ftmac100_ids, 433 .bind = ftmac100_bind, 434 .ofdata_to_platdata = ftmac100_ofdata_to_platdata, 435 .probe = ftmac100_probe, 436 .ops = &ftmac100_ops, 437 .priv_auto_alloc_size = sizeof(struct ftmac100_data), 438 .platdata_auto_alloc_size = sizeof(struct eth_pdata), 439 .flags = DM_FLAG_ALLOC_PRIV_DMA, 440 }; 441 #endif 442