void tm4c129EthInitGpio(NetInterface *interface) { //DK-TM4C129X evaluation board? #if defined(USE_DK_TM4C129X) //Enable GPIO clocks SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOK); //Select the relevant alternate function for PF1, PK4 and PK6 GPIOPinConfigure(GPIO_PF1_EN0LED2); GPIOPinConfigure(GPIO_PK4_EN0LED0); GPIOPinConfigure(GPIO_PK6_EN0LED1); //Configure Ethernet LED pins for proper operation GPIOPinTypeEthernetLED(GPIO_PORTF_BASE, GPIO_PIN_1); GPIOPinTypeEthernetLED(GPIO_PORTK_BASE, GPIO_PIN_4 | GPIO_PIN_6); //EK-TM4C1294XL evaluation board? #elif defined(USE_EK_TM4C1294XL) //Enable GPIO clock SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); //Select the relevant alternate function for PF0 and PF4 GPIOPinConfigure(GPIO_PF0_EN0LED0); GPIOPinConfigure(GPIO_PF4_EN0LED1); //Configure Ethernet LED pins for proper operation GPIOPinTypeEthernetLED(GPIO_PORTF_BASE, GPIO_PIN_0 | GPIO_PIN_4); #endif }
void prvSetupHardware( void ) { /* If running on Rev A2 silicon, turn the LDO voltage up to 2.75V. This is a workaround to allow the PLL to operate reliably. */ if( DEVICE_IS_REVA2 ) { SysCtlLDOSet( SYSCTL_LDO_2_75V ); } /* Set the clocking to run from the PLL at 50 MHz */ SysCtlClockSet( SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | SYSCTL_XTAL_16MHZ ); /* Enable Port F for Ethernet LEDs LED0 Bit 3 Output LED1 Bit 2 Output */ SysCtlPeripheralEnable( SYSCTL_PERIPH_GPIOF ); /* GPIODirModeSet( GPIO_PORTF_BASE, (GPIO_PIN_2 | GPIO_PIN_3), GPIO_DIR_MODE_HW ); GPIOPadConfigSet( GPIO_PORTF_BASE, (GPIO_PIN_2 | GPIO_PIN_3 ), GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD ); */ //GPIOPinConfigure(GPIO_PF2_LED1); //GPIOPinConfigure(GPIO_PF3_LED0); GPIOPinTypeEthernetLED(GPIO_PORTF_BASE, GPIO_PIN_2 | GPIO_PIN_3); vParTestInitialise(); }
int rt_hw_luminaryif_init(void) { rt_err_t result; unsigned long ulUser0, ulUser1; /* Enable and Reset the Ethernet Controller. */ SysCtlPeripheralEnable(SYSCTL_PERIPH_ETH); SysCtlPeripheralReset(SYSCTL_PERIPH_ETH); /* Enable Port F for Ethernet LEDs. LED0 Bit 3 Output LED1 Bit 2 Output */ SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); /* GPIODirModeSet and GPIOPadConfigSet */ GPIOPinTypeEthernetLED(GPIO_PORTF_BASE, GPIO_PIN_2 | GPIO_PIN_3); GPIOPinConfigure(GPIO_PF2_LED1); GPIOPinConfigure(GPIO_PF3_LED0); FlashUserSet(0x00371200, 0x00563412); /* OUI:00-12-37 (hex) Texas Instruments, only for test */ /* Configure the hardware MAC address */ FlashUserGet(&ulUser0, &ulUser1); if((ulUser0 == 0xffffffff) || (ulUser1 == 0xffffffff)) { rt_kprintf("Fatal error in geting MAC address\n"); } /* init rt-thread device interface */ luminaryif_dev_entry.parent.parent.init = luminaryif_init; luminaryif_dev_entry.parent.parent.open = luminaryif_open; luminaryif_dev_entry.parent.parent.close = luminaryif_close; luminaryif_dev_entry.parent.parent.read = luminaryif_read; luminaryif_dev_entry.parent.parent.write = luminaryif_write; luminaryif_dev_entry.parent.parent.control = luminaryif_control; luminaryif_dev_entry.parent.eth_rx = luminaryif_rx; luminaryif_dev_entry.parent.eth_tx = luminaryif_tx; /* Convert the 24/24 split MAC address from NV ram into a 32/16 split MAC address needed to program the hardware registers, then program the MAC address into the Ethernet Controller registers. */ luminaryif_dev_entry.dev_addr[0] = ((ulUser0 >> 0) & 0xff); luminaryif_dev_entry.dev_addr[1] = ((ulUser0 >> 8) & 0xff); luminaryif_dev_entry.dev_addr[2] = ((ulUser0 >> 16) & 0xff); luminaryif_dev_entry.dev_addr[3] = ((ulUser1 >> 0) & 0xff); luminaryif_dev_entry.dev_addr[4] = ((ulUser1 >> 8) & 0xff); luminaryif_dev_entry.dev_addr[5] = ((ulUser1 >> 16) & 0xff); /* Program the hardware with it's MAC address (for filtering). */ EthernetMACAddrSet(ETH_BASE, luminaryif_dev_entry.dev_addr); rt_sem_init(&tx_sem, "emac", 1, RT_IPC_FLAG_FIFO); result = eth_device_init(&(luminaryif_dev->parent), "E0"); return result; }
/** * In this function, the hardware should be initialized. * Called from stellarisif_init(). * * @param netif the already initialized lwip network interface structure * for this ethernetif */ static void stellarisif_hwinit(struct netif *netif) { u32_t temp; //struct stellarisif *stellarisif = netif->state; /* set MAC hardware address length */ netif->hwaddr_len = ETHARP_HWADDR_LEN; #if 1 // // Enable the Link OK and Link Activity LEDS. // GPIOPinTypeEthernetLED(GPIO_PORTF_BASE, GPIO_PIN_2 | GPIO_PIN_3); GPIOPinConfigure(GPIO_PF3_LED0); GPIOPinConfigure(GPIO_PF2_LED1); #endif /* set MAC hardware address */ EthernetMACAddrGet(ETH_BASE, &(netif->hwaddr[0])); /* maximum transfer unit */ netif->mtu = 1500; /* device capabilities */ /* don't set NETIF_FLAG_ETHARP if this device is not an ethernet one */ netif->flags = NETIF_FLAG_BROADCAST | NETIF_FLAG_ETHARP | NETIF_FLAG_LINK_UP; /* Do whatever else is needed to initialize interface. */ /* Disable all Ethernet Interrupts. */ EthernetIntDisable(ETH_BASE, (ETH_INT_PHY | ETH_INT_MDIO | ETH_INT_RXER | ETH_INT_RXOF | ETH_INT_TX | ETH_INT_TXER | ETH_INT_RX)); temp = EthernetIntStatus(ETH_BASE, false); EthernetIntClear(ETH_BASE, temp); /* Initialize the Ethernet Controller. */ EthernetInitExpClk(ETH_BASE, SysCtlClockGet()); /* * Configure the Ethernet Controller for normal operation. * - Enable TX Duplex Mode * - Enable TX Padding * - Enable TX CRC Generation * - Enable RX Multicast Reception */ EthernetConfigSet(ETH_BASE, (ETH_CFG_TX_DPLXEN |ETH_CFG_TX_CRCEN | ETH_CFG_TX_PADEN | ETH_CFG_RX_AMULEN)); /* Enable the Ethernet Controller transmitter and receiver. */ EthernetEnable(ETH_BASE); /* Enable the Ethernet Interrupt handler. */ IntEnable(INT_ETH); /* Enable Ethernet TX and RX Packet Interrupts. */ EthernetIntEnable(ETH_BASE, ETH_INT_RX | ETH_INT_TX); }
void pin_init(void) { // Enable all the GPIO peripherals ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOG); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOH); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOJ); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOK); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOL); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOM); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPION); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOP); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOQ); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOR); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOS); // PF1/PK4/PK6 are used for Ethernet LEDs ROM_GPIOPinConfigure(GPIO_PK4_EN0LED0); ROM_GPIOPinConfigure(GPIO_PK6_EN0LED1); GPIOPinTypeEthernetLED(GPIO_PORTK_BASE, GPIO_PIN_4); GPIOPinTypeEthernetLED(GPIO_PORTK_BASE, GPIO_PIN_6); #ifdef DEVKIT // PN5 is used for the user LED ROM_GPIOPinTypeGPIOOutput(GPIO_PORTN_BASE, GPIO_PIN_5); ROM_GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_5, 0); #else // PA0-1 is used for the user LED ROM_GPIOPinTypeGPIOOutput(GPIO_PORTA_BASE, GPIO_PIN_1 | GPIO_PIN_0); ROM_GPIOPinWrite(GPIO_PORTA_BASE, GPIO_PIN_1 | GPIO_PIN_0, GPIO_PIN_0); // PH2-3 is used for the user LED ROM_GPIOPinTypeGPIOOutput(GPIO_PORTH_BASE, GPIO_PIN_3 | GPIO_PIN_2); ROM_GPIOPinWrite(GPIO_PORTH_BASE, GPIO_PIN_3 | GPIO_PIN_2, GPIO_PIN_3 | GPIO_PIN_2); #endif }
/*add by miaofng*/ void low_level_init(struct netif *netif) { // // Enable and Reset the Ethernet Controller. // SysCtlPeripheralEnable(SYSCTL_PERIPH_ETH); SysCtlPeripheralReset(SYSCTL_PERIPH_ETH); // // Enable Port F for Ethernet LEDs. // LED0 Bit 3 Output // LED1 Bit 2 Output // SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); GPIOPinTypeEthernetLED(GPIO_PORTF_BASE, GPIO_PIN_2 | GPIO_PIN_3); /* initialize the hardware */ stellarisif_hwinit(netif); }
//***************************************************************************** // //! Configures the device pins for the standard usages on the EK-TM4C1294XL. //! //! \param bEthernet is a boolean used to determine function of Ethernet pins. //! If true Ethernet pins are configured as Ethernet LEDs. If false GPIO are //! available for application use. //! \param bUSB is a boolean used to determine function of USB pins. If true USB //! pins are configured for USB use. If false then USB pins are available for //! application use as GPIO. //! //! This function enables the GPIO modules and configures the device pins for //! the default, standard usages on the EK-TM4C1294XL. Applications that //! require alternate configurations of the device pins can either not call //! this function and take full responsibility for configuring all the device //! pins, or can reconfigure the required device pins after calling this //! function. //! //! \return None. // //***************************************************************************** void PinoutSet(bool bEthernet, bool bUSB) { // // Enable all the GPIO peripherals. // ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOG); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOH); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOJ); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOK); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOL); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOM); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPION); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOP); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOQ); // // PA0-1 are used for UART0. // ROM_GPIOPinConfigure(GPIO_PA0_U0RX); ROM_GPIOPinConfigure(GPIO_PA1_U0TX); ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1); // // PB0-1/PD6/PL6-7 are used for USB. // PQ4 can be used as a power fault detect on this board but it is not // the hardware peripheral power fault input pin. // if(bUSB) { HWREG(GPIO_PORTD_BASE + GPIO_O_LOCK) = GPIO_LOCK_KEY; HWREG(GPIO_PORTD_BASE + GPIO_O_CR) = 0xff; ROM_GPIOPinConfigure(GPIO_PD6_USB0EPEN); ROM_GPIOPinTypeUSBAnalog(GPIO_PORTB_BASE, GPIO_PIN_0 | GPIO_PIN_1); ROM_GPIOPinTypeUSBDigital(GPIO_PORTD_BASE, GPIO_PIN_6); ROM_GPIOPinTypeUSBAnalog(GPIO_PORTL_BASE, GPIO_PIN_6 | GPIO_PIN_7); ROM_GPIOPinTypeGPIOInput(GPIO_PORTQ_BASE, GPIO_PIN_4); } else { // // Keep the default config for most pins used by USB. // Add a pull down to PD6 to turn off the TPS2052 switch // ROM_GPIOPinTypeGPIOInput(GPIO_PORTD_BASE, GPIO_PIN_6); MAP_GPIOPadConfigSet(GPIO_PORTD_BASE, GPIO_PIN_6, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPD); } // // PF0/PF4 are used for Ethernet LEDs. // if(bEthernet) { // // this app wants to configure for ethernet LED function. // ROM_GPIOPinConfigure(GPIO_PF0_EN0LED0); ROM_GPIOPinConfigure(GPIO_PF4_EN0LED1); GPIOPinTypeEthernetLED(GPIO_PORTF_BASE, GPIO_PIN_0 | GPIO_PIN_4); } else { // // This app does not want Ethernet LED function so configure as // standard outputs for LED driving. // ROM_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_0 | GPIO_PIN_4); // // Default the LEDs to OFF. // ROM_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_0 | GPIO_PIN_4, 0); MAP_GPIOPadConfigSet(GPIO_PORTF_BASE, GPIO_PIN_0 | GPIO_PIN_4, GPIO_STRENGTH_12MA, GPIO_PIN_TYPE_STD); } // // PJ0 and J1 are used for user buttons // ROM_GPIOPinTypeGPIOInput(GPIO_PORTJ_BASE, GPIO_PIN_0 | GPIO_PIN_1); ROM_GPIOPinWrite(GPIO_PORTJ_BASE, GPIO_PIN_0 | GPIO_PIN_1, 0); // // PN0 and PN1 are used for USER LEDs. // ROM_GPIOPinTypeGPIOOutput(GPIO_PORTN_BASE, GPIO_PIN_0 | GPIO_PIN_1); MAP_GPIOPadConfigSet(GPIO_PORTN_BASE, GPIO_PIN_0 | GPIO_PIN_1, GPIO_STRENGTH_12MA, GPIO_PIN_TYPE_STD); // // Default the LEDs to OFF. // ROM_GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_0 | GPIO_PIN_1, 0); }
//***************************************************************************** // // This example demonstrates the use of the Ethernet Controller with the uIP // TCP/IP stack. // //***************************************************************************** int main(void) { uip_ipaddr_t ipaddr; static struct uip_eth_addr sTempAddr; long lPeriodicTimer, lARPTimer, lPacketLength; unsigned long ulUser0, ulUser1; unsigned long ulTemp; // // Set the clocking to run directly from the crystal. // SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN | SYSCTL_XTAL_8MHZ); // // Initialize the OLED display. // RIT128x96x4Init(1000000); RIT128x96x4StringDraw("Ethernet with uIP", 12, 0, 15); // // Enable and Reset the Ethernet Controller. // SysCtlPeripheralEnable(SYSCTL_PERIPH_ETH); SysCtlPeripheralReset(SYSCTL_PERIPH_ETH); // // Enable Port F for Ethernet LEDs. // LED0 Bit 3 Output // LED1 Bit 2 Output // SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); GPIOPinTypeEthernetLED(GPIO_PORTF_BASE, GPIO_PIN_2 | GPIO_PIN_3); // // Configure SysTick for a periodic interrupt. // SysTickPeriodSet(SysCtlClockGet() / SYSTICKHZ); SysTickEnable(); SysTickIntEnable(); // // Intialize the Ethernet Controller and disable all Ethernet Controller // interrupt sources. // EthernetIntDisable(ETH_BASE, (ETH_INT_PHY | ETH_INT_MDIO | ETH_INT_RXER | ETH_INT_RXOF | ETH_INT_TX | ETH_INT_TXER | ETH_INT_RX)); ulTemp = EthernetIntStatus(ETH_BASE, false); EthernetIntClear(ETH_BASE, ulTemp); // // Initialize the Ethernet Controller for operation. // EthernetInitExpClk(ETH_BASE, SysCtlClockGet()); // // Configure the Ethernet Controller for normal operation. // - Full Duplex // - TX CRC Auto Generation // - TX Padding Enabled // EthernetConfigSet(ETH_BASE, (ETH_CFG_TX_DPLXEN | ETH_CFG_TX_CRCEN | ETH_CFG_TX_PADEN)); // // Wait for the link to become active. // RIT128x96x4StringDraw("Waiting for Link", 12, 8, 15); ulTemp = EthernetPHYRead(ETH_BASE, PHY_MR1); while((ulTemp & 0x0004) == 0) { ulTemp = EthernetPHYRead(ETH_BASE, PHY_MR1); } RIT128x96x4StringDraw("Link Established", 12, 16, 15); // // Enable the Ethernet Controller. // EthernetEnable(ETH_BASE); // // Enable the Ethernet interrupt. // IntEnable(INT_ETH); // // Enable the Ethernet RX Packet interrupt source. // EthernetIntEnable(ETH_BASE, ETH_INT_RX); // // Enable all processor interrupts. // IntMasterEnable(); // // Initialize the uIP TCP/IP stack. // uip_init(); #ifdef USE_STATIC_IP uip_ipaddr(ipaddr, DEFAULT_IPADDR0, DEFAULT_IPADDR1, DEFAULT_IPADDR2, DEFAULT_IPADDR3); uip_sethostaddr(ipaddr); DisplayIPAddress(ipaddr, 18, 24); uip_ipaddr(ipaddr, DEFAULT_NETMASK0, DEFAULT_NETMASK1, DEFAULT_NETMASK2, DEFAULT_NETMASK3); uip_setnetmask(ipaddr); #else uip_ipaddr(ipaddr, 0, 0, 0, 0); uip_sethostaddr(ipaddr); DisplayIPAddress(ipaddr, 18, 24); uip_ipaddr(ipaddr, 0, 0, 0, 0); uip_setnetmask(ipaddr); #endif // // Configure the hardware MAC address for Ethernet Controller filtering of // incoming packets. // // For the Ethernet Eval Kits, the MAC address will be stored in the // non-volatile USER0 and USER1 registers. These registers can be read // using the FlashUserGet function, as illustrated below. // FlashUserGet(&ulUser0, &ulUser1); if((ulUser0 == 0xffffffff) || (ulUser1 == 0xffffffff)) { // // We should never get here. This is an error if the MAC address has // not been programmed into the device. Exit the program. // RIT128x96x4StringDraw("MAC Address", 0, 16, 15); RIT128x96x4StringDraw("Not Programmed!", 0, 24, 15); while(1) { } } // // Convert the 24/24 split MAC address from NV ram into a 32/16 split MAC // address needed to program the hardware registers, then program the MAC // address into the Ethernet Controller registers. // sTempAddr.addr[0] = ((ulUser0 >> 0) & 0xff); sTempAddr.addr[1] = ((ulUser0 >> 8) & 0xff); sTempAddr.addr[2] = ((ulUser0 >> 16) & 0xff); sTempAddr.addr[3] = ((ulUser1 >> 0) & 0xff); sTempAddr.addr[4] = ((ulUser1 >> 8) & 0xff); sTempAddr.addr[5] = ((ulUser1 >> 16) & 0xff); // // Program the hardware with it's MAC address (for filtering). // EthernetMACAddrSet(ETH_BASE, (unsigned char *)&sTempAddr); uip_setethaddr(sTempAddr); // // Initialize the TCP/IP Application (e.g. web server). // httpd_init(); #ifndef USE_STATIC_IP // // Initialize the DHCP Client Application. // dhcpc_init(&sTempAddr.addr[0], 6); dhcpc_request(); #endif // // Main Application Loop. // lPeriodicTimer = 0; lARPTimer = 0; while(true) { // // Wait for an event to occur. This can be either a System Tick event, // or an RX Packet event. // while(!g_ulFlags) { } // // If SysTick, Clear the SysTick interrupt flag and increment the // timers. // if(HWREGBITW(&g_ulFlags, FLAG_SYSTICK) == 1) { HWREGBITW(&g_ulFlags, FLAG_SYSTICK) = 0; lPeriodicTimer += SYSTICKMS; lARPTimer += SYSTICKMS; } // // Check for an RX Packet and read it. // lPacketLength = EthernetPacketGetNonBlocking(ETH_BASE, uip_buf, sizeof(uip_buf)); if(lPacketLength > 0) { // // Set uip_len for uIP stack usage. // uip_len = (unsigned short)lPacketLength; // // Clear the RX Packet event and renable RX Packet interrupts. // if(HWREGBITW(&g_ulFlags, FLAG_RXPKT) == 1) { HWREGBITW(&g_ulFlags, FLAG_RXPKT) = 0; EthernetIntEnable(ETH_BASE, ETH_INT_RX); } // // Process incoming IP packets here. // if(BUF->type == htons(UIP_ETHTYPE_IP)) { uip_arp_ipin(); uip_input(); // // If the above function invocation resulted in data that // should be sent out on the network, the global variable // uip_len is set to a value > 0. // if(uip_len > 0) { uip_arp_out(); EthernetPacketPut(ETH_BASE, uip_buf, uip_len); uip_len = 0; } } // // Process incoming ARP packets here. // else if(BUF->type == htons(UIP_ETHTYPE_ARP)) { uip_arp_arpin(); // // If the above function invocation resulted in data that // should be sent out on the network, the global variable // uip_len is set to a value > 0. // if(uip_len > 0) { EthernetPacketPut(ETH_BASE, uip_buf, uip_len); uip_len = 0; } } } // // Process TCP/IP Periodic Timer here. // if(lPeriodicTimer > UIP_PERIODIC_TIMER_MS) { lPeriodicTimer = 0; for(ulTemp = 0; ulTemp < UIP_CONNS; ulTemp++) { uip_periodic(ulTemp); // // If the above function invocation resulted in data that // should be sent out on the network, the global variable // uip_len is set to a value > 0. // if(uip_len > 0) { uip_arp_out(); EthernetPacketPut(ETH_BASE, uip_buf, uip_len); uip_len = 0; } } #if UIP_UDP for(ulTemp = 0; ulTemp < UIP_UDP_CONNS; ulTemp++) { uip_udp_periodic(ulTemp); // // If the above function invocation resulted in data that // should be sent out on the network, the global variable // uip_len is set to a value > 0. // if(uip_len > 0) { uip_arp_out(); EthernetPacketPut(ETH_BASE, uip_buf, uip_len); uip_len = 0; } } #endif // UIP_UDP } // // Process ARP Timer here. // if(lARPTimer > UIP_ARP_TIMER_MS) { lARPTimer = 0; uip_arp_timer(); } } }
/** * Creates task to feed data from interrupt to lwIP, * initializes EMAC0, then initializes lwIP */ void init_ethernet(void){/*{{{*/ { // Enable Ethernet hardware/*{{{*/ uint32_t user0, user1; /** * Enable ethernet * See page 160 of spmu298a */ MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_EMAC0); MAP_SysCtlPeripheralReset(SYSCTL_PERIPH_EMAC0); //Enable internal PHY MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_EPHY0); MAP_SysCtlPeripheralReset(SYSCTL_PERIPH_EPHY0); // Set Ethernet LED pinouts // See Page 269 of spmu298a.pdf MAP_GPIOPinConfigure(GPIO_PF0_EN0LED0); MAP_GPIOPinConfigure(GPIO_PF4_EN0LED1); GPIOPinTypeEthernetLED(GPIO_PORTF_BASE, GPIO_PIN_0|GPIO_PIN_4); // Busy wait until MAC ready while(MAP_SysCtlPeripheralReady(SYSCTL_PERIPH_EMAC0) == 0); //Using builtin PHY, so don't need to call GPIOPinTypeEthernetMII() MAP_EMACPHYConfigSet(EMAC0_BASE, EMAC_PHY_TYPE_INTERNAL|EMAC_PHY_INT_MDIX_EN|EMAC_PHY_AN_100B_T_FULL_DUPLEX); // Initialize MAC (see spmu363a.pdf) // Maybe should optimize burst size MAP_EMACInit(EMAC0_BASE, g_syshz, EMAC_BCONFIG_MIXED_BURST|EMAC_BCONFIG_PRIORITY_FIXED, 4, 4, 0); // Set options // Tune parameters MAP_EMACConfigSet(EMAC0_BASE, (EMAC_CONFIG_FULL_DUPLEX | EMAC_CONFIG_CHECKSUM_OFFLOAD | EMAC_CONFIG_7BYTE_PREAMBLE | EMAC_CONFIG_IF_GAP_96BITS | EMAC_CONFIG_USE_MACADDR0 | EMAC_CONFIG_SA_FROM_DESCRIPTOR | EMAC_CONFIG_100MBPS| EMAC_CONFIG_BO_LIMIT_1024), (EMAC_MODE_RX_STORE_FORWARD | EMAC_MODE_TX_STORE_FORWARD | EMAC_MODE_TX_THRESHOLD_64_BYTES | EMAC_MODE_RX_THRESHOLD_64_BYTES), 0); //Mac Address saved in user0 and user1 by default MAP_FlashUserGet(&user0, &user1); mac_addr[0] = user0 & 0xFF; mac_addr[1] = user0 >> 8 & 0xFF; mac_addr[2] = user0 >> 16 & 0xFF; mac_addr[3] = user1 & 0xFF; mac_addr[4] = user1 >> 8 & 0xFF; mac_addr[5] = user1 >> 16 & 0xFF; MAP_EMACAddrSet(EMAC0_BASE, 0, mac_addr ); //Explicitly Disable PTP EMACTimestampDisable(EMAC0_BASE); }/*}}}*/ // Lower priority of ISR so *FromISR functions can be safely called MAP_IntPrioritySet(INT_EMAC0, ETH_ISR_PRIO); tcpip_init(tcpip_init_cb, NULL); }/*}}}*/