1 /* 2 * (C) Copyright 2010 3 * Reinhard Meyer, EMK Elektronik, reinhard.meyer@emk-elektronik.de 4 * Martin Krause, Martin.Krause@tqs.de 5 * reworked original enc28j60.c 6 * 7 * SPDX-License-Identifier: GPL-2.0+ 8 */ 9 10 #include <common.h> 11 #include <net.h> 12 #include <spi.h> 13 #include <malloc.h> 14 #include <netdev.h> 15 #include <miiphy.h> 16 #include "enc28j60.h" 17 18 /* 19 * IMPORTANT: spi_claim_bus() and spi_release_bus() 20 * are called at begin and end of each of the following functions: 21 * enc_miiphy_read(), enc_miiphy_write(), enc_write_hwaddr(), 22 * enc_init(), enc_recv(), enc_send(), enc_halt() 23 * ALL other functions assume that the bus has already been claimed! 24 * Since net_process_received_packet() might call enc_send() in return, the bus 25 * must be released, net_process_received_packet() called and claimed again. 26 */ 27 28 /* 29 * Controller memory layout. 30 * We only allow 1 frame for transmission and reserve the rest 31 * for reception to handle as many broadcast packets as possible. 32 * Also use the memory from 0x0000 for receiver buffer. See errata pt. 5 33 * 0x0000 - 0x19ff 6656 bytes receive buffer 34 * 0x1a00 - 0x1fff 1536 bytes transmit buffer = 35 * control(1)+frame(1518)+status(7)+reserve(10). 36 */ 37 #define ENC_RX_BUF_START 0x0000 38 #define ENC_RX_BUF_END 0x19ff 39 #define ENC_TX_BUF_START 0x1a00 40 #define ENC_TX_BUF_END 0x1fff 41 #define ENC_MAX_FRM_LEN 1518 42 #define RX_RESET_COUNTER 1000 43 44 /* 45 * For non data transfer functions, like phy read/write, set hwaddr, init 46 * we do not need a full, time consuming init including link ready wait. 47 * This enum helps to bring the chip through the minimum necessary inits. 48 */ 49 enum enc_initstate {none=0, setupdone, linkready}; 50 typedef struct enc_device { 51 struct eth_device *dev; /* back pointer */ 52 struct spi_slave *slave; 53 int rx_reset_counter; 54 u16 next_pointer; 55 u8 bank; /* current bank in enc28j60 */ 56 enum enc_initstate initstate; 57 } enc_dev_t; 58 59 /* 60 * enc_bset: set bits in a common register 61 * enc_bclr: clear bits in a common register 62 * 63 * making the reg parameter u8 will give a compile time warning if the 64 * functions are called with a register not accessible in all Banks 65 */ 66 static void enc_bset(enc_dev_t *enc, const u8 reg, const u8 data) 67 { 68 u8 dout[2]; 69 70 dout[0] = CMD_BFS(reg); 71 dout[1] = data; 72 spi_xfer(enc->slave, 2 * 8, dout, NULL, 73 SPI_XFER_BEGIN | SPI_XFER_END); 74 } 75 76 static void enc_bclr(enc_dev_t *enc, const u8 reg, const u8 data) 77 { 78 u8 dout[2]; 79 80 dout[0] = CMD_BFC(reg); 81 dout[1] = data; 82 spi_xfer(enc->slave, 2 * 8, dout, NULL, 83 SPI_XFER_BEGIN | SPI_XFER_END); 84 } 85 86 /* 87 * high byte of the register contains bank number: 88 * 0: no bank switch necessary 89 * 1: switch to bank 0 90 * 2: switch to bank 1 91 * 3: switch to bank 2 92 * 4: switch to bank 3 93 */ 94 static void enc_set_bank(enc_dev_t *enc, const u16 reg) 95 { 96 u8 newbank = reg >> 8; 97 98 if (newbank == 0 || newbank == enc->bank) 99 return; 100 switch (newbank) { 101 case 1: 102 enc_bclr(enc, CTL_REG_ECON1, 103 ENC_ECON1_BSEL0 | ENC_ECON1_BSEL1); 104 break; 105 case 2: 106 enc_bset(enc, CTL_REG_ECON1, ENC_ECON1_BSEL0); 107 enc_bclr(enc, CTL_REG_ECON1, ENC_ECON1_BSEL1); 108 break; 109 case 3: 110 enc_bclr(enc, CTL_REG_ECON1, ENC_ECON1_BSEL0); 111 enc_bset(enc, CTL_REG_ECON1, ENC_ECON1_BSEL1); 112 break; 113 case 4: 114 enc_bset(enc, CTL_REG_ECON1, 115 ENC_ECON1_BSEL0 | ENC_ECON1_BSEL1); 116 break; 117 } 118 enc->bank = newbank; 119 } 120 121 /* 122 * local functions to access SPI 123 * 124 * reg: register inside ENC28J60 125 * data: 8/16 bits to write 126 * c: number of retries 127 * 128 * enc_r8: read 8 bits 129 * enc_r16: read 16 bits 130 * enc_w8: write 8 bits 131 * enc_w16: write 16 bits 132 * enc_w8_retry: write 8 bits, verify and retry 133 * enc_rbuf: read from ENC28J60 into buffer 134 * enc_wbuf: write from buffer into ENC28J60 135 */ 136 137 /* 138 * MAC and MII registers need a 3 byte SPI transfer to read, 139 * all other registers need a 2 byte SPI transfer. 140 */ 141 static int enc_reg2nbytes(const u16 reg) 142 { 143 /* check if MAC or MII register */ 144 return ((reg >= CTL_REG_MACON1 && reg <= CTL_REG_MIRDH) || 145 (reg >= CTL_REG_MAADR1 && reg <= CTL_REG_MAADR4) || 146 (reg == CTL_REG_MISTAT)) ? 3 : 2; 147 } 148 149 /* 150 * Read a byte register 151 */ 152 static u8 enc_r8(enc_dev_t *enc, const u16 reg) 153 { 154 u8 dout[3]; 155 u8 din[3]; 156 int nbytes = enc_reg2nbytes(reg); 157 158 enc_set_bank(enc, reg); 159 dout[0] = CMD_RCR(reg); 160 spi_xfer(enc->slave, nbytes * 8, dout, din, 161 SPI_XFER_BEGIN | SPI_XFER_END); 162 return din[nbytes-1]; 163 } 164 165 /* 166 * Read a L/H register pair and return a word. 167 * Must be called with the L register's address. 168 */ 169 static u16 enc_r16(enc_dev_t *enc, const u16 reg) 170 { 171 u8 dout[3]; 172 u8 din[3]; 173 u16 result; 174 int nbytes = enc_reg2nbytes(reg); 175 176 enc_set_bank(enc, reg); 177 dout[0] = CMD_RCR(reg); 178 spi_xfer(enc->slave, nbytes * 8, dout, din, 179 SPI_XFER_BEGIN | SPI_XFER_END); 180 result = din[nbytes-1]; 181 dout[0]++; /* next register */ 182 spi_xfer(enc->slave, nbytes * 8, dout, din, 183 SPI_XFER_BEGIN | SPI_XFER_END); 184 result |= din[nbytes-1] << 8; 185 return result; 186 } 187 188 /* 189 * Write a byte register 190 */ 191 static void enc_w8(enc_dev_t *enc, const u16 reg, const u8 data) 192 { 193 u8 dout[2]; 194 195 enc_set_bank(enc, reg); 196 dout[0] = CMD_WCR(reg); 197 dout[1] = data; 198 spi_xfer(enc->slave, 2 * 8, dout, NULL, 199 SPI_XFER_BEGIN | SPI_XFER_END); 200 } 201 202 /* 203 * Write a L/H register pair. 204 * Must be called with the L register's address. 205 */ 206 static void enc_w16(enc_dev_t *enc, const u16 reg, const u16 data) 207 { 208 u8 dout[2]; 209 210 enc_set_bank(enc, reg); 211 dout[0] = CMD_WCR(reg); 212 dout[1] = data; 213 spi_xfer(enc->slave, 2 * 8, dout, NULL, 214 SPI_XFER_BEGIN | SPI_XFER_END); 215 dout[0]++; /* next register */ 216 dout[1] = data >> 8; 217 spi_xfer(enc->slave, 2 * 8, dout, NULL, 218 SPI_XFER_BEGIN | SPI_XFER_END); 219 } 220 221 /* 222 * Write a byte register, verify and retry 223 */ 224 static void enc_w8_retry(enc_dev_t *enc, const u16 reg, const u8 data, const int c) 225 { 226 u8 dout[2]; 227 u8 readback; 228 int i; 229 230 enc_set_bank(enc, reg); 231 for (i = 0; i < c; i++) { 232 dout[0] = CMD_WCR(reg); 233 dout[1] = data; 234 spi_xfer(enc->slave, 2 * 8, dout, NULL, 235 SPI_XFER_BEGIN | SPI_XFER_END); 236 readback = enc_r8(enc, reg); 237 if (readback == data) 238 break; 239 /* wait 1ms */ 240 udelay(1000); 241 } 242 if (i == c) { 243 printf("%s: write reg 0x%03x failed\n", enc->dev->name, reg); 244 } 245 } 246 247 /* 248 * Read ENC RAM into buffer 249 */ 250 static void enc_rbuf(enc_dev_t *enc, const u16 length, u8 *buf) 251 { 252 u8 dout[1]; 253 254 dout[0] = CMD_RBM; 255 spi_xfer(enc->slave, 8, dout, NULL, SPI_XFER_BEGIN); 256 spi_xfer(enc->slave, length * 8, NULL, buf, SPI_XFER_END); 257 #ifdef DEBUG 258 puts("Rx:\n"); 259 print_buffer(0, buf, 1, length, 0); 260 #endif 261 } 262 263 /* 264 * Write buffer into ENC RAM 265 */ 266 static void enc_wbuf(enc_dev_t *enc, const u16 length, const u8 *buf, const u8 control) 267 { 268 u8 dout[2]; 269 dout[0] = CMD_WBM; 270 dout[1] = control; 271 spi_xfer(enc->slave, 2 * 8, dout, NULL, SPI_XFER_BEGIN); 272 spi_xfer(enc->slave, length * 8, buf, NULL, SPI_XFER_END); 273 #ifdef DEBUG 274 puts("Tx:\n"); 275 print_buffer(0, buf, 1, length, 0); 276 #endif 277 } 278 279 /* 280 * Try to claim the SPI bus. 281 * Print error message on failure. 282 */ 283 static int enc_claim_bus(enc_dev_t *enc) 284 { 285 int rc = spi_claim_bus(enc->slave); 286 if (rc) 287 printf("%s: failed to claim SPI bus\n", enc->dev->name); 288 return rc; 289 } 290 291 /* 292 * Release previously claimed SPI bus. 293 * This function is mainly for symmetry to enc_claim_bus(). 294 * Let the toolchain decide to inline it... 295 */ 296 static void enc_release_bus(enc_dev_t *enc) 297 { 298 spi_release_bus(enc->slave); 299 } 300 301 /* 302 * Read PHY register 303 */ 304 static u16 enc_phy_read(enc_dev_t *enc, const u8 addr) 305 { 306 uint64_t etime; 307 u8 status; 308 309 enc_w8(enc, CTL_REG_MIREGADR, addr); 310 enc_w8(enc, CTL_REG_MICMD, ENC_MICMD_MIIRD); 311 /* 1 second timeout - only happens on hardware problem */ 312 etime = get_ticks() + get_tbclk(); 313 /* poll MISTAT.BUSY bit until operation is complete */ 314 do 315 { 316 status = enc_r8(enc, CTL_REG_MISTAT); 317 } while (get_ticks() <= etime && (status & ENC_MISTAT_BUSY)); 318 if (status & ENC_MISTAT_BUSY) { 319 printf("%s: timeout reading phy\n", enc->dev->name); 320 return 0; 321 } 322 enc_w8(enc, CTL_REG_MICMD, 0); 323 return enc_r16(enc, CTL_REG_MIRDL); 324 } 325 326 /* 327 * Write PHY register 328 */ 329 static void enc_phy_write(enc_dev_t *enc, const u8 addr, const u16 data) 330 { 331 uint64_t etime; 332 u8 status; 333 334 enc_w8(enc, CTL_REG_MIREGADR, addr); 335 enc_w16(enc, CTL_REG_MIWRL, data); 336 /* 1 second timeout - only happens on hardware problem */ 337 etime = get_ticks() + get_tbclk(); 338 /* poll MISTAT.BUSY bit until operation is complete */ 339 do 340 { 341 status = enc_r8(enc, CTL_REG_MISTAT); 342 } while (get_ticks() <= etime && (status & ENC_MISTAT_BUSY)); 343 if (status & ENC_MISTAT_BUSY) { 344 printf("%s: timeout writing phy\n", enc->dev->name); 345 return; 346 } 347 } 348 349 /* 350 * Verify link status, wait if necessary 351 * 352 * Note: with a 10 MBit/s only PHY there is no autonegotiation possible, 353 * half/full duplex is a pure setup matter. For the time being, this driver 354 * will setup in half duplex mode only. 355 */ 356 static int enc_phy_link_wait(enc_dev_t *enc) 357 { 358 u16 status; 359 int duplex; 360 uint64_t etime; 361 362 #ifdef CONFIG_ENC_SILENTLINK 363 /* check if we have a link, then just return */ 364 status = enc_phy_read(enc, PHY_REG_PHSTAT1); 365 if (status & ENC_PHSTAT1_LLSTAT) 366 return 0; 367 #endif 368 369 /* wait for link with 1 second timeout */ 370 etime = get_ticks() + get_tbclk(); 371 while (get_ticks() <= etime) { 372 status = enc_phy_read(enc, PHY_REG_PHSTAT1); 373 if (status & ENC_PHSTAT1_LLSTAT) { 374 /* now we have a link */ 375 status = enc_phy_read(enc, PHY_REG_PHSTAT2); 376 duplex = (status & ENC_PHSTAT2_DPXSTAT) ? 1 : 0; 377 printf("%s: link up, 10Mbps %s-duplex\n", 378 enc->dev->name, duplex ? "full" : "half"); 379 return 0; 380 } 381 udelay(1000); 382 } 383 384 /* timeout occurred */ 385 printf("%s: link down\n", enc->dev->name); 386 return 1; 387 } 388 389 /* 390 * This function resets the receiver only. 391 */ 392 static void enc_reset_rx(enc_dev_t *enc) 393 { 394 u8 econ1; 395 396 econ1 = enc_r8(enc, CTL_REG_ECON1); 397 if ((econ1 & ENC_ECON1_RXRST) == 0) { 398 enc_bset(enc, CTL_REG_ECON1, ENC_ECON1_RXRST); 399 enc->rx_reset_counter = RX_RESET_COUNTER; 400 } 401 } 402 403 /* 404 * Reset receiver and reenable it. 405 */ 406 static void enc_reset_rx_call(enc_dev_t *enc) 407 { 408 enc_bclr(enc, CTL_REG_ECON1, ENC_ECON1_RXRST); 409 enc_bset(enc, CTL_REG_ECON1, ENC_ECON1_RXEN); 410 } 411 412 /* 413 * Copy a packet from the receive ring and forward it to 414 * the protocol stack. 415 */ 416 static void enc_receive(enc_dev_t *enc) 417 { 418 u8 *packet = (u8 *)net_rx_packets[0]; 419 u16 pkt_len; 420 u16 copy_len; 421 u16 status; 422 u8 pkt_cnt = 0; 423 u16 rxbuf_rdpt; 424 u8 hbuf[6]; 425 426 enc_w16(enc, CTL_REG_ERDPTL, enc->next_pointer); 427 do { 428 enc_rbuf(enc, 6, hbuf); 429 enc->next_pointer = hbuf[0] | (hbuf[1] << 8); 430 pkt_len = hbuf[2] | (hbuf[3] << 8); 431 status = hbuf[4] | (hbuf[5] << 8); 432 debug("next_pointer=$%04x pkt_len=%u status=$%04x\n", 433 enc->next_pointer, pkt_len, status); 434 if (pkt_len <= ENC_MAX_FRM_LEN) 435 copy_len = pkt_len; 436 else 437 copy_len = 0; 438 if ((status & (1L << 7)) == 0) /* check Received Ok bit */ 439 copy_len = 0; 440 /* check if next pointer is resonable */ 441 if (enc->next_pointer >= ENC_TX_BUF_START) 442 copy_len = 0; 443 if (copy_len > 0) { 444 enc_rbuf(enc, copy_len, packet); 445 } 446 /* advance read pointer to next pointer */ 447 enc_w16(enc, CTL_REG_ERDPTL, enc->next_pointer); 448 /* decrease packet counter */ 449 enc_bset(enc, CTL_REG_ECON2, ENC_ECON2_PKTDEC); 450 /* 451 * Only odd values should be written to ERXRDPTL, 452 * see errata B4 pt.13 453 */ 454 rxbuf_rdpt = enc->next_pointer - 1; 455 if ((rxbuf_rdpt < enc_r16(enc, CTL_REG_ERXSTL)) || 456 (rxbuf_rdpt > enc_r16(enc, CTL_REG_ERXNDL))) { 457 enc_w16(enc, CTL_REG_ERXRDPTL, 458 enc_r16(enc, CTL_REG_ERXNDL)); 459 } else { 460 enc_w16(enc, CTL_REG_ERXRDPTL, rxbuf_rdpt); 461 } 462 /* read pktcnt */ 463 pkt_cnt = enc_r8(enc, CTL_REG_EPKTCNT); 464 if (copy_len == 0) { 465 (void)enc_r8(enc, CTL_REG_EIR); 466 enc_reset_rx(enc); 467 printf("%s: receive copy_len=0\n", enc->dev->name); 468 continue; 469 } 470 /* 471 * Because net_process_received_packet() might call enc_send(), 472 * we need to release the SPI bus, call 473 * net_process_received_packet(), reclaim the bus. 474 */ 475 enc_release_bus(enc); 476 net_process_received_packet(packet, pkt_len); 477 if (enc_claim_bus(enc)) 478 return; 479 (void)enc_r8(enc, CTL_REG_EIR); 480 } while (pkt_cnt); 481 /* Use EPKTCNT not EIR.PKTIF flag, see errata pt. 6 */ 482 } 483 484 /* 485 * Poll for completely received packets. 486 */ 487 static void enc_poll(enc_dev_t *enc) 488 { 489 u8 eir_reg; 490 u8 pkt_cnt; 491 492 #ifdef CONFIG_USE_IRQ 493 /* clear global interrupt enable bit in enc28j60 */ 494 enc_bclr(enc, CTL_REG_EIE, ENC_EIE_INTIE); 495 #endif 496 (void)enc_r8(enc, CTL_REG_ESTAT); 497 eir_reg = enc_r8(enc, CTL_REG_EIR); 498 if (eir_reg & ENC_EIR_TXIF) { 499 /* clear TXIF bit in EIR */ 500 enc_bclr(enc, CTL_REG_EIR, ENC_EIR_TXIF); 501 } 502 /* We have to use pktcnt and not pktif bit, see errata pt. 6 */ 503 pkt_cnt = enc_r8(enc, CTL_REG_EPKTCNT); 504 if (pkt_cnt > 0) { 505 if ((eir_reg & ENC_EIR_PKTIF) == 0) { 506 debug("enc_poll: pkt cnt > 0, but pktif not set\n"); 507 } 508 enc_receive(enc); 509 /* 510 * clear PKTIF bit in EIR, this should not need to be done 511 * but it seems like we get problems if we do not 512 */ 513 enc_bclr(enc, CTL_REG_EIR, ENC_EIR_PKTIF); 514 } 515 if (eir_reg & ENC_EIR_RXERIF) { 516 printf("%s: rx error\n", enc->dev->name); 517 enc_bclr(enc, CTL_REG_EIR, ENC_EIR_RXERIF); 518 } 519 if (eir_reg & ENC_EIR_TXERIF) { 520 printf("%s: tx error\n", enc->dev->name); 521 enc_bclr(enc, CTL_REG_EIR, ENC_EIR_TXERIF); 522 } 523 #ifdef CONFIG_USE_IRQ 524 /* set global interrupt enable bit in enc28j60 */ 525 enc_bset(enc, CTL_REG_EIE, ENC_EIE_INTIE); 526 #endif 527 } 528 529 /* 530 * Completely Reset the ENC 531 */ 532 static void enc_reset(enc_dev_t *enc) 533 { 534 u8 dout[1]; 535 536 dout[0] = CMD_SRC; 537 spi_xfer(enc->slave, 8, dout, NULL, 538 SPI_XFER_BEGIN | SPI_XFER_END); 539 /* sleep 1 ms. See errata pt. 2 */ 540 udelay(1000); 541 } 542 543 /* 544 * Initialisation data for most of the ENC registers 545 */ 546 static const u16 enc_initdata[] = { 547 /* 548 * Setup the buffer space. The reset values are valid for the 549 * other pointers. 550 * 551 * We shall not write to ERXST, see errata pt. 5. Instead we 552 * have to make sure that ENC_RX_BUS_START is 0. 553 */ 554 CTL_REG_ERXSTL, ENC_RX_BUF_START, 555 CTL_REG_ERXSTH, ENC_RX_BUF_START >> 8, 556 CTL_REG_ERXNDL, ENC_RX_BUF_END, 557 CTL_REG_ERXNDH, ENC_RX_BUF_END >> 8, 558 CTL_REG_ERDPTL, ENC_RX_BUF_START, 559 CTL_REG_ERDPTH, ENC_RX_BUF_START >> 8, 560 /* 561 * Set the filter to receive only good-CRC, unicast and broadcast 562 * frames. 563 * Note: some DHCP servers return their answers as broadcasts! 564 * So its unwise to remove broadcast from this. This driver 565 * might incur receiver overruns with packet loss on a broadcast 566 * flooded network. 567 */ 568 CTL_REG_ERXFCON, ENC_RFR_BCEN | ENC_RFR_UCEN | ENC_RFR_CRCEN, 569 570 /* enable MAC to receive frames */ 571 CTL_REG_MACON1, 572 ENC_MACON1_MARXEN | ENC_MACON1_TXPAUS | ENC_MACON1_RXPAUS, 573 574 /* configure pad, tx-crc and duplex */ 575 CTL_REG_MACON3, 576 ENC_MACON3_PADCFG0 | ENC_MACON3_TXCRCEN | 577 ENC_MACON3_FRMLNEN, 578 579 /* Allow infinite deferals if the medium is continously busy */ 580 CTL_REG_MACON4, ENC_MACON4_DEFER, 581 582 /* Late collisions occur beyond 63 bytes */ 583 CTL_REG_MACLCON2, 63, 584 585 /* 586 * Set (low byte) Non-Back-to_Back Inter-Packet Gap. 587 * Recommended 0x12 588 */ 589 CTL_REG_MAIPGL, 0x12, 590 591 /* 592 * Set (high byte) Non-Back-to_Back Inter-Packet Gap. 593 * Recommended 0x0c for half-duplex. Nothing for full-duplex 594 */ 595 CTL_REG_MAIPGH, 0x0C, 596 597 /* set maximum frame length */ 598 CTL_REG_MAMXFLL, ENC_MAX_FRM_LEN, 599 CTL_REG_MAMXFLH, ENC_MAX_FRM_LEN >> 8, 600 601 /* 602 * Set MAC back-to-back inter-packet gap. 603 * Recommended 0x12 for half duplex 604 * and 0x15 for full duplex. 605 */ 606 CTL_REG_MABBIPG, 0x12, 607 608 /* end of table */ 609 0xffff 610 }; 611 612 /* 613 * Wait for the XTAL oscillator to become ready 614 */ 615 static int enc_clock_wait(enc_dev_t *enc) 616 { 617 uint64_t etime; 618 619 /* one second timeout */ 620 etime = get_ticks() + get_tbclk(); 621 622 /* 623 * Wait for CLKRDY to become set (i.e., check that we can 624 * communicate with the ENC) 625 */ 626 do 627 { 628 if (enc_r8(enc, CTL_REG_ESTAT) & ENC_ESTAT_CLKRDY) 629 return 0; 630 } while (get_ticks() <= etime); 631 632 printf("%s: timeout waiting for CLKRDY\n", enc->dev->name); 633 return -1; 634 } 635 636 /* 637 * Write the MAC address into the ENC 638 */ 639 static int enc_write_macaddr(enc_dev_t *enc) 640 { 641 unsigned char *p = enc->dev->enetaddr; 642 643 enc_w8_retry(enc, CTL_REG_MAADR5, *p++, 5); 644 enc_w8_retry(enc, CTL_REG_MAADR4, *p++, 5); 645 enc_w8_retry(enc, CTL_REG_MAADR3, *p++, 5); 646 enc_w8_retry(enc, CTL_REG_MAADR2, *p++, 5); 647 enc_w8_retry(enc, CTL_REG_MAADR1, *p++, 5); 648 enc_w8_retry(enc, CTL_REG_MAADR0, *p, 5); 649 return 0; 650 } 651 652 /* 653 * Setup most of the ENC registers 654 */ 655 static int enc_setup(enc_dev_t *enc) 656 { 657 u16 phid1 = 0; 658 u16 phid2 = 0; 659 const u16 *tp; 660 661 /* reset enc struct values */ 662 enc->next_pointer = ENC_RX_BUF_START; 663 enc->rx_reset_counter = RX_RESET_COUNTER; 664 enc->bank = 0xff; /* invalidate current bank in enc28j60 */ 665 666 /* verify PHY identification */ 667 phid1 = enc_phy_read(enc, PHY_REG_PHID1); 668 phid2 = enc_phy_read(enc, PHY_REG_PHID2) & ENC_PHID2_MASK; 669 if (phid1 != ENC_PHID1_VALUE || phid2 != ENC_PHID2_VALUE) { 670 printf("%s: failed to identify PHY. Found %04x:%04x\n", 671 enc->dev->name, phid1, phid2); 672 return -1; 673 } 674 675 /* now program registers */ 676 for (tp = enc_initdata; *tp != 0xffff; tp += 2) 677 enc_w8_retry(enc, tp[0], tp[1], 10); 678 679 /* 680 * Prevent automatic loopback of data beeing transmitted by setting 681 * ENC_PHCON2_HDLDIS 682 */ 683 enc_phy_write(enc, PHY_REG_PHCON2, (1<<8)); 684 685 /* 686 * LEDs configuration 687 * LEDA: LACFG = 0100 -> display link status 688 * LEDB: LBCFG = 0111 -> display TX & RX activity 689 * STRCH = 1 -> LED pulses 690 */ 691 enc_phy_write(enc, PHY_REG_PHLCON, 0x0472); 692 693 /* Reset PDPXMD-bit => half duplex */ 694 enc_phy_write(enc, PHY_REG_PHCON1, 0); 695 696 #ifdef CONFIG_USE_IRQ 697 /* enable interrupts */ 698 enc_bset(enc, CTL_REG_EIE, ENC_EIE_PKTIE); 699 enc_bset(enc, CTL_REG_EIE, ENC_EIE_TXIE); 700 enc_bset(enc, CTL_REG_EIE, ENC_EIE_RXERIE); 701 enc_bset(enc, CTL_REG_EIE, ENC_EIE_TXERIE); 702 enc_bset(enc, CTL_REG_EIE, ENC_EIE_INTIE); 703 #endif 704 705 return 0; 706 } 707 708 /* 709 * Check if ENC has been initialized. 710 * If not, try to initialize it. 711 * Remember initialized state in struct. 712 */ 713 static int enc_initcheck(enc_dev_t *enc, const enum enc_initstate requiredstate) 714 { 715 if (enc->initstate >= requiredstate) 716 return 0; 717 718 if (enc->initstate < setupdone) { 719 /* Initialize the ENC only */ 720 enc_reset(enc); 721 /* if any of functions fails, skip the rest and return an error */ 722 if (enc_clock_wait(enc) || enc_setup(enc) || enc_write_macaddr(enc)) { 723 return -1; 724 } 725 enc->initstate = setupdone; 726 } 727 /* if that's all we need, return here */ 728 if (enc->initstate >= requiredstate) 729 return 0; 730 731 /* now wait for link ready condition */ 732 if (enc_phy_link_wait(enc)) { 733 return -1; 734 } 735 enc->initstate = linkready; 736 return 0; 737 } 738 739 #if defined(CONFIG_CMD_MII) 740 /* 741 * Read a PHY register. 742 * 743 * This function is registered with miiphy_register(). 744 */ 745 int enc_miiphy_read(struct mii_dev *bus, int phy_adr, int devad, int reg) 746 { 747 u16 value = 0; 748 struct eth_device *dev = eth_get_dev_by_name(bus->name); 749 enc_dev_t *enc; 750 751 if (!dev || phy_adr != 0) 752 return -1; 753 754 enc = dev->priv; 755 if (enc_claim_bus(enc)) 756 return -1; 757 if (enc_initcheck(enc, setupdone)) { 758 enc_release_bus(enc); 759 return -1; 760 } 761 value = enc_phy_read(enc, reg); 762 enc_release_bus(enc); 763 return value; 764 } 765 766 /* 767 * Write a PHY register. 768 * 769 * This function is registered with miiphy_register(). 770 */ 771 int enc_miiphy_write(struct mii_dev *bus, int phy_adr, int devad, int reg, 772 u16 value) 773 { 774 struct eth_device *dev = eth_get_dev_by_name(bus->name); 775 enc_dev_t *enc; 776 777 if (!dev || phy_adr != 0) 778 return -1; 779 780 enc = dev->priv; 781 if (enc_claim_bus(enc)) 782 return -1; 783 if (enc_initcheck(enc, setupdone)) { 784 enc_release_bus(enc); 785 return -1; 786 } 787 enc_phy_write(enc, reg, value); 788 enc_release_bus(enc); 789 return 0; 790 } 791 #endif 792 793 /* 794 * Write hardware (MAC) address. 795 * 796 * This function entered into eth_device structure. 797 */ 798 static int enc_write_hwaddr(struct eth_device *dev) 799 { 800 enc_dev_t *enc = dev->priv; 801 802 if (enc_claim_bus(enc)) 803 return -1; 804 if (enc_initcheck(enc, setupdone)) { 805 enc_release_bus(enc); 806 return -1; 807 } 808 enc_release_bus(enc); 809 return 0; 810 } 811 812 /* 813 * Initialize ENC28J60 for use. 814 * 815 * This function entered into eth_device structure. 816 */ 817 static int enc_init(struct eth_device *dev, bd_t *bis) 818 { 819 enc_dev_t *enc = dev->priv; 820 821 if (enc_claim_bus(enc)) 822 return -1; 823 if (enc_initcheck(enc, linkready)) { 824 enc_release_bus(enc); 825 return -1; 826 } 827 /* enable receive */ 828 enc_bset(enc, CTL_REG_ECON1, ENC_ECON1_RXEN); 829 enc_release_bus(enc); 830 return 0; 831 } 832 833 /* 834 * Check for received packets. 835 * 836 * This function entered into eth_device structure. 837 */ 838 static int enc_recv(struct eth_device *dev) 839 { 840 enc_dev_t *enc = dev->priv; 841 842 if (enc_claim_bus(enc)) 843 return -1; 844 if (enc_initcheck(enc, linkready)) { 845 enc_release_bus(enc); 846 return -1; 847 } 848 /* Check for dead receiver */ 849 if (enc->rx_reset_counter > 0) 850 enc->rx_reset_counter--; 851 else 852 enc_reset_rx_call(enc); 853 enc_poll(enc); 854 enc_release_bus(enc); 855 return 0; 856 } 857 858 /* 859 * Send a packet. 860 * 861 * This function entered into eth_device structure. 862 * 863 * Should we wait here until we have a Link? Or shall we leave that to 864 * protocol retries? 865 */ 866 static int enc_send( 867 struct eth_device *dev, 868 void *packet, 869 int length) 870 { 871 enc_dev_t *enc = dev->priv; 872 873 if (enc_claim_bus(enc)) 874 return -1; 875 if (enc_initcheck(enc, linkready)) { 876 enc_release_bus(enc); 877 return -1; 878 } 879 /* setup transmit pointers */ 880 enc_w16(enc, CTL_REG_EWRPTL, ENC_TX_BUF_START); 881 enc_w16(enc, CTL_REG_ETXNDL, length + ENC_TX_BUF_START); 882 enc_w16(enc, CTL_REG_ETXSTL, ENC_TX_BUF_START); 883 /* write packet to ENC */ 884 enc_wbuf(enc, length, (u8 *) packet, 0x00); 885 /* 886 * Check that the internal transmit logic has not been altered 887 * by excessive collisions. Reset transmitter if so. 888 * See Errata B4 12 and 14. 889 */ 890 if (enc_r8(enc, CTL_REG_EIR) & ENC_EIR_TXERIF) { 891 enc_bset(enc, CTL_REG_ECON1, ENC_ECON1_TXRST); 892 enc_bclr(enc, CTL_REG_ECON1, ENC_ECON1_TXRST); 893 } 894 enc_bclr(enc, CTL_REG_EIR, (ENC_EIR_TXERIF | ENC_EIR_TXIF)); 895 /* start transmitting */ 896 enc_bset(enc, CTL_REG_ECON1, ENC_ECON1_TXRTS); 897 enc_release_bus(enc); 898 return 0; 899 } 900 901 /* 902 * Finish use of ENC. 903 * 904 * This function entered into eth_device structure. 905 */ 906 static void enc_halt(struct eth_device *dev) 907 { 908 enc_dev_t *enc = dev->priv; 909 910 if (enc_claim_bus(enc)) 911 return; 912 /* Just disable receiver */ 913 enc_bclr(enc, CTL_REG_ECON1, ENC_ECON1_RXEN); 914 enc_release_bus(enc); 915 } 916 917 /* 918 * This is the only exported function. 919 * 920 * It may be called several times with different bus:cs combinations. 921 */ 922 int enc28j60_initialize(unsigned int bus, unsigned int cs, 923 unsigned int max_hz, unsigned int mode) 924 { 925 struct eth_device *dev; 926 enc_dev_t *enc; 927 928 /* try to allocate, check and clear eth_device object */ 929 dev = malloc(sizeof(*dev)); 930 if (!dev) { 931 return -1; 932 } 933 memset(dev, 0, sizeof(*dev)); 934 935 /* try to allocate, check and clear enc_dev_t object */ 936 enc = malloc(sizeof(*enc)); 937 if (!enc) { 938 free(dev); 939 return -1; 940 } 941 memset(enc, 0, sizeof(*enc)); 942 943 /* try to setup the SPI slave */ 944 enc->slave = spi_setup_slave(bus, cs, max_hz, mode); 945 if (!enc->slave) { 946 printf("enc28j60: invalid SPI device %i:%i\n", bus, cs); 947 free(enc); 948 free(dev); 949 return -1; 950 } 951 952 enc->dev = dev; 953 /* now fill the eth_device object */ 954 dev->priv = enc; 955 dev->init = enc_init; 956 dev->halt = enc_halt; 957 dev->send = enc_send; 958 dev->recv = enc_recv; 959 dev->write_hwaddr = enc_write_hwaddr; 960 sprintf(dev->name, "enc%i.%i", bus, cs); 961 eth_register(dev); 962 #if defined(CONFIG_CMD_MII) 963 int retval; 964 struct mii_dev *mdiodev = mdio_alloc(); 965 if (!mdiodev) 966 return -ENOMEM; 967 strncpy(mdiodev->name, dev->name, MDIO_NAME_LEN); 968 mdiodev->read = enc_miiphy_read; 969 mdiodev->write = enc_miiphy_write; 970 971 retval = mdio_register(mdiodev); 972 if (retval < 0) 973 return retval; 974 #endif 975 return 0; 976 } 977