| /* |
| * Copyright (c) 2013 Qualcomm Atheros, Inc. |
| * |
| * This program is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU General Public License |
| * as published by the Free Software Foundation; either version 2 |
| * of the License, or (at your option) any later version. |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| * |
| * You should have received a copy of the GNU General Public License |
| * along with this program; if not, write to the Free Software |
| * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. |
| * |
| */ |
| |
| #include <stdio.h> |
| #include <sys/types.h> |
| #include <sys/socket.h> |
| #include <getopt.h> |
| #include <errno.h> |
| #include <err.h> |
| #include <sys/ioctl.h> |
| #include <unistd.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <net/if.h> |
| #include <fcntl.h> |
| #include "athrs_ctrl.h" |
| #include <stdint.h> |
| #define MAX_SIZ 10 |
| |
| struct eth_cfg_params { |
| int cmd; |
| char ad_name[IFNAMSIZ]; /* if name, e.g. "lan0" */ |
| uint16_t vlanid; |
| uint16_t portnum; |
| uint32_t phy_reg; |
| uint32_t tos; |
| uint32_t val; |
| uint8_t duplex; |
| uint8_t mac_addr[6]; |
| struct rx_stats rxcntr; |
| struct tx_stats txcntr; |
| struct tx_mac_stats txmac; |
| struct rx_mac_stats rxmac; |
| phystats phy_st; |
| |
| }; |
| |
| struct ifreq ifr; |
| struct eth_cfg_params etd; |
| int s,opt_force = 0,duplex = 1; |
| const char *progname; |
| static void rx_stats(void) |
| { |
| //printf ("\n\n%s\n", __func__); |
| printf ("\t%d\t port%d :Rx bcast cntr\n", etd.rxcntr.rx_broad, etd.portnum); |
| printf ("\t%d\t port%d :Rx pause cntr\n", etd.rxcntr.rx_pause, etd.portnum); |
| printf ("\t%d\t port%d :Rx multi frames rcvd\n", etd.rxcntr.rx_multi, etd.portnum); |
| printf ("\t%d\t port%d :Rx fcs err cntr\n", etd.rxcntr.rx_fcserr, etd.portnum); |
| printf ("\t%d\t port%d :Rx allign err cntr\n", etd.rxcntr.rx_allignerr, etd.portnum); |
| printf ("\t%d\t port%d :Rx runt cntr \n", etd.rxcntr.rx_runt, etd.portnum); |
| printf ("\t%d\t port%d :Rx fragment cntr\n", etd.rxcntr.rx_frag, etd.portnum); |
| printf ("\t%d\t port%d :Rx 64b byte cntr\n", etd.rxcntr.rx_64b, etd.portnum); |
| printf ("\t%d\t port%d :Rx 128b byte cntr\n", etd.rxcntr.rx_128b, etd.portnum); |
| printf ("\t%d\t port%d :Rx 256b byte cntr\n", etd.rxcntr.rx_256b, etd.portnum); |
| printf ("\t%d\t port%d :Rx 512b byte cntr\n", etd.rxcntr.rx_512b, etd.portnum); |
| printf ("\t%d\t port%d :Rx 1024b byte cntr\n", etd.rxcntr.rx_1024b, etd.portnum); |
| printf ("\t%d\t port%d :Rx 1518b byte cntr\n ", etd.rxcntr.rx_1518b, etd.portnum); |
| printf ("\t%d\t port%d :Rx total pkt rcvd\n", (etd.rxcntr.rx_64b + etd.rxcntr.rx_128b + etd.rxcntr.rx_256b + |
| etd.rxcntr.rx_512b + etd.rxcntr.rx_1024b + etd.rxcntr.rx_1518b), etd.portnum); |
| printf ("\t%d\t port%d :Rx maxb cntr\n", etd.rxcntr.rx_maxb, etd.portnum); |
| printf ("\t%d\t port%d :Rx too long cntr\n", etd.rxcntr.rx_tool, etd.portnum); |
| printf ("\t%d\t port%d :Rx byte_l\n", etd.rxcntr.rx_goodbl, etd.portnum); |
| printf ("\t%d\t port%d :Rx byte_h\n", etd.rxcntr.rx_goodbh, etd.portnum); |
| printf ("\t%d\t port%d :Rx overflow cntr\n", etd.rxcntr.rx_overflow, etd.portnum); |
| printf ("\t%d\t port%d :Rx bad byte_l cntr\n", etd.rxcntr.rx_badbl, etd.portnum); |
| printf ("\t%d\t port%d :Rx bad byte_u cntr\n", etd.rxcntr.rx_badbu, etd.portnum); |
| } |
| |
| static void tx_stats(void) |
| { |
| printf ("\n\n%s\n", __func__); |
| printf ("\t%d\t port%d : Tx bcast cntr \n", etd.txcntr.tx_broad, etd.portnum); |
| printf ("\t%d\t port%d : Tx pause cntr\n", etd.txcntr.tx_pause, etd.portnum); |
| printf ("\t%d\t port%d : Tx multi cntr\n", etd.txcntr.tx_multi, etd.portnum); |
| printf ("\t%d\t port%d : Tx under run cntr\n", etd.txcntr.tx_underrun, etd.portnum); |
| printf ("\t%d\t port%d : Tx 64b byte cntr\n", etd.txcntr.tx_64b, etd.portnum); |
| printf ("\t%d\t port%d : Tx 128b byte cntr\n", etd.txcntr.tx_128b, etd.portnum); |
| printf ("\t%d\t port%d : Tx 256b byte cntr\n", etd.txcntr.tx_256b, etd.portnum); |
| printf ("\t%d\t port%d : Tx 512b byte cntr\n", etd.txcntr.tx_512b, etd.portnum); |
| printf ("\t%d\t port%d : Tx 1024b byte cntr\n", etd.txcntr.tx_1024b, etd.portnum); |
| printf ("\t%d\t port%d : Tx 1518b byte cntr\n", etd.txcntr.tx_1518b, etd.portnum); |
| printf ("\t%d\t port%d : Tx total pkt txmtd cntr\n", (etd.txcntr.tx_64b + etd.txcntr.tx_128b |
| + etd.txcntr.tx_256b+ etd.txcntr.tx_512b + etd.txcntr.tx_1024b |
| + etd.txcntr.tx_1518b), etd.portnum); |
| printf ("\t%d\t port%d : Tx max byte cntr\n", etd.txcntr.tx_maxb, etd.portnum); |
| printf ("\t%d\t port%d : Tx oversize \n", etd.txcntr.tx_oversiz, etd.portnum); |
| printf ("\t%d\t port%d : Tx byte _l \n", etd.txcntr.tx_bytel, etd.portnum); |
| printf ("\t%d\t port%d : Tx byte _h \n", etd.txcntr.tx_byteh, etd.portnum); |
| printf ("\t%d\t port%d : Tx collision err cntr\n", etd.txcntr.tx_collision, etd.portnum); |
| printf ("\t%d\t port%d : Tx abort collision err cntr\n", etd.txcntr.tx_abortcol, etd.portnum); |
| printf ("\t%d\t port%d : Tx multi collision err cntr\n", etd.txcntr.tx_multicol, etd.portnum); |
| printf ("\t%d\t port%d : Tx single collision err cntr\n", etd.txcntr.tx_singalcol, etd.portnum); |
| printf ("\t%d\t port%d : Tx exec deffer err cntr\n", etd.txcntr.tx_execdefer, etd.portnum); |
| printf ("\t%d\t port%d : Tx defer err cntr\n", etd.txcntr.tx_defer, etd.portnum); |
| printf ("\t%d\t port%d : Tx late collision err cntr\n", etd.txcntr.tx_latecol, etd.portnum); |
| |
| } |
| static void tx_mac_stats(void) |
| { |
| printf ("\n\n%s\n", __func__); |
| printf ("\t%d\t : Tx pkt cntr\n", etd.txmac.pkt_cntr); |
| printf ("\t%d\t : Tx byte cntr\n", etd.txmac.byte_cntr); |
| printf ("\t%d\t : Tx mcast pkt cntr\n", etd.txmac.mcast_cntr); |
| printf ("\t%d\t : Tx bcast pkt cntr\n", etd.txmac.bcast_cntr); |
| printf ("\t%d\t : Tx pause frame pkt cntr\n", etd.txmac.pctrlframe_cntr); |
| printf ("\t%d\t : Tx deferal pkt cntr\n", etd.txmac.deferal_cntr); |
| printf ("\t%d\t : Tx excessive deferal pkt cntr\n", etd.txmac.excess_deferal_cntr); |
| printf ("\t%d\t : Tx single collision pkt cntr\n", etd.txmac.single_col_cntr); |
| printf ("\t%d\t : Tx multiple collision pkt cntr\n", etd.txmac.multi_col_cntr); |
| printf ("\t%d\t : Tx late collision pkt cntr\n", etd.txmac.late_col_cntr); |
| printf ("\t%d\t : Tx excessive collison pkt cntr\n", etd.txmac.excess_col_cntr); |
| printf ("\t%d\t : Tx total collison pkt cntr\n", etd.txmac.total_col_cntr); |
| printf ("\t%d\t : Tx drop frame cntr\n", etd.txmac.dropframe_cntr); |
| printf ("\t%d\t : Tx jabber frame cntr\n", etd.txmac.jabberframe_cntr); |
| printf ("\t%d\t : Tx fcs err cntr\n", etd.txmac.fcserr_cntr); |
| printf ("\t%d\t : Tx control frame cntr\n", etd.txmac.ctrlframe_cntr); |
| printf ("\t%d\t : Tx oversize frame cntr\n", etd.txmac.oz_frame_cntr); |
| printf ("\t%d\t : Tx undersize frame cntr\n", etd.txmac.us_frame_cntr); |
| printf ("\t%d\t : Tx fragments frame cntr\n", etd.txmac.frag_frame_cntr); |
| |
| } |
| static void rx_mac_stats (void) |
| { |
| printf ("\n\n%s\n", __func__); |
| printf ("\t%d\t: Rx byte cntr\n", etd.rxmac.byte_cntr); |
| printf ("\t%d\t: Rx pkt cntr\n", etd.rxmac.pkt_cntr); |
| printf ("\t%d\t: Rx fcs err cntr\n", etd.rxmac.fcserr_cntr); |
| printf ("\t%d\t: Rx mcast pkt cntr\n", etd.rxmac.mcast_cntr); |
| printf ("\t%d\t: Rx bcast pkt cntr\n", etd.rxmac.bcast_cntr); |
| printf ("\t%d\t: Rx ctrl frame cntr\n", etd.rxmac.ctrlframe_cntr); |
| printf ("\t%d\t: Rx pause frame pkt cntr\n", etd.rxmac.pausefr_cntr); |
| printf ("\t%d\t: Rx unknown opcode cntr\n", etd.rxmac.unknownop_cntr); |
| printf ("\t%d\t: Rx alignment err cntr\n", etd.rxmac.allignerr_cntr); |
| printf ("\t%d\t: Rx frame length err cntr\n", etd.rxmac.framelerr_cntr); |
| printf ("\t%d\t: Rx code err cntr\n", etd.rxmac.codeerr_cntr); |
| printf ("\t%d\t: Rx carrier sense err cntr\n", etd.rxmac.carriersenseerr_cntr); |
| printf ("\t%d\t: Rx under sz pkt cntr\n", etd.rxmac.underszpkt_cntr); |
| printf ("\t%d\t: Rx over sz pkt cntr\n", etd.rxmac.ozpkt_cntr); |
| printf ("\t%d\t: Rx fragment cntr\n", etd.rxmac.fragment_cntr); |
| printf ("\t%d\t: Rx jabber cntr\n", etd.rxmac.jabber_cntr); |
| printf ("\t%d\t: RX drop cntr\n",etd.rxmac.rcvdrop_cntr); |
| printf ("\t%u\t: Rx overfl cntr\n",etd.rxmac.rxoverfl); |
| |
| } |
| |
| |
| |
| u_int32_t |
| regread(u_int32_t phy_reg,u_int16_t portno) |
| { |
| |
| etd.phy_reg = phy_reg; |
| etd.cmd = ATHR_PHY_RD; |
| etd.portnum = portno; |
| if (ioctl(s,ATHR_PHY_CTRL_IOC, &ifr) < 0) |
| err(1, etd.ad_name); |
| return etd.val; |
| } |
| static void athr_en_jumboframe(int value) |
| { |
| etd.cmd = ATHR_JUMBO_FRAME; |
| etd.val=value; |
| if (ioctl(s,ATHR_GMAC_CTRL_IOC, &ifr) < 0) |
| err(1,etd.ad_name); |
| } |
| static void athr_set_framesize(int sz) |
| { |
| etd.cmd = ATHR_FRAME_SIZE_CTL; |
| etd.val = sz; |
| if (ioctl(s,ATHR_GMAC_CTRL_IOC, &ifr) < 0) |
| err(1,etd.ad_name); |
| |
| } |
| static void athr_commit_acl_rules(void) |
| { |
| etd.cmd = ATHR_ACL_COMMIT; |
| if (ioctl(s,ATHR_HW_ACL_IOC,&ifr) < 0) |
| err(1,etd.ad_name); |
| |
| } |
| static void athr_flush_acl_rules(void) |
| { |
| etd.cmd = ATHR_ACL_FLUSH; |
| if (ioctl(s,ATHR_HW_ACL_IOC,&ifr) < 0) |
| err(1,etd.ad_name); |
| } |
| static void athr_flow_link (int portno, int val) |
| { |
| etd.cmd = ATHR_FLOW_LINK_EN; |
| etd.val = val; |
| etd.portnum = portno; |
| if (ioctl (s, ATHR_PHY_CTRL_IOC, &ifr) < 0) |
| err(1,etd.ad_name); |
| } |
| static void athr_txflctrl (int portno, int val) |
| { |
| if (portno == 0x3f) { |
| etd.val = val; |
| etd.cmd = ATHR_GMAC_TX_FLOW_CTRL; |
| if (ioctl (s, ATHR_GMAC_CTRL_IOC, &ifr) < 0) |
| printf("%s ioctl error\n",__func__); |
| |
| } else { |
| etd.cmd = ATHR_PHY_TXFCTL; |
| etd.portnum = portno; |
| etd.val = val; |
| if (ioctl (s, ATHR_PHY_CTRL_IOC, &ifr) < 0) |
| printf("%s ioctl error\n",__func__); |
| |
| } |
| |
| |
| } |
| static void athr_gmac_flow_ctrl(int val) |
| { |
| etd.val = val; |
| etd.cmd = ATHR_GMAC_FLOW_CTRL; |
| if (ioctl (s, ATHR_GMAC_CTRL_IOC, &ifr) < 0) |
| printf("%s ioctl error\n",__func__); |
| |
| } |
| static void athr_phy_flow_ctrl(int val, int portno) |
| { |
| etd.val = val; |
| etd.cmd = ATHR_PHY_FLOW_CTRL; |
| etd.portnum = portno; |
| if (ioctl (s, ATHR_PHY_CTRL_IOC, &ifr) < 0) |
| printf("%s ioctl error\n",__func__); |
| } |
| static void athr_rxflctrl (int portno, int val) |
| { |
| if (portno == 0x3f) { |
| etd.val = val; |
| etd.cmd = ATHR_GMAC_RX_FLOW_CTRL; |
| if (ioctl (s, ATHR_GMAC_CTRL_IOC, &ifr) < 0) |
| printf("%s ioctl error\n",__func__); |
| |
| } else { |
| etd.cmd = ATHR_PHY_RXFCTL; |
| etd.portnum = portno; |
| etd.val = val; |
| if (ioctl (s, ATHR_PHY_CTRL_IOC, &ifr) < 0) |
| printf("%s ioctl error\n",__func__); |
| |
| } |
| |
| |
| } |
| static void athr_set_mib(int val) |
| { |
| etd.cmd = ATHR_PHY_MIB; |
| etd.portnum = 0x3f; |
| etd.val = val; |
| if (ioctl (s, ATHR_PHY_CTRL_IOC, &ifr) < 0) |
| err(1, etd.ad_name); |
| } |
| static void athr_disp_stats(int portno) |
| { |
| if (portno == 0x3f) { |
| etd.cmd = ATHR_GMAC_STATS; |
| if (ioctl (s, ATHR_GMAC_CTRL_IOC, &ifr) < 0){ |
| err(1, etd.ad_name); |
| } else { |
| rx_mac_stats (); |
| tx_mac_stats (); |
| |
| } |
| |
| } else { |
| etd.cmd = ATHR_PHY_STATS; |
| etd.portnum = portno; |
| if (ioctl (s, ATHR_PHY_CTRL_IOC, &ifr) < 0) |
| err(1, etd.ad_name); |
| else{ |
| rx_stats (); |
| tx_stats (); |
| |
| } |
| } |
| |
| } |
| static void athr_dma_check(int val) |
| { |
| etd.cmd = ATHR_GMAC_DMA_CHECK; |
| etd.val = val; |
| if (ioctl (s, ATHR_GMAC_CTRL_IOC, &ifr) < 0) |
| err(1, etd.ad_name); |
| |
| } |
| |
| static void athr_set_qos(int val) |
| { |
| etd.cmd = ATHR_QOS_ETH_SOFT_CLASS; |
| etd.val = val; |
| if (ioctl (s, ATHR_GMAC_QOS_CTRL_IOC, &ifr) < 0) |
| err (1, etd.ad_name); |
| } |
| static void athr_set_port_pri(int portno, int val) |
| { |
| etd.cmd = ATHR_QOS_ETH_PORT; |
| etd.portnum = portno; |
| etd.val = val; |
| if (ioctl (s, ATHR_GMAC_QOS_CTRL_IOC, &ifr) < 0) |
| err (1, etd.ad_name); |
| |
| } |
| static void athr_ip_qos (int tos, int val) |
| { |
| etd.cmd = ATHR_QOS_ETH_IP; |
| etd.val = val; |
| etd.tos = tos; |
| if (ioctl (s, ATHR_GMAC_QOS_CTRL_IOC, &ifr) < 0) |
| err (1, etd.ad_name); |
| |
| } |
| static void athr_vlan_qos (int vlan_id, int val) |
| { |
| etd.cmd = ATHR_QOS_ETH_VLAN; |
| etd.val = val; |
| etd.vlanid = vlan_id; |
| if (ioctl (s, ATHR_GMAC_QOS_CTRL_IOC, &ifr) < 0) |
| err (1, etd.ad_name); |
| |
| } |
| static void athr_mac_qos(int portno, int val, char *mac_addr) |
| { |
| etd.cmd = ATHR_QOS_ETH_DA; |
| etd.val = val; |
| etd.portnum = portno; |
| sscanf (mac_addr, "%hhx:%hhx:%hhx:%hhx:%hhx:%hhx", |
| &etd.mac_addr[0], &etd.mac_addr[1], |
| &etd.mac_addr[2], &etd.mac_addr[3], |
| &etd.mac_addr[4], &etd.mac_addr[5]); |
| if (ioctl (s, ATHR_GMAC_QOS_CTRL_IOC, &ifr) < 0) |
| err (1, etd.ad_name); |
| |
| } |
| |
| static int athr_port_st(int portno) |
| { |
| char str[][MAX_SIZ] = {"10Mbps","100Mbps","1000Mbps"}; |
| |
| etd.cmd = ATHR_PORT_STATS; |
| etd.portnum = portno; |
| if (etd.portnum > 5){ |
| printf ("port usage <0-5>"); |
| return -EINVAL; |
| } |
| if (ioctl (s, ATHR_PHY_CTRL_IOC, &ifr) < 0) |
| err (1, etd.ad_name); |
| printf("\t\t\t____phy%d stats____\n",etd.portnum); |
| printf("Link:\t\t%s\n",etd.phy_st.link ? "alive":"Not alive"); |
| printf("Speed:\t\t%s\n",str[etd.phy_st.speed]); |
| printf("Duplex:\t\t%s\n",etd.phy_st.duplex ? "Full duplex":"Half-duplex"); |
| printf("Rx flowctrl:\t%s\n",etd.phy_st.rxflctrl ? "Enabled": "Disabled"); |
| printf("Tx flowctrl:\t%s\n",etd.phy_st.txflctrl ? "Enabled": "Disabled"); |
| return 0; |
| |
| } |
| static void athr_process_egress(int portno, int val) |
| { |
| etd.cmd = ATHR_QOS_PORT_ELIMIT; |
| etd.val = val; |
| etd. portnum = portno; |
| if (ioctl (s, ATHR_GMAC_QOS_CTRL_IOC, &ifr) < 0) |
| err (1, etd.ad_name); |
| |
| } |
| static void athr_process_igress(int portno, int val) |
| { |
| etd.cmd = ATHR_QOS_PORT_ILIMIT; |
| etd.val = val; |
| etd. portnum = portno; |
| if (ioctl (s, ATHR_GMAC_QOS_CTRL_IOC, &ifr) < 0) |
| err (1, etd.ad_name); |
| |
| } |
| |
| |
| void regwrite(u_int32_t phy_reg,u_int32_t val,u_int16_t portno) |
| { |
| |
| etd.val = val; |
| etd.phy_reg = phy_reg; |
| etd.portnum = portno; |
| if(opt_force) { |
| etd.duplex = duplex; |
| etd.cmd = ATHR_PHY_FORCE; |
| if (ioctl(s,ATHR_PHY_CTRL_IOC, &ifr) < 0) |
| err(1, etd.ad_name); |
| opt_force = 0; |
| } |
| else { |
| etd.cmd = ATHR_PHY_WR; |
| if (ioctl(s,ATHR_PHY_CTRL_IOC, &ifr) < 0) |
| err(1, etd.ad_name); |
| } |
| } |
| |
| static void usage(void) |
| { |
| fprintf(stderr, "usage: %s [-i ifname] [-p portnum] offset[=value]\n", progname); |
| fprintf(stderr, "usage: %s [-f] -p portnum =10/100/0 [-d duplex]\n", progname); |
| fprintf(stderr, "usage: %s [-i ifname][-x]\n", progname); |
| fprintf(stderr, "usage: %s [-i ifname][-c]\n", progname); |
| fprintf(stderr, "usage: %s [-i ifname][-s value]\n", progname); |
| fprintf(stderr, "usage: %s [-i ifname][-j 0|1]\n", progname); |
| fprintf(stderr, "usage: %s [--txfctl] [-i ifname] -v [0|1]\n", progname); |
| fprintf(stderr, "usage: %s [--txfctl] [-i ifname] -v [0|1] -p <portno>\n", progname); |
| fprintf(stderr, "usage: %s [--rxfctl] [-i ifname] -v [0|1]\n",progname); |
| fprintf(stderr, "usage: %s [--rxfctl] [-i ifname] -v [0|1] -p <portno>\n", progname); |
| fprintf(stderr, "usage: %s [--macfl] [-i ifname] -v [0|1]\n", progname); |
| fprintf(stderr, "usage: %s [--swfl] [-i ifname] -v [0|1]\n", progname); |
| fprintf(stderr, "usage: %s [--dma] [-i ifname] -v [0|1]\n", progname); |
| fprintf(stderr, "usage: %s [--f_link] [-i ifname] -v [0|1]\n", progname); |
| fprintf(stderr, "usage: %s [--mib] [-i ifname] -v [0|1]\n", progname); |
| fprintf(stderr, "usage: %s [--stats] [-i ifname]\n", progname); |
| fprintf(stderr, "usage: %s [--stats] [-i ifname] -p <portno>\n", progname); |
| fprintf(stderr, "usage: %s [--qos] [-i ifname] -v [0|1]\n", progname); |
| fprintf(stderr, "usage: %s [--ipqos] [-i ifname] -t <tos> -v <val>\n", progname); |
| fprintf(stderr, "usage: %s [--vqos] [-i ifname] -l <vlanid> -v <val>\n", progname); |
| fprintf(stderr, "usage: %s [--mqos [-i ifname] -v <val> -p <portnum> -m <macaddr>\n", progname); |
| fprintf(stderr, "usage: %s [--p_st] [-i ifname] -p <portno>\n", progname); |
| fprintf(stderr, "usage: %s [--igrl] [-i ifname] -p <portno> -v <val>\n", progname); |
| fprintf(stderr, "usage: %s [--egrl] [-i ifname] -p <portno> -v <val>\n", progname); |
| fprintf(stderr, "usage: %s [-i ifname][-s value]\n",progname); |
| fprintf(stderr, "usage: %s [-i ifname][-j 0|1]\n",progname); |
| exit(-1); |
| } |
| |
| |
| int |
| ethreg_main(int argc, char *argv[]) |
| { |
| const char *ifname = "lan0"; |
| int c,portnum = 0x3f,cmd = 0,value = -1; |
| int optionindex = 0; |
| int vlanid = 0; |
| char *mac = NULL; |
| int tos = -1; |
| char *opt = "xfhci:d:s:j:v:t:p:m:l:"; |
| |
| s = socket(AF_INET, SOCK_DGRAM, 0); |
| if (s < 0) |
| err(1, "socket"); |
| |
| opt_force = 0; |
| progname = argv[0]; |
| |
| |
| struct option long_options[] = |
| { |
| { "f_link", no_argument, 0, ATHR_FLOW_LINK_EN}, |
| { "txfctl", no_argument, 0, ATHR_PHY_TXFCTL}, |
| { "rxfctl", no_argument, 0, ATHR_PHY_RXFCTL}, |
| { "stats" , no_argument, 0, ATHR_GMAC_STATS}, |
| { "mib" , no_argument, 0, ATHR_PHY_MIB}, |
| { "dma" , no_argument, 0, ATHR_GMAC_DMA_CHECK}, |
| { "qos" , no_argument, 0, ATHR_QOS_ETH_SOFT_CLASS}, |
| { "ppri" , no_argument, 0, ATHR_QOS_ETH_PORT}, |
| { "ipqos" , no_argument, 0, ATHR_QOS_ETH_IP}, |
| { "vqos" , no_argument, 0, ATHR_QOS_ETH_VLAN}, |
| { "mqos" , no_argument, 0, ATHR_QOS_ETH_DA}, |
| { "igrl" , no_argument, 0, ATHR_QOS_PORT_ELIMIT}, |
| { "egrl" , no_argument, 0, ATHR_QOS_PORT_ILIMIT}, |
| { "p_st" , no_argument, 0, ATHR_PORT_STATS}, |
| { "macfl" , no_argument, 0, ATHR_GMAC_FLOW_CTRL}, |
| { "swfl" , no_argument, 0, ATHR_PHY_FLOW_CTRL}, |
| { 0,0,0,0} |
| }; |
| |
| |
| while ((c = getopt_long(argc, argv, |
| opt, long_options, &optionindex)) != -1) { |
| switch (c) { |
| case ATHR_FLOW_LINK_EN: |
| cmd = ATHR_FLOW_LINK_EN; |
| break; |
| case ATHR_PHY_TXFCTL: |
| cmd = ATHR_PHY_TXFCTL; |
| break; |
| case ATHR_PHY_RXFCTL: |
| cmd = ATHR_PHY_RXFCTL; |
| break; |
| case ATHR_PHY_MIB: |
| cmd = ATHR_PHY_MIB; |
| break; |
| case ATHR_GMAC_STATS: |
| cmd = ATHR_GMAC_STATS; |
| break; |
| case ATHR_GMAC_DMA_CHECK: |
| cmd = ATHR_GMAC_DMA_CHECK; |
| break; |
| case ATHR_QOS_ETH_SOFT_CLASS: |
| cmd = ATHR_QOS_ETH_SOFT_CLASS; |
| break; |
| case ATHR_QOS_ETH_PORT: |
| cmd = ATHR_QOS_ETH_PORT; |
| break; |
| case ATHR_QOS_ETH_VLAN: |
| cmd = ATHR_QOS_ETH_VLAN; |
| break; |
| case ATHR_QOS_ETH_IP: |
| cmd = ATHR_QOS_ETH_IP; |
| break; |
| case ATHR_QOS_ETH_DA: |
| cmd = ATHR_QOS_ETH_DA; |
| break; |
| case ATHR_PORT_STATS: |
| cmd = ATHR_PORT_STATS; |
| break; |
| case ATHR_QOS_PORT_ELIMIT: |
| cmd = ATHR_QOS_PORT_ELIMIT; |
| break; |
| case ATHR_QOS_PORT_ILIMIT: |
| cmd = ATHR_QOS_PORT_ILIMIT; |
| break; |
| case ATHR_GMAC_FLOW_CTRL: |
| cmd = ATHR_GMAC_FLOW_CTRL; |
| break; |
| case ATHR_PHY_FLOW_CTRL: |
| cmd = ATHR_PHY_FLOW_CTRL; |
| break; |
| case 'm': |
| mac = optarg; |
| break; |
| case 'v': |
| value = strtoul(optarg, 0, 0); |
| break; |
| case 'i': |
| ifname = optarg; |
| break; |
| case 't': |
| tos = strtoul(optarg, 0, 0); |
| break; |
| case 'p': |
| portnum = strtoul(optarg, 0, 0); |
| break; |
| case 'f': |
| opt_force = 1; |
| break; |
| case 'd': |
| duplex = strtoul(optarg, 0, 0); |
| break; |
| case 'c': |
| cmd = ATHR_ACL_COMMIT; |
| break; |
| case 'x': |
| cmd = ATHR_ACL_FLUSH; |
| break; |
| case 's': |
| cmd = ATHR_FRAME_SIZE_CTL; |
| value = strtoul(optarg, 0, 0); |
| break; |
| case 'j': |
| cmd = ATHR_JUMBO_FRAME; |
| value = strtoul(optarg, 0, 0); |
| break; |
| case 'l': |
| vlanid = strtoul (optarg, 0, 0); |
| break; |
| case 'h': |
| usage(); |
| break; |
| default: |
| usage(); |
| /*NOTREACHED*/ |
| } |
| |
| } |
| |
| argc -= optind; |
| argv += optind; |
| strncpy(etd.ad_name, ifname, sizeof (etd.ad_name)); |
| strncpy(ifr.ifr_name, ifname, IFNAMSIZ); |
| ifr.ifr_data = (void *) &etd; |
| |
| if (cmd == ATHR_ACL_COMMIT) { |
| athr_commit_acl_rules(); |
| return 0; |
| } |
| else if (cmd == ATHR_ACL_FLUSH) { |
| athr_flush_acl_rules(); |
| return 0; |
| } |
| else if(cmd == ATHR_FRAME_SIZE_CTL) { |
| if (value == -1) { |
| printf ("usage:ethreg -i <if_name> -s <val>\n"); |
| return -1; |
| } else { |
| athr_set_framesize(value); |
| } |
| return 0; |
| } |
| else if (cmd == ATHR_JUMBO_FRAME) { |
| if (value == -1) { |
| printf ("usage: ethreg -i <if_name> -j <0|1>\n"); |
| return -1; |
| } else { |
| athr_en_jumboframe(value); |
| } |
| return 0; |
| } |
| else if (cmd == ATHR_FLOW_LINK_EN) { |
| if (value == -1 || portnum == 0x3f) { |
| printf ("usage: ethreg --f_link -i <ifname> -p <portnum> -v 1\n"); |
| return -1; |
| } else { |
| athr_flow_link(portnum, value); |
| } |
| return 0; |
| } |
| else if (cmd == ATHR_PHY_RXFCTL) { |
| if (value == -1) { |
| printf ("usage: ethreg --rxfctl -i <ifname> -p <portnum> -v [0|1]\n"); |
| printf ("usage: ethreg --rxfctl -i <ifname> -v [0|1]\n"); |
| return -1; |
| } else { |
| athr_rxflctrl(portnum, value); |
| } |
| return 0; |
| } |
| else if (cmd == ATHR_PHY_TXFCTL) { |
| if (value == -1) { |
| printf ("usage: ethreg --txfctl -i <ifname> -p <portnum> -v [0|1]\n"); |
| printf ("usage: ethreg --txfctl -i <ifname> -v [0|1]\n"); |
| return -1; |
| } else { |
| athr_txflctrl(portnum, value); |
| } |
| return 0; |
| } |
| else if (cmd == ATHR_PHY_MIB) { |
| if (value == -1) { |
| printf ("usage: ethreg --mib -i <ifname> -v 1\n"); |
| return -1; |
| } else { |
| athr_set_mib(value); |
| } |
| return 0; |
| } |
| else if (cmd == ATHR_GMAC_STATS) { |
| athr_disp_stats(portnum); |
| return 0; |
| } |
| else if (cmd == ATHR_GMAC_DMA_CHECK) { |
| if (value == -1) { |
| printf ("usage: ethreg --dma -i <ifname> -v [0|1]\n"); |
| return -1; |
| } else { |
| athr_dma_check(value); |
| } |
| return 0; |
| } |
| else if (cmd == ATHR_QOS_ETH_SOFT_CLASS) { |
| if (value == -1) { |
| printf ("usage: ethreg --qos -i <ifname> -v [0|1]\n"); |
| return -1; |
| } else { |
| athr_set_qos(value); |
| } |
| return 0; |
| |
| } |
| else if (cmd == ATHR_QOS_ETH_PORT) { |
| if (value == -1) { |
| printf("usage: ethreg --ppri -i <ifname> -p <portno> -v <val>\n"); |
| return -1; |
| } else { |
| athr_set_port_pri(portnum, value); |
| } |
| return 0; |
| } |
| else if (cmd == ATHR_QOS_ETH_IP) { |
| if (tos == -1 || value == -1) { |
| printf ("usage: ethreg --ipqos -i <ifname> -v <val> -t <tos>\n"); |
| return -1; |
| } else { |
| athr_ip_qos(tos, value); |
| } |
| return 0; |
| } |
| else if (cmd == ATHR_QOS_ETH_VLAN) { |
| if (value == -1 || vlanid == -1) { |
| printf ("usage: ethreg --vqos -i <ifname> -v <val> -l <vlanid>\n"); |
| return -1; |
| } else { |
| athr_vlan_qos(vlanid, value); |
| |
| } |
| return 0; |
| } |
| else if (cmd == ATHR_QOS_ETH_DA) { |
| if (portnum == 0x3f || value == -1 || mac == NULL) { |
| printf ("usage: ethreg --mqos -i <ifname> -v <val> -p <portnum> -m <macaddr>\n"); |
| return -1; |
| } else { |
| athr_mac_qos(portnum, value, mac); |
| } |
| return 0; |
| } |
| else if (cmd == ATHR_PORT_STATS) { |
| if (portnum == 0x3f) { |
| printf ("usage: ethreg --port_st -i <ifname> -p <portno>\n"); |
| return -1; |
| } else { |
| athr_port_st(portnum); |
| } |
| return 0; |
| } |
| else if (cmd == ATHR_QOS_PORT_ELIMIT) { |
| if (portnum == 0x3f || value == -1 ) { |
| printf("usage: ethreg --egrl -i <ifname> -p <portnum> -v <val>\n"); |
| return -1; |
| } else { |
| athr_process_egress(portnum, value); |
| } |
| return 0; |
| } |
| else if (cmd == ATHR_QOS_PORT_ILIMIT) { |
| if (portnum == 0x3f || value == -1 ) { |
| printf("usage: ethreg --igrl -i <ifname> -p <portnum> -v <val>\n"); |
| return -1; |
| } else { |
| athr_process_igress(portnum, value); |
| } |
| return 0; |
| } |
| else if (cmd == ATHR_GMAC_FLOW_CTRL){ |
| athr_gmac_flow_ctrl(value); |
| return 0; |
| } |
| else if (cmd == ATHR_PHY_FLOW_CTRL){ |
| athr_phy_flow_ctrl(value, portnum); |
| return 0; |
| } |
| |
| for (; argc > 0; argc--, argv++) { |
| u_int32_t off; |
| u_int32_t val, oval; |
| char *cp; |
| |
| cp = strchr(argv[0], '='); |
| |
| if (cp != NULL) |
| *cp = '\0'; |
| |
| off = (u_int) strtoul(argv[0], 0, 0); |
| |
| if (off == 0 && errno == EINVAL) |
| errx(1, "%s: invalid reg offset %s", |
| progname, argv[0]); |
| |
| if (cp == NULL) { |
| val = regread(off,portnum); |
| printf("Read Reg: 0x%08x = 0x%08x\n",off, val); |
| return 0; |
| } else { |
| val = (u_int32_t) strtoul(cp+1, 0, 0); |
| if (val == 0 && errno == EINVAL) { |
| errx(1, "%s: invalid reg value %s", |
| progname, cp+1); |
| } |
| else { |
| oval = regread(off,portnum); |
| if(opt_force == 0) { |
| printf("Write Reg: 0x%08x: Oldval = 0x%08x Newval = 0x%08x\n", off, oval, val); |
| |
| } else if(opt_force == 1 && portnum == 0x3f) { |
| fprintf(stderr, "usage: %s [-f] -p portnum =10/100/0 [-d duplex]\n", progname); |
| return -1; |
| } |
| regwrite(off,val,portnum); |
| } |
| } |
| } |
| return 0; |
| } |
| |
