sys/boot/arm/at91/libat91/emac.c

   1 /*******************************************************************************
   2  *
   3  * Filename: emac.c
   4  *
   5  * Instantiation of routines for MAC/ethernet functions supporting tftp.
   6  *
   7  * Revision information:
   8  *
   9  * 28AUG2004    kb_admin        initial creation
  10  * 08JAN2005    kb_admin        added tftp download
  11  *                                      also adapted from external sources
  12  *
  13  * BEGIN_KBDD_BLOCK
  14  * No warranty, expressed or implied, is included with this software.  It is
  15  * provided "AS IS" and no warranty of any kind including statutory or aspects
  16  * relating to merchantability or fitness for any purpose is provided.  All
  17  * intellectual property rights of others is maintained with the respective
  18  * owners.  This software is not copyrighted and is intended for reference
  19  * only.
  20  * END_BLOCK
  21  *
  22  * $FreeBSD$
  23  ******************************************************************************/
  24
  25 #include "at91rm9200.h"
  26 #include "at91rm9200_lowlevel.h"
  27 #include "emac.h"
  28 #include "lib.h"
  29
  30 /* ****************************** GLOBALS *************************************/
  31
  32 /* ********************** PRIVATE FUNCTIONS/DATA ******************************/
  33
  34 static receive_descriptor_t *p_rxBD;
  35 static unsigned short localPort;
  36 static unsigned short serverPort;
  37 static unsigned serverMACSet;
  38 static unsigned localIPSet, serverIPSet;
  39 static unsigned lastSize;
  40 static unsigned char serverMACAddr[6];
  41 static unsigned char localIPAddr[4], serverIPAddr[4];
  42 static int      ackBlock;
  43 static char *dlAddress;
  44
  45 static unsigned transmitBuffer[1024 / sizeof(unsigned)];
  46 static unsigned tftpSendPacket[256 / sizeof(unsigned)];
  47
  48 /*
  49  * .KB_C_FN_DEFINITION_START
  50  * unsigned short IP_checksum(unsigned short *p, int len)
  51  *  This private function calculates the IP checksum for various headers.
  52  * .KB_C_FN_DEFINITION_END
  53  */
  54 static unsigned short
  55 IP_checksum(unsigned short *p, int len)
  56 {
  57         unsigned        i, t;
  58
  59         len &= ~1;
  60
  61         for (i=0,t=0; i<len; i+=2, ++p)
  62                 t += SWAP16(*p);
  63
  64         t = (t & 0xffff) + (t >> 16);
  65         return (~t);
  66 }
  67
  68
  69 /*
  70  * .KB_C_FN_DEFINITION_START
  71  * void GetServerAddress(void)
  72  *  This private function sends an ARP request to determine the server MAC.
  73  * .KB_C_FN_DEFINITION_END
  74  */
  75 static void
  76 GetServerAddress(void)
  77 {
  78         arp_header_t    *p_ARP;
  79
  80         p_ARP = (arp_header_t*)transmitBuffer;
  81
  82         p_memset((char*)p_ARP->dest_mac, 0xFF, 6);
  83
  84         memcpy(p_ARP->src_mac, localMACAddr, 6);
  85
  86         p_ARP->frame_type = SWAP16(PROTOCOL_ARP);
  87         p_ARP->hard_type  = SWAP16(1);
  88         p_ARP->prot_type  = SWAP16(PROTOCOL_IP);
  89         p_ARP->hard_size  = 6;
  90         p_ARP->prot_size  = 4;
  91         p_ARP->operation  = SWAP16(ARP_REQUEST);
  92
  93         memcpy(p_ARP->sender_mac, localMACAddr, 6);
  94         memcpy(p_ARP->sender_ip, localIPAddr, 4);
  95         p_memset((char*)p_ARP->target_mac, 0, 6);
  96         memcpy(p_ARP->target_ip, serverIPAddr, 4);
  97
  98         // wait until transmit is available
  99         while (!(*AT91C_EMAC_TSR & AT91C_EMAC_BNQ)) ;
 100
 101         *AT91C_EMAC_TSR |= AT91C_EMAC_COMP;
 102         *AT91C_EMAC_TAR = (unsigned)transmitBuffer;
 103         *AT91C_EMAC_TCR = 0x40;
 104 }
 105
 106
 107 /*
 108  * .KB_C_FN_DEFINITION_START
 109  * void Send_TFTP_Packet(char *tftpData, unsigned tftpLength)
 110  *  This private function initializes and send a TFTP packet.
 111  * .KB_C_FN_DEFINITION_END
 112  */
 113 static void
 114 Send_TFTP_Packet(char *tftpData, unsigned tftpLength)
 115 {
 116         transmit_header_t       *macHdr = (transmit_header_t*)tftpSendPacket;
 117         ip_header_t             *ipHdr;
 118         udp_header_t            *udpHdr;
 119         unsigned                t_checksum;
 120
 121         memcpy(macHdr->dest_mac, serverMACAddr, 6);
 122         memcpy(macHdr->src_mac, localMACAddr, 6);
 123         macHdr->proto_mac = SWAP16(PROTOCOL_IP);
 124
 125         ipHdr = (ip_header_t*)&macHdr->packet_length;
 126
 127         ipHdr->ip_v_hl = 0x45;
 128         ipHdr->ip_tos = 0;
 129         ipHdr->ip_len = SWAP16(28 + tftpLength);
 130         ipHdr->ip_id = 0;
 131         ipHdr->ip_off = SWAP16(0x4000);
 132         ipHdr->ip_ttl = 64;
 133         ipHdr->ip_p = PROTOCOL_UDP;
 134         ipHdr->ip_sum = 0;
 135
 136         memcpy(ipHdr->ip_src, localIPAddr, 4);
 137         memcpy(ipHdr->ip_dst, serverIPAddr, 4);
 138
 139         ipHdr->ip_sum = SWAP16(IP_checksum((unsigned short*)ipHdr, 20));
 140
 141         udpHdr = (udp_header_t*)(ipHdr + 1);
 142
 143         udpHdr->src_port  = localPort;
 144         udpHdr->dst_port  = serverPort;
 145         udpHdr->udp_len   = SWAP16(8 + tftpLength);
 146         udpHdr->udp_cksum = 0;
 147
 148         memcpy((char *)udpHdr+8, tftpData, tftpLength);
 149
 150         t_checksum = IP_checksum((unsigned short*)ipHdr + 6, (16 + tftpLength));
 151
 152         t_checksum = (~t_checksum) & 0xFFFF;
 153         t_checksum += 25 + tftpLength;
 154
 155         t_checksum = (t_checksum & 0xffff) + (t_checksum >> 16);
 156         t_checksum = (~t_checksum) & 0xFFFF;
 157
 158         udpHdr->udp_cksum = SWAP16(t_checksum);
 159
 160         while (!(*AT91C_EMAC_TSR & AT91C_EMAC_BNQ)) ;
 161
 162         *AT91C_EMAC_TSR |= AT91C_EMAC_COMP;
 163         *AT91C_EMAC_TAR = (unsigned)tftpSendPacket;
 164         *AT91C_EMAC_TCR = 42 + tftpLength;
 165 }
 166
 167
 168 /*
 169  * .KB_C_FN_DEFINITION_START
 170  * void TFTP_RequestFile(char *filename)
 171  *  This private function sends a RRQ packet to the server.
 172  * .KB_C_FN_DEFINITION_END
 173  */
 174 static void
 175 TFTP_RequestFile(char *filename)
 176 {
 177         tftp_header_t   tftpHeader;
 178         char            *cPtr, *ePtr, *mPtr;
 179         unsigned        length;
 180
 181         tftpHeader.opcode = TFTP_RRQ_OPCODE;
 182
 183         cPtr = (char*)&(tftpHeader.block_num);
 184
 185         ePtr = strcpy(cPtr, filename);
 186         mPtr = strcpy(ePtr, "octet");
 187
 188         length = mPtr - cPtr;
 189         length += 2;
 190
 191         Send_TFTP_Packet((char*)&tftpHeader, length);
 192 }
 193
 194
 195 /*
 196  * .KB_C_FN_DEFINITION_START
 197  * void TFTP_ACK_Data(char *data, unsigned short block_num, unsigned short len)
 198  *  This private function sends an ACK packet to the server.
 199  * .KB_C_FN_DEFINITION_END
 200  */
 201 static void
 202 TFTP_ACK_Data(unsigned char *data, unsigned short block_num, unsigned short len)
 203 {
 204         tftp_header_t   tftpHeader;
 205
 206         if (block_num == (ackBlock + 1)) {
 207                 ++ackBlock;
 208                 memcpy(dlAddress, data, len);
 209                 dlAddress += len;
 210                 lastSize += len;
 211                 if (ackBlock % 128 == 0)
 212                         printf("tftp: %u kB\r", lastSize / 1024);
 213         }
 214         tftpHeader.opcode = TFTP_ACK_OPCODE;
 215         tftpHeader.block_num = SWAP16(ackBlock);
 216         Send_TFTP_Packet((char*)&tftpHeader, 4);
 217         if (len < 512) {
 218                 ackBlock = -2;
 219                 printf("tftp: %u byte\n", lastSize);
 220         }
 221 }
 222
 223
 224 /*
 225  * .KB_C_FN_DEFINITION_START
 226  * void CheckForNewPacket(ip_header_t *pHeader)
 227  *  This private function polls for received ethernet packets and handles
 228  * any here.
 229  * .KB_C_FN_DEFINITION_END
 230  */
 231 static int
 232 CheckForNewPacket(ip_header_t *pHeader)
 233 {
 234         unsigned short  *pFrameType;
 235         unsigned        i;
 236         char            *pData;
 237         ip_header_t     *pIpHeader;
 238         arp_header_t    *p_ARP;
 239         int             process = 0;
 240
 241         process = 0;
 242         for (i = 0; i < MAX_RX_PACKETS; ++i) {
 243                 if(p_rxBD[i].address & 0x1) {
 244                         process = 1;
 245                         (*AT91C_EMAC_RSR) |= (*AT91C_EMAC_RSR);
 246                         break;
 247                 }
 248         }
 249
 250         if (!process)
 251                 return (0);
 252         process = i;
 253
 254         pFrameType = (unsigned short *)((p_rxBD[i].address & 0xFFFFFFFC) + 12);
 255         pData      = (char *)(p_rxBD[i].address & 0xFFFFFFFC);
 256
 257         switch (*pFrameType) {
 258
 259         case SWAP16(PROTOCOL_ARP):
 260                 p_ARP = (arp_header_t*)pData;
 261                 if (p_ARP->operation == SWAP16(ARP_REPLY)) {
 262                         // check if new server info is available
 263                         if ((!serverMACSet) &&
 264                                 (!(p_memcmp((char*)p_ARP->sender_ip,
 265                                         (char*)serverIPAddr, 4)))) {
 266
 267                                 serverMACSet = 1;
 268                                 memcpy(serverMACAddr, p_ARP->sender_mac, 6);
 269                         }
 270                 } else if (p_ARP->operation == SWAP16(ARP_REQUEST)) {
 271                         // ARP REPLY operation
 272                         p_ARP->operation =  SWAP16(ARP_REPLY);
 273
 274                         // Fill the dest address and src address
 275                         for (i = 0; i <6; i++) {
 276                                 // swap ethernet dest address and ethernet src address
 277                                 pData[i] = pData[i+6];
 278                                 pData[i+6] = localMACAddr[i];
 279                                 // swap sender ethernet address and target ethernet address
 280                                 pData[i+22] = localMACAddr[i];
 281                                 pData[i+32] = pData[i+6];
 282                         }
 283
 284                         // swap sender IP address and target IP address
 285                         for (i = 0; i<4; i++) {
 286                                 pData[i+38] = pData[i+28];
 287                                 pData[i+28] = localIPAddr[i];
 288                         }
 289
 290                         if (!(*AT91C_EMAC_TSR & AT91C_EMAC_BNQ)) break;
 291
 292                         *AT91C_EMAC_TSR |= AT91C_EMAC_COMP;
 293                         *AT91C_EMAC_TAR = (unsigned)pData;
 294                         *AT91C_EMAC_TCR = 0x40;
 295                 }
 296                 break;
 297         case SWAP16(PROTOCOL_IP):
 298                 pIpHeader = (ip_header_t*)(pData + 14);
 299                 memcpy(pHeader, pIpHeader, sizeof(ip_header_t));
 300
 301                 if (pIpHeader->ip_p == PROTOCOL_UDP) {
 302                         udp_header_t    *udpHdr;
 303                         tftp_header_t   *tftpHdr;
 304
 305                         udpHdr = (udp_header_t*)((char*)pIpHeader+20);
 306                         tftpHdr = (tftp_header_t*)((char*)udpHdr + 8);
 307
 308                         if (udpHdr->dst_port != localPort)
 309                                 break;
 310
 311                         if (tftpHdr->opcode != TFTP_DATA_OPCODE)
 312                                 break;
 313
 314                         if (ackBlock == -1) {
 315                                 if (tftpHdr->block_num != SWAP16(1))
 316                                         break;
 317                                 serverPort = udpHdr->src_port;
 318                                 ackBlock = 0;
 319                         }
 320
 321                         if (serverPort != udpHdr->src_port)
 322                                 break;
 323
 324                         TFTP_ACK_Data(tftpHdr->data,
 325                             SWAP16(tftpHdr->block_num),
 326                             SWAP16(udpHdr->udp_len) - 12);
 327                 }
 328         }
 329         p_rxBD[process].address &= ~0x01;
 330         return (1);
 331 }
 332
 333
 334 /*
 335  * .KB_C_FN_DEFINITION_START
 336  * unsigned short AT91F_MII_ReadPhy (AT91PS_EMAC pEmac, unsigned char addr)
 337  *  This private function reads the PHY device.
 338  * .KB_C_FN_DEFINITION_END
 339  */
 340 #ifndef BOOT_BWCT
 341 static unsigned short
 342 AT91F_MII_ReadPhy (AT91PS_EMAC pEmac, unsigned char addr)
 343 {
 344         unsigned value = 0x60020000 | (addr << 18);
 345
 346         pEmac->EMAC_CTL |= AT91C_EMAC_MPE;
 347         pEmac->EMAC_MAN = value;
 348         while(!((pEmac->EMAC_SR) & AT91C_EMAC_IDLE));
 349         pEmac->EMAC_CTL &= ~AT91C_EMAC_MPE;
 350         return (pEmac->EMAC_MAN & 0x0000ffff);
 351 }
 352 #endif
 353
 354 /*
 355  * .KB_C_FN_DEFINITION_START
 356  * unsigned short AT91F_MII_WritePhy (AT91PS_EMAC pEmac, unsigned char addr, unsigned short s)
 357  *  This private function writes the PHY device.
 358  * .KB_C_FN_DEFINITION_END
 359  */
 360 #ifdef BOOT_TSC
 361 static unsigned short
 362 AT91F_MII_WritePhy (AT91PS_EMAC pEmac, unsigned char addr, unsigned short s)
 363 {
 364         unsigned value = 0x50020000 | (addr << 18) | s;
 365
 366         pEmac->EMAC_CTL |= AT91C_EMAC_MPE;
 367         pEmac->EMAC_MAN = value;
 368         while(!((pEmac->EMAC_SR) & AT91C_EMAC_IDLE));
 369         pEmac->EMAC_CTL &= ~AT91C_EMAC_MPE;
 370         return (pEmac->EMAC_MAN & 0x0000ffff);
 371 }
 372 #endif
 373
 374 /*
 375  * .KB_C_FN_DEFINITION_START
 376  * void MII_GetLinkSpeed(AT91PS_EMAC pEmac)
 377  *  This private function determines the link speed set by the PHY.
 378  * .KB_C_FN_DEFINITION_END
 379  */
 380 static void
 381 MII_GetLinkSpeed(AT91PS_EMAC pEmac)
 382 {
 383 #if defined(BOOT_TSC) || defined(BOOT_KB920X) || defined(BOOT_CENTIPAD)
 384         unsigned short stat2;
 385 #endif
 386         unsigned update;
 387 #ifdef BOOT_TSC
 388         unsigned sec;
 389         int i;
 390 #endif
 391 #ifdef BOOT_BWCT
 392         /* hardcoded link speed since we connect a switch via MII */
 393         update = pEmac->EMAC_CFG & ~(AT91C_EMAC_SPD | AT91C_EMAC_FD);
 394         update |= AT91C_EMAC_SPD;
 395         update |= AT91C_EMAC_FD;
 396 #endif
 397 #if defined(BOOT_KB920X) || defined(BOOT_CENTIPAD)
 398         stat2 = AT91F_MII_ReadPhy(pEmac, MII_STS2_REG);
 399         if (!(stat2 & MII_STS2_LINK))
 400                 return ;
 401         update = pEmac->EMAC_CFG & ~(AT91C_EMAC_SPD | AT91C_EMAC_FD);
 402         if (stat2 & MII_STS2_100TX)
 403                 update |= AT91C_EMAC_SPD;
 404         if (stat2 & MII_STS2_FDX)
 405                 update |= AT91C_EMAC_FD;
 406 #endif
 407 #ifdef BOOT_TSC
 408         while (1) {
 409                 for (i = 0; i < 10; i++) {
 410                         stat2 = AT91F_MII_ReadPhy(pEmac, MII_STS_REG);
 411                         if (stat2 & MII_STS_LINK_STAT)
 412                                 break;
 413                         printf(".");
 414                         sec = GetSeconds();
 415                         while (GetSeconds() == sec)
 416                             continue;
 417                 }
 418                 if (stat2 & MII_STS_LINK_STAT)
 419                         break;
 420                 printf("Resetting MII...");
 421                 AT91F_MII_WritePhy(pEmac, 0x0, 0x8000);
 422                 while (AT91F_MII_ReadPhy(pEmac, 0x0) & 0x8000) continue;
 423         }
 424         printf("emac: link");
 425         stat2 = AT91F_MII_ReadPhy(pEmac, MII_SPEC_STS_REG);
 426         update = pEmac->EMAC_CFG & ~(AT91C_EMAC_SPD | AT91C_EMAC_FD);
 427         if (stat2 & (MII_SSTS_100FDX | MII_SSTS_100HDX)) {
 428                 printf(" 100TX");
 429                 update |= AT91C_EMAC_SPD;
 430         }
 431         if (stat2 & (MII_SSTS_100FDX | MII_SSTS_10FDX)) {
 432                 printf(" FDX");
 433                 update |= AT91C_EMAC_FD;
 434         }
 435         printf("\n");
 436 #endif
 437         pEmac->EMAC_CFG = update;
 438 }
 439
 440
 441 /*
 442  * .KB_C_FN_DEFINITION_START
 443  * void AT91F_EmacEntry(void)
 444  *  This private function initializes the EMAC on the chip.
 445  * .KB_C_FN_DEFINITION_END
 446  */
 447 static void
 448 AT91F_EmacEntry(void)
 449 {
 450         unsigned        i;
 451         char            *pRxPacket = (char*)RX_DATA_START;
 452         AT91PS_EMAC     pEmac = AT91C_BASE_EMAC;
 453
 454         p_rxBD = (receive_descriptor_t*)RX_BUFFER_START;
 455         localPort = SWAP16(0x8002);
 456
 457         for (i = 0; i < MAX_RX_PACKETS; ++i) {
 458
 459                 p_rxBD[i].address = (unsigned)pRxPacket;
 460                 p_rxBD[i].size = 0;
 461                 pRxPacket += RX_PACKET_SIZE;
 462         }
 463
 464         // Set the WRAP bit at the end of the list descriptor
 465         p_rxBD[MAX_RX_PACKETS-1].address |= 0x02;
 466
 467         if (!(pEmac->EMAC_SR & AT91C_EMAC_LINK))
 468                 MII_GetLinkSpeed(pEmac);
 469
 470         pEmac->EMAC_RBQP = (unsigned) p_rxBD;
 471         pEmac->EMAC_RSR  |= (AT91C_EMAC_OVR | AT91C_EMAC_REC | AT91C_EMAC_BNA);
 472         pEmac->EMAC_CTL  = AT91C_EMAC_TE | AT91C_EMAC_RE;
 473
 474         pEmac->EMAC_TAR = (unsigned)transmitBuffer;
 475 }
 476
 477
 478 /* ************************** GLOBAL FUNCTIONS ********************************/
 479
 480 /*
 481  * .KB_C_FN_DEFINITION_START
 482  * void SetServerIPAddress(unsigned address)
 483  *  This global function sets the IP of the TFTP download server.
 484  * .KB_C_FN_DEFINITION_END
 485  */
 486 void
 487 SetServerIPAddress(unsigned address)
 488 {
 489         // force update in case the IP has changed
 490         serverMACSet = 0;
 491
 492         serverIPAddr[0] = (address >> 24) & 0xFF;
 493         serverIPAddr[1] = (address >> 16) & 0xFF;
 494         serverIPAddr[2] = (address >>  8) & 0xFF;
 495         serverIPAddr[3] = (address >>  0) & 0xFF;
 496
 497         serverIPSet = 1;
 498 }
 499
 500
 501 /*
 502  * .KB_C_FN_DEFINITION_START
 503  * void SetLocalIPAddress(unsigned address)
 504  *  This global function sets the IP of this module.
 505  * .KB_C_FN_DEFINITION_END
 506  */
 507 void
 508 SetLocalIPAddress(unsigned address)
 509 {
 510         // force update in case the IP has changed
 511         serverMACSet = 0;
 512
 513         localIPAddr[0] = (address >> 24) & 0xFF;
 514         localIPAddr[1] = (address >> 16) & 0xFF;
 515         localIPAddr[2] = (address >>  8) & 0xFF;
 516         localIPAddr[3] = (address >>  0) & 0xFF;
 517
 518         localIPSet = 1;
 519 }
 520
 521
 522 /*
 523  * .KB_C_FN_DEFINITION_START
 524  * void TFTP_Download(unsigned address, char *filename)
 525  *  This global function initiates and processes a tftp download request.
 526  * The server IP, local IP, local MAC must be set before this function is
 527  * executed.
 528  * .KB_C_FN_DEFINITION_END
 529  */
 530 void
 531 TFTP_Download(unsigned address, char *filename)
 532 {
 533         ip_header_t     IpHeader;
 534         unsigned        thisSeconds;
 535         int             timeout;
 536
 537         if ((!localMACSet) || (!localIPSet) || (!serverIPSet))
 538                 return ;
 539
 540         AT91F_EmacEntry();
 541         GetServerAddress();
 542         dlAddress = (char*)address;
 543         lastSize = 0;
 544         timeout = 10;
 545         thisSeconds = (GetSeconds() + 2) % 32;
 546         serverPort = SWAP16(69);
 547         ++localPort;
 548         ackBlock = -1;
 549
 550         while (timeout) {
 551                 if (CheckForNewPacket(&IpHeader)) {
 552                         if (ackBlock == -2)
 553                                 break;
 554                         timeout = 10;
 555                         thisSeconds = (GetSeconds() + 2) % 32;
 556                 } else if (GetSeconds() == thisSeconds) {
 557                         --timeout;
 558                         thisSeconds = (GetSeconds() + 2) % 32;
 559                         if (!serverMACSet)
 560                                 GetServerAddress();
 561                         else if (ackBlock == -1)
 562                                 TFTP_RequestFile(filename);
 563                         else {
 564                                 // Be sure to send a NAK, which is done by
 565                                 // ACKing the last block we got.
 566                                 TFTP_ACK_Data(0, ackBlock, 512);
 567                                 printf("\nNAK %u\n", ackBlock);
 568                         }
 569                 }
 570         }
 571         if (timeout == 0)
 572                 printf("TFTP TIMEOUT!\n");
 573 }