devbox
我家自动化
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

AM335x网络分析+KSZ9031分析（uboot中ping不通问题）_am335x 网口

作者：我家自动化 | 2024-02-14 21:19:35

赞

踩

am335x 网口

问题背景：

       手头上的任务是将eboot中添加ping外部网的功能，所以就直接从uboot上把ping命令那部分拿过来调试，am335x内部自带mac，ksz9031是phy，目前主板可以设置ksz9031，也就是说mdio是没问题的，然后用的是通用的cpsw网卡驱动，用的cpdma传输，目前死活ping不通，10/100/1000速度下都试过，自动协商也没问题，感觉卡在cpdma那边，没有输出传出去的感觉，想不用dma直接输出数据，不知道如何下手。经过几个星期的折腾终于解决了，问题出在大小端函数和实虚地址上面。

分析：

       AM335x硬件资源上可以支持两个双网口，网口是GMII,RGMII,RMII接口的10/100/1000以太网端口；

       首先来看下它的网络子系统结构图

               

                                                                                        图1 AM335x网络子系统结构图

        网络子系统的核心就是这个CPSW_3G的模块。它是个是么结构呢，我的理解他就是的多路选择器，这个模块有3个接口，分别为PORT0,PORT1,PORT2。其中PORT0接口的接口类型是CPPI型，它连接内部DMA，构成网络特有的DMA通道叫做CPDMA。还有两个接口PORT1和PORT2是对外的，他们的接口类型可以选择为GMII,RGMII,RMII这三种中的任意一个，这个有相应的寄存器可以配置的。简单的描述下就是下面这个结构

                                                          

                                                                                     图2 AM335x网络子系统简化图

再接着看图1，在uboot中并没有用到中断，采用的是轮询的方式，所以中断int部分暂时不用。系统时钟PRCM的配置，千兆网模式下的时钟是125MHZ，百兆网口需要25MHZ，十兆需要2.5MHZ。Control Moudle中的GMII_SEL，就是图中左下方那块的作用是选择接口模式，也就是将PORT1和PORT2选择为GMII,RGMII,RMII其中一种类型。再往下SCR就是各种配置寄存器了，这个对着TI手册查看即可，再往下有一个特别重要的点，MDIO模块。这里我们要阐述下网卡的概念，网卡是由两部分构成的，一部分是mac，一部分是phy，mac提供mac地址和链路接口，phy用于物理信号的生成接收。一般的像常用的DM9000网卡中这两部分都是集成的。也有些芯片像AM335x，它内部自带mac部分（上面分析的部分），这个时候外部就只需要接phy芯片就行，接口方式就是上面说的GMII,RGMII,RMII。我用的phy芯片是KSZ9031，用的接口方式是RGMII。  phy芯片是需要配置的，而这个配置的专用线就是MDIO，它和IIC比较类似，一根CLK,一根DATA。但它据说比IIC快，具体为什么，没有分析，可能他是专用吧，IIC比较通用。因此它们的连接简图如图3所示：

                                                        

                                                                               图3  AM335x网络连接简图

ok，进入正题之前先对网络系统进行初始化：

      初始化过程1，对于phy芯片的初始化Uboot中在board/ti/am335x/board.c或者evm.c中会对phy进行初始化最终通用的phy.c（通用的都是phy，也有些特定的，按情况而定）中的一些初始化配置。

  1. eth_register(dev);
  2. cpsw_mdio_init(name, mdio_base, mdio_div);
  3. bus = miiphy_get_dev_by_name(name);
  4. for_active_slave(slave, priv)
  5.     cpsw_phy_init(dev, slave);

      初始化过程2，对于am335x内部网络模块的初始化。这部分内容在ti的通用网络驱动文件cpsw.c中，Cpsw.c是一个通用的网络驱动，所有的配置，收发的最终实现都在这里面对于AM335X内部网络模块的初始化分为两部分，一部分是mac模块的配置（对照寄存器表一一配置）。另外一部分是对于DMA配置。

初始化过程有个博客讲解的比较好，我直接复制过来了（也添加了一点自己的分析），我有点懒：我会接着他后面详解这个发送流程。

原博客地址是 
https://blog.csdn.net/hahachenchen789/article/details/53339181

转载开始：（一直到下面转载结束）

  1. static int cpsw_init(struct eth_device *dev, bd_t *bis)
  2. {
  3. 	struct cpsw_priv	*priv = dev->priv;
  4. 	struct cpsw_slave	*slave;
  5. 	int i, ret;
  6.  
  7. 	/* soft reset the controller and initialize priv */
  8. 	setbit_and_wait_for_clear32(&priv->regs->soft_reset);
  9.  
  10. 	/* initialize and reset the address lookup engine */
  11. 	cpsw_ale_enable(priv, 1);
  12. 	cpsw_ale_clear(priv, 1);
  13. 	cpsw_ale_vlan_aware(priv, 0); /* vlan unaware mode */
  14.  
  15. 	/* setup host port priority mapping */
  16. 	__raw_writel(0x76543210, &priv->host_port_regs->cpdma_tx_pri_map);
  17. 	__raw_writel(0, &priv->host_port_regs->cpdma_rx_chan_map);
  18.  
  19. 	/* disable priority elevation and enable statistics on all ports */
  20. 	__raw_writel(0, &priv->regs->ptype);
  21.  
  22. 	/* enable statistics collection only on the host port */
  23. 	__raw_writel(BIT(priv->host_port), &priv->regs->stat_port_en);
  24.  
  25. 	cpsw_ale_port_state(priv, priv->host_port, ALE_PORT_STATE_FORWARD);
  26.  
  27. 	cpsw_ale_add_ucast(priv, priv->dev->enetaddr, priv->host_port,
  28. 			   ALE_SECURE);
  29. 	cpsw_ale_add_mcast(priv, NetBcastAddr, 1 << priv->host_port);
  30.  
  31. 	for_each_slave(slave, priv)
  32. 		cpsw_slave_init(slave, priv);
  33.  
  34. 	cpsw_update_link(priv);
  35.  
  36. 	/* init descriptor pool */  提交DMA描述符，实际上就是提供描述符链表，先把这个链表构造在这，每有一次数据传输就往里面填值。
  37. 	for (i = 0; i < NUM_DESCS; i++) {
  38. 		desc_write(&priv->descs[i], hw_next,
  39. 			   (i == (NUM_DESCS - 1)) ? 0 : &priv->descs[i+1]);
  40. 	}
  41. 	priv->desc_free = &priv->descs[0];
  42.  
  43. 	/* initialize channels */
  44. 	if (priv->data.version == CPSW_CTRL_VERSION_2) {
  45. 		memset(&priv->rx_chan, 0, sizeof(struct cpdma_chan));
  46. 		priv->rx_chan.hdp       = priv->dma_regs + CPDMA_RXHDP_VER2;
  47. 		priv->rx_chan.cp        = priv->dma_regs + CPDMA_RXCP_VER2;
  48. 		priv->rx_chan.rxfree    = priv->dma_regs + CPDMA_RXFREE;
  49.  
  50. 		memset(&priv->tx_chan, 0, sizeof(struct cpdma_chan));
  51. 		priv->tx_chan.hdp       = priv->dma_regs + CPDMA_TXHDP_VER2;
  52. 		priv->tx_chan.cp        = priv->dma_regs + CPDMA_TXCP_VER2;
  53. 	} else {
  54. 		memset(&priv->rx_chan, 0, sizeof(struct cpdma_chan));
  55. 		priv->rx_chan.hdp       = priv->dma_regs + CPDMA_RXHDP_VER1;
  56. 		priv->rx_chan.cp        = priv->dma_regs + CPDMA_RXCP_VER1;
  57. 		priv->rx_chan.rxfree    = priv->dma_regs + CPDMA_RXFREE;
  58.  
  59. 		memset(&priv->tx_chan, 0, sizeof(struct cpdma_chan));
  60. 		priv->tx_chan.hdp       = priv->dma_regs + CPDMA_TXHDP_VER1;
  61. 		priv->tx_chan.cp        = priv->dma_regs + CPDMA_TXCP_VER1;
  62. 	}
  63.  
  64. 	/* clear dma state */
  65. 	setbit_and_wait_for_clear32(priv->dma_regs + CPDMA_SOFTRESET);
  66.  
  67. 	if (priv->data.version == CPSW_CTRL_VERSION_2) {
  68. 		for (i = 0; i < priv->data.channels; i++) {
  69. 			__raw_writel(0, priv->dma_regs + CPDMA_RXHDP_VER2 + 4
  70. 					* i);
  71. 			__raw_writel(0, priv->dma_regs + CPDMA_RXFREE + 4
  72. 					* i);
  73. 			__raw_writel(0, priv->dma_regs + CPDMA_RXCP_VER2 + 4
  74. 					* i);
  75. 			__raw_writel(0, priv->dma_regs + CPDMA_TXHDP_VER2 + 4
  76. 					* i);
  77. 			__raw_writel(0, priv->dma_regs + CPDMA_TXCP_VER2 + 4
  78. 					* i);
  79. 		}
  80. 	} else {
  81. 		for (i = 0; i < priv->data.channels; i++) {
  82. 			__raw_writel(0, priv->dma_regs + CPDMA_RXHDP_VER1 + 4
  83. 					* i);
  84. 			__raw_writel(0, priv->dma_regs + CPDMA_RXFREE + 4
  85. 					* i);
  86. 			__raw_writel(0, priv->dma_regs + CPDMA_RXCP_VER1 + 4
  87. 					* i);
  88. 			__raw_writel(0, priv->dma_regs + CPDMA_TXHDP_VER1 + 4
  89. 					* i);
  90. 			__raw_writel(0, priv->dma_regs + CPDMA_TXCP_VER1 + 4
  91. 					* i);
  92.  
  93. 		}
  94. 	}
  95.  
  96. 	__raw_writel(1, priv->dma_regs + CPDMA_TXCONTROL);
  97. 	__raw_writel(1, priv->dma_regs + CPDMA_RXCONTROL);
  98.  
  99. 	/* submit rx descs */
  100. 	for (i = 0; i < PKTBUFSRX; i++) {
  101. 		ret = cpdma_submit(priv, &priv->rx_chan, NetRxPackets[i],
  102. 				   PKTSIZE);
  103. 		if (ret < 0) {
  104. 			printf("error %d submitting rx desc\n", ret);
  105. 			break;
  106. 		}
  107. 	}
  108.  
  109. 	return 0;
  110. }

 

首先是声明几个结构体变量，其中包括cpsw的主：cpsw_priv和cpsw_slave，然后是设置cpsw的基础寄存器的地址cpsw_base，然后调用calloc函数为这些结构体分配空间。

分配好后对priv结构体中的成员进行初始化，host_port=0表示主机端口号是0，然后成员的寄存器的偏移地址进行初始化。

  1. host_port       = host_port_num;
  2. regs        = regs;
  3. host_port_regs  = regs + host_port_reg_ofs;
  4. dma_regs        = regs + cpdma_reg_ofs;
  5. ale_regs        = regs + ale_reg_ofs;
  6. descs       = (void *)regs + bd_ram_ofs;

对每个salve进行初始化，这里采用for循环的意义在于可能有多个网卡，am335x支持双网卡。

  1. for_each_slave(slave, priv) {
  2.     cpsw_slave_setup(slave, idx, priv);
  3.     idx = idx + 1;
  4. }

以mdio方式对网卡配置进行初始化：主要是调用cpsw_phy_init函数进行初始化

  1. eth_register(dev);
  2. cpsw_mdio_init(name, mdio_base, mdio_div);
  3. bus = miiphy_get_dev_by_name(name);
  4. for_active_slave(slave, priv)
  5.     cpsw_phy_init(dev, slave);

cpsw_phy_init函数定义：

  1. static int cpsw_phy_init(struct eth_device *dev, struct cpsw_slave *slave)
  2. {
  3.     struct cpsw_priv *priv = (struct cpsw_priv *)priv;
  4.     struct phy_device *phydev;
  5.     u32 supported = PHY_GBIT_FEATURES;
  6.     printf("cpsw_phy_init \n");
  7.     printf("phy_addr:%d \n", phy_addr);
  8.     phydev = phy_connect(bus, phy_addr,
  9.             dev, phy_if);
  10.  
  11.     if (!phydev)
  12.         return -1;
  13.  
  14.     phydev->supported= supported;
  15.     phydev->advertising = phydev->supported;
  16.  
  17.     priv->phydev = phydev;
  18.     phy_config(phydev);
  19.  
  20.     return 1;
  21. }

该函数调用phy_connect函数连接网卡，返回的值如果合理就调用phy_config函数对该网卡进行配置，主要是配置网卡的速率和半双工。

首先分析phy_connect函数：

  1. struct phy_device *phy_connect(struct mii_dev *bus, int addr,
  2.         struct eth_device *dev, phy_interface_t interface)
  3. {
  4.     struct phy_device *phydev;
  5.     phydev = phy_find_by_mask(bus, addr, interface);
  6.     if (phydev)
  7.         phy_connect_dev(phydev, dev);
  8.     else
  9.         printf("Could not get PHY for %s: addr %d\n", bus-&gt;name, addr);
  10.     return phydev;
  11. }

该函数首先调用phy_find_by_mask函数查询网卡设备，如果存在则调用phy_connect_dev函数连接，否则就打印出错信息

phy_connect_dev函数实现：

  1. struct phy_device *phy_find_by_mask(struct mii_dev *bus, unsigned phy_mask,
  2.         phy_interface_t interface)
  3. {
  4.     /* Reset the bus */
  5.     if (bus->reset) {
  6.         bus->reset(bus);
  7.  
  8.         /* Wait 15ms to make sure the PHY has come out of hard reset */
  9.         udelay(15000);
  10.     }
  11.  
  12.     return get_phy_device_by_mask(bus, phy_mask, interface);
  13. }

该函数主要是调用get_phy_device_by_mask函数进行设备的查找，get_phy_device_by_mask函数的实现至关重要，包含了对于网卡的主要mdio通信

get_phy_device_by_mask函数实现：

  1. static struct phy_device *get_phy_device_by_mask(struct mii_dev *bus,
  2.         unsigned phy_mask, phy_interface_t interface)
  3. {
  4.     int i;
  5.     struct phy_device *phydev;
  6.  
  7.     phydev = search_for_existing_phy(bus, phy_mask, interface);
  8.     if (phydev)
  9.         return phydev;
  10.     /* Try Standard (ie Clause 22) access */
  11.     /* Otherwise we have to try Clause 45 */
  12.     for (i = 0; i < 5; i++) {
  13.         phydev = create_phy_by_mask(bus, phy_mask,
  14.                 i ? i : MDIO_DEVAD_NONE, interface);
  15.         if (IS_ERR(phydev))
  16.             return NULL;
  17.         if (phydev)
  18.             return phydev;
  19.     }
  20.     printf("Phy %d not found\n", ffs(phy_mask) - 1);
  21.     return phy_device_create(bus, ffs(phy_mask) - 1, 0xffffffff, interface);
  22. }

该函数首先调用search_for_existing_phy函数查找当前存在的设备，如果存在则将该设备返回，不存在则调用create_phy_by_mask函数进行创建。 
search_for_existing_phy函数实现：

  1. static struct phy_device *search_for_existing_phy(struct mii_dev *bus,
  2.         unsigned phy_mask, phy_interface_t interface)
  3. {
  4.     /* If we have one, return the existing device, with new interface */
  5.     while (phy_mask) {
  6.         int addr = ffs(phy_mask) - 1;
  7.         if (bus->phymap[addr]) {
  8.             bus->phymap[addr]->interface = interface;
  9.             return bus->phymap[addr];
  10.         }
  11.         phy_mask &= ~(1 << addr);
  12.     }
  13.     return NULL;
  14. }

create_phy_by_mask函数实现：

  1. static struct phy_device *create_phy_by_mask(struct mii_dev *bus,
  2.         unsigned phy_mask, int devad, phy_interface_t interface)
  3. {
  4.     u32 phy_id = 0xffffffff;
  5.     while (phy_mask) {
  6.         int addr = ffs(phy_mask) - 1;
  7.         int r = get_phy_id(bus, addr, devad, &phy_id);
  8.         /* If the PHY ID is mostly f's, we didn't find anything */
  9.         if (r == 0 && (phy_id & 0x1fffffff) != 0x1fffffff)
  10.             return phy_device_create(bus, addr, phy_id, interface);
  11.         phy_mask &= ~(1 << addr);
  12.     }
  13.     return NULL;
  14. }

该函数调用get_phy_id函数让处理器通过mdio总线查看网卡寄存器存储的ID，如果ID都是f，说明没有ID，就返回空，否则返回phy_device_create函数进行创建一个网卡设备。 
get_phy_id函数实现：

  1. int __weak get_phy_id(struct mii_dev *bus, int addr, int devad, u32 *phy_id)
  2. {
  3.     int phy_reg;
  4.  
  5.     /* Grab the bits from PHYIR1, and put them
  6.      * in the upper half */
  7.     phy_reg = bus->read(bus, addr, devad, MII_PHYSID1);
  8.  
  9.     if (phy_reg < 0)
  10.         return -EIO;
  11.  
  12.     *phy_id = (phy_reg & 0xffff) << 16;
  13.  
  14.     /* Grab the bits from PHYIR2, and put them in the lower half */
  15.     phy_reg = bus-&gt;read(bus, addr, devad, MII_PHYSID2);
  16.  
  17.     if (phy_reg < 0)
  18.         return -EIO;
  19.  
  20.     *phy_id |= (phy_reg & 0xffff);
  21.  
  22.     return 0;
  23. }

该函数就调用了bus->read总线读函数，来读取网卡寄存器的值，这里是读取寄存器存储的网卡ID，bus->read函数定义为cpsw_mdio_read，cpsw_mdio_read实现：

  1. static int cpsw_mdio_read(struct mii_dev *bus, int phy_id,
  2.                 int dev_addr, int phy_reg)
  3. {
  4.     int data;
  5.     u32 reg;
  6.     printf("cpsw_mdio_read \n");
  7.     printf("phy_id %d\n",phy_id);
  8.     if (phy_reg & ~PHY_REG_MASK || phy_id & ~PHY_ID_MASK)
  9.         return -EINVAL;
  10.  
  11.     wait_for_user_access();
  12.     reg = (USERACCESS_GO | USERACCESS_READ | (phy_reg << 21) |
  13.            (phy_id << 16));
  14.     __raw_writel(reg, &mdio_regs->user[0].access);
  15.     reg = wait_for_user_access();
  16.  
  17.     data = (reg & USERACCESS_ACK) ? (reg & USERACCESS_DATA) : -1;
  18.     return data;
  19. }

该函数调用wait_for_user_access函数来等待能否读取寄存器信号，当标志位表示能够access时，将reg的值写到&mdio_regs->user[0].access寄存器，reg包含了想要读的寄存器的变量，然后继续调用wait_for_user_access函数等待数据完成，将wait_for_user_access函数的返回值给reg，想要读寄存器的data就等于(reg & USERACCESS_ACK) ? (reg & USERACCESS_DATA) : -1; 然后返回data，就完成了mdio对于网卡寄存器的读取。

看看wait_for_user_access函数的实现：

  1. static inline u32 wait_for_user_access(void)
  2. {
  3.     u32 reg = 0;
  4.     int timeout = MDIO_TIMEOUT;
  5.  
  6.     while (timeout-- &&
  7.     ((reg = __raw_readl(&mdio_regs->user[0].access)) & USERACCESS_GO))
  8.         udelay(10);
  9.  
  10.     if (timeout == -1) {
  11.         printf("wait_for_user_access Timeout\n");
  12.         return -ETIMEDOUT;
  13.     }
  14.     return reg;
  15. }

可以看出，这里用了一个while循环，等待100个机器周期来读取网卡寄存器的值。

以上就是cpsw的注册和网卡设备的mdio连接。 
接下来分析最重要的cpsw_init函数，包含了ALE、DMA、cpsw_slave的初始化和配置。

cpsw_init函数实现：

  1. static int cpsw_init(struct eth_device *dev, bd_t *bis)
  2. {
  3.     struct cpsw_priv    *priv = dev-&gt;priv;
  4.     struct cpsw_slave   *slave;
  5.     int i, ret;
  6.     printf("cpsw_init func\n");
  7.     /* soft reset the controller and initialize priv */
  8.     setbit_and_wait_for_clear32(&priv->regs->soft_reset);
  9.  
  10.     /* initialize and reset the address lookup engine */
  11.     cpsw_ale_enable(priv, 1);
  12.     cpsw_ale_clear(priv, 1);
  13.     cpsw_ale_vlan_aware(priv, 0); /* vlan unaware mode */
  14.  
  15.     /* setup host port priority mapping */
  16.     __raw_writel(0x76543210, &priv->host_port_regs->cpdma_tx_pri_map);
  17.     __raw_writel(0, &priv->host_port_regs->cpdma_rx_chan_map);
  18.  
  19.     /* disable priority elevation and enable statistics on all ports */
  20.     __raw_writel(0, &priv->regs->ptype);
  21.  
  22.     /* enable statistics collection only on the host port */
  23.     __raw_writel(BIT(priv->host_port), &priv->regs->stat_port_en);
  24.     __raw_writel(0x7, &priv->regs->stat_port_en);
  25.     printf("&priv->regs->stat_port_en:%x\n", &priv->regs->stat_port_en);
  26.      printf("priv->regs->stat_port_en:%x\n", priv->regs->stat_port_en);
  27.  
  28.     cpsw_ale_port_state(priv, priv->host_port, ALE_PORT_STATE_FORWARD);
  29.  
  30.     //cpsw_ale_add_ucast(priv, priv->dev->enetaddr, priv->host_port, ALE_SECURE);
  31.     //cpsw_ale_add_mcast(priv, net_bcast_ethaddr, 1 << priv->host_port);
  32.  
  33.     for_active_slave(slave, priv)
  34.         cpsw_slave_init(slave, priv);
  35.  
  36.     cpsw_update_link(priv);
  37.  
  38.     /* init descriptor pool */
  39.     for (i = 0; i < NUM_DESCS; i++) {
  40.         desc_write(&priv->descs[i], hw_next,
  41.                (i == (NUM_DESCS - 1)) ? 0 : &priv->descs[i+1]);
  42.     }
  43.     priv->desc_free = &priv->descs[0];
  44.     printf("&priv->descs[0]:%x\n", &priv->descs[0]);
  45.     printf("priv->dma_regs + CPDMA_RXHDP_VER2:%x\n",priv->dma_regs + CPDMA_RXHDP_VER2);
  46.  
  47.     /* initialize channels */
  48.     if (priv->data.version == CPSW_CTRL_VERSION_2) {
  49.         memset(&priv->rx_chan, 0, sizeof(struct cpdma_chan));
  50.         priv->rx_chan.hdp       = priv->dma_regs + CPDMA_RXHDP_VER2;
  51.         priv->rx_chan.cp        = priv->dma_regs + CPDMA_RXCP_VER2;
  52.         priv->rx_chan.rxfree    = priv->dma_regs + CPDMA_RXFREE;
  53.  
  54.         memset(&priv->tx_chan, 0, sizeof(struct cpdma_chan));
  55.         priv->tx_chan.hdp       = priv->dma_regs + CPDMA_TXHDP_VER2;
  56.         priv->tx_chan.cp        = priv->dma_regs + CPDMA_TXCP_VER2;
  57.     } else {
  58.         memset(&priv->rx_chan, 0, sizeof(struct cpdma_chan));
  59.         priv->rx_chan.hdp       = priv->dma_regs + CPDMA_RXHDP_VER1;
  60.         priv->rx_chan.cp        = priv->dma_regs + CPDMA_RXCP_VER1;
  61.         priv->rx_chan.rxfree    = priv->dma_regs + CPDMA_RXFREE;
  62.  
  63.         memset(&priv->tx_chan, 0, sizeof(struct cpdma_chan));
  64.         priv->tx_chan.hdp       = priv->dma_regs + CPDMA_TXHDP_VER1;
  65.         priv->tx_chan.cp        = priv->dma_regs + CPDMA_TXCP_VER1;
  66.     }
  67.  
  68.     /* clear dma state */
  69.     setbit_and_wait_for_clear32(priv-&gt;dma_regs + CPDMA_SOFTRESET);
  70.  
  71.     if (priv-&gt;data.version == CPSW_CTRL_VERSION_2) {
  72.         for (i = 0; i < priv->data.channels; i++) {
  73.             __raw_writel(0, priv->dma_regs + CPDMA_RXHDP_VER2 + 4
  74.                     * i);
  75.             __raw_writel(0, priv->dma_regs + CPDMA_RXFREE + 4
  76.                     * i);
  77.             __raw_writel(0, priv->dma_regs + CPDMA_RXCP_VER2 + 4
  78.                     * i);
  79.             __raw_writel(0, priv->dma_regs + CPDMA_TXHDP_VER2 + 4
  80.                     * i);
  81.             __raw_writel(0, priv->dma_regs + CPDMA_TXCP_VER2 + 4
  82.                     * i);
  83.         }
  84.     } else {
  85.         for (i = 0; i < priv->data.channels; i++) {
  86.             __raw_writel(0, priv->dma_regs + CPDMA_RXHDP_VER1 + 4
  87.                     * i);
  88.             __raw_writel(0, priv->dma_regs + CPDMA_RXFREE + 4
  89.                     * i);
  90.             __raw_writel(0, priv->dma_regs + CPDMA_RXCP_VER1 + 4
  91.                     * i);
  92.             __raw_writel(0, priv->dma_regs + CPDMA_TXHDP_VER1 + 4
  93.                     * i);
  94.             __raw_writel(0, priv->dma_regs + CPDMA_TXCP_VER1 + 4
  95.                     * i);
  96.  
  97.         }
  98.     }
  99.  
  100.     __raw_writel(1, priv->dma_regs + CPDMA_TXCONTROL);
  101.     __raw_writel(1, priv->dma_regs + CPDMA_RXCONTROL);
  102.  
  103.     /* submit rx descs */
  104.     for (i = 0; i < PKTBUFSRX; i++) {
  105.         ret = cpdma_submit(priv, &priv->rx_chan, net_rx_packets[i],
  106.                    PKTSIZE);
  107.         if (ret < 0) {
  108.             printf("error %d submitting rx desc\n", ret);
  109.             break;
  110.         }
  111.     }
  112.  
  113.     return 0;
  114. }

首先是ALE的初始化： 
ALE：address lookup engine 地址查询引擎，是TI创造的一种对于双网卡选择的方式：

  1. /* initialize and reset the address lookup engine */
  2.     cpsw_ale_enable(priv, 1);
  3.     cpsw_ale_clear(priv, 1);
  4.     cpsw_ale_vlan_aware(priv, 0); /* vlan unaware mode */

这三个函数的实现都在cpsw.c文件中，都是向相应的ale寄存器中写值，目的是为了使能ale引擎，并开启vlan（虚拟局域网）

贴出代码，但不具体解释：

  1. #define cpsw_ale_enable(priv, val)  cpsw_ale_control(priv, 31, val)
  2. #define cpsw_ale_clear(priv, val)   cpsw_ale_control(priv, 30, val)
  3. #define cpsw_ale_vlan_aware(priv, val)  cpsw_ale_control(priv,  2, val)
  4.  
  5. static inline void cpsw_ale_control(struct cpsw_priv *priv, int bit, int val)
  6. {
  7.     u32 tmp, mask = BIT(bit);
  8.  
  9.     tmp  = __raw_readl(priv->ale_regs + ALE_CONTROL);
  10.     tmp &= ~mask;
  11.     tmp |= val ? mask : 0;
  12.     __raw_writel(tmp, priv->ale_regs + ALE_CONTROL);
  13. }

接下来设置端口的初始mapping，也就是设置内存映射，将硬件DMA通道的发送和接收寄存器的硬件地址映射到内存空间，这样就可通过访问和修改内存地址内容来修改相应硬件配置：

  1. /* setup host port priority mapping */
  2.     __raw_writel(0x76543210, &priv->host_port_regs->cpdma_tx_pri_map);
  3.     __raw_writel(0, &priv->host_port_regs->cpdma_rx_chan_map);
  4.  
  5.     /* disable priority elevation and enable statistics on all ports */
  6.     __raw_writel(0, &priv->regs->ptype);
  7.  
  8.     /* enable statistics collection only on the host port */
  9.     __raw_writel(BIT(priv->host_port), &priv->regs->stat_port_en);
  10.     __raw_writel(0x7, &priv->regs->stat_port_en);

接着，初始化cpsw的slave，也就是网卡部分，具体实现在cpsw_slave_init函数，待会再分析。

  1. for_active_slave(slave, priv)
  2.         cpsw_slave_init(slave, priv);

接着是cpsw_update_link函数，该函数是刷新与网卡的连接，确保能够通信。 
该函数的实现主要是调用cpsw_slave_update_link函数对slave进行重新初始化连接：

函数实现：

  1. static void cpsw_slave_update_link(struct cpsw_slave *slave,
  2.                    struct cpsw_priv *priv, int *link)
  3. {
  4.     struct phy_device *phy;
  5.     u32 mac_control = 0;
  6.  
  7.     phy = priv->phydev;
  8.  
  9.     if (!phy)
  10.         return;
  11.  
  12.     phy_startup(phy);
  13.     *link = phy->link;
  14.  
  15.     if (*link) { /* link up */
  16.         mac_control = priv->data.mac_control;
  17.         if (phy->speed == 1000)
  18.             mac_control |= GIGABITEN;
  19.         if (phy->duplex == DUPLEX_FULL)
  20.             mac_control |= FULLDUPLEXEN;
  21.         if (phy->speed == 100)
  22.             mac_control |= MIIEN;
  23.     }
  24.  
  25.     if (mac_control == slave->mac_control)
  26.         return;
  27.  
  28.     if (mac_control) {
  29.         printf("link up on port %d, speed %d, %s duplex\n",
  30.                 slave->slave_num, phy->speed,
  31.                 (phy->duplex == DUPLEX_FULL) ? "full" : "half");
  32.     } else {
  33.         printf("link down on port %d\n", slave->slave_num);
  34.     }
  35.  
  36.     __raw_writel(mac_control, &slave->sliver->mac_control);
  37.     slave->mac_control = mac_control;
  38. }

该函数调用phy_startup(phy)进行设备的开启和连接，然后获得数据进行判断，当link为真时，进入if，判断网卡的工作速率是在10M还是100M，工作模式是双工还是单工。并且通过printf打印信息。

 

对于phy_startup函数主要是调用phy.c文件下的genphy_update_link函数和genphy_parse_link函数。

genphy_update_link实现如下：

  1. int genphy_update_link(struct phy_device *phydev)
  2. {
  3.     unsigned int mii_reg;
  4.  
  5.     /*
  6.      * Wait if the link is up, and autonegotiation is in progress
  7.      * (ie - we're capable and it's not done)
  8.      */
  9.     mii_reg = phy_read(phydev, MDIO_DEVAD_NONE, MII_BMSR);
  10.  
  11.     /*
  12.      * If we already saw the link up, and it hasn't gone down, then
  13.      * we don't need to wait for autoneg again
  14.      */
  15.     if (phydev->link && mii_reg & BMSR_LSTATUS)
  16.         return 0;
  17.  
  18.     if ((mii_reg & BMSR_ANEGCAPABLE) && !(mii_reg & BMSR_ANEGCOMPLETE)) {
  19.         int i = 0;
  20.  
  21.         printf("%s Waiting for PHY auto negotiation to complete",
  22.             phydev->dev->name);
  23.         while (!(mii_reg & BMSR_ANEGCOMPLETE)) {
  24.             /*
  25.              * Timeout reached ?
  26.              */
  27.             if (i > PHY_ANEG_TIMEOUT) {
  28.                 printf(" TIMEOUT !\n");
  29.                 phydev->link = 0;
  30.                 return 0;
  31.             }
  32.  
  33.             if (ctrlc()) {
  34.                 puts("user interrupt!\n");
  35.                 phydev->link = 0;
  36.                 return -EINTR;
  37.             }
  38.  
  39.             if ((i++ % 500) == 0)
  40.                 printf(".");
  41.  
  42.             udelay(1000);   /* 1 ms */
  43.             mii_reg = phy_read(phydev, MDIO_DEVAD_NONE, MII_BMSR);
  44.         }
  45.         printf(" done\n");
  46.         phydev->link = 1;
  47.     } else {
  48.         /* Read the link a second time to clear the latched state */
  49.         mii_reg = phy_read(phydev, MDIO_DEVAD_NONE, MII_BMSR);
  50.  
  51.         if (mii_reg & BMSR_LSTATUS)
  52.             phydev->link = 1;
  53.         else
  54.             phydev->link = 0;
  55.     }
  56.  
  57.     return 0;
  58. }

该函数首先调用phy_read函数来获取BMSR寄存器的值

什么是BMSR，这是网卡的状态寄存器，BMCR是网卡的控制寄存器，一般而言，BMSR供我们读取数据进行判断网卡的状态，而BMCR一般是供我们写入数据进行控制。

下图是该网卡的寄存器表：

如果想要查看各寄存器的定义和每一位的定义，可以到SMSC官网下载文档。

回到函数，当读取到网卡的状态寄存器的值后，开始进行一系列判断

 

if ((mii_reg & BMSR_ANEGCAPABLE) && !(mii_reg & BMSR_ANEGCOMPLETE))这个判断条件是判断网卡是否完成自适应配置，如果完成，打印相应信息。不然的话，第二次读取BMSR寄存器，重新判断一次。

然后是genphy_config函数，该函数是对网卡的信息进行一个读取，比如是否支持千兆网卡，是否支持10M/100M 单工/双工。

函数实现：

  1. int genphy_config(struct phy_device *phydev)
  2. {
  3.     int val;
  4.     u32 features;
  5.  
  6.     /* For now, I'll claim that the generic driver supports
  7.      * all possible port types */
  8.     features = (SUPPORTED_TP | SUPPORTED_MII
  9.             | SUPPORTED_AUI | SUPPORTED_FIBRE |
  10.             SUPPORTED_BNC);
  11.  
  12.     /* Do we support autonegotiation? */
  13.     val = phy_read(phydev, MDIO_DEVAD_NONE, MII_BMSR);
  14.  
  15.     if (val < 0)
  16.         return val;
  17.  
  18.     if (val & BMSR_ANEGCAPABLE)
  19.         features |= SUPPORTED_Autoneg;
  20.  
  21.     if (val & BMSR_100FULL)
  22.         features |= SUPPORTED_100baseT_Full;
  23.     if (val & BMSR_100HALF)
  24.         features |= SUPPORTED_100baseT_Half;
  25.     if (val & BMSR_10FULL)
  26.         features |= SUPPORTED_10baseT_Full;
  27.     if (val & BMSR_10HALF)
  28.         features |= SUPPORTED_10baseT_Half;
  29.  
  30.     if (val & BMSR_ESTATEN) {
  31.         val = phy_read(phydev, MDIO_DEVAD_NONE, MII_ESTATUS);
  32.  
  33.         if (val < 0)
  34.             return val;
  35.  
  36.         if (val & ESTATUS_1000_TFULL)
  37.             features |= SUPPORTED_1000baseT_Full;
  38.         if (val & ESTATUS_1000_THALF)
  39.             features |= SUPPORTED_1000baseT_Half;
  40.         if (val & ESTATUS_1000_XFULL)
  41.             features |= SUPPORTED_1000baseX_Full;
  42.         if (val & ESTATUS_1000_XHALF)
  43.             features |= SUPPORTED_1000baseX_Half;
  44.     }
  45.  
  46.     phydev->supported = features;
  47.     phydev->advertising = features;
  48.  
  49.     genphy_config_aneg(phydev);
  50.  
  51.     return 0;
  52. }

该函数和genphy_update_link的实现风格很像，不再详细说明 
再回到cpsw_slave_update_link函数，这样就完成了对于网卡的重新连接。 
回到cpsw_init函数，接着初始化DMA通道和DMA描述符 
首先初始化描述符

  1. /* init descriptor pool */
  2.     for (i = 0; i < NUM_DESCS; i++) {
  3.         desc_write(&priv->descs[i], hw_next,
  4.                (i == (NUM_DESCS - 1)) ? 0 : &priv->descs[i+1]);
  5.     }
  6.     priv->desc_free = &priv->descs[0];

然后初始化DMA通道，am335有8个channel

  1. memset(&priv->rx_chan, 0, sizeof(struct cpdma_chan));
  2. priv->rx_chan.hdp       = priv->dma_regs + CPDMA_RXHDP_VER2;
  3. priv->rx_chan.cp        = priv->dma_regs + CPDMA_RXCP_VER2;
  4. priv->rx_chan.rxfree    = priv->dma_regs + CPDMA_RXFREE;
  5.  
  6. memset(&priv->tx_chan, 0, sizeof(struct cpdma_chan));
  7. priv->tx_chan.hdp       = priv->dma_regs + CPDMA_TXHDP_VER2;
  8. priv->tx_chan.cp        = priv->dma_regs + CPDMA_TXCP_VER2;

分配好channel的内存地址后，初始化这些通道，方法也很简单，写0即可：

  1. __raw_writel(0, priv->dma_regs + CPDMA_RXHDP_VER2 + 4
  2.         * i);
  3. __raw_writel(0, priv->dma_regs + CPDMA_RXFREE + 4
  4.         * i);
  5. __raw_writel(0, priv->dma_regs + CPDMA_RXCP_VER2 + 4
  6.         * i);
  7. __raw_writel(0, priv->dma_regs + CPDMA_TXHDP_VER2 + 4
  8.         * i);
  9. __raw_writel(0, priv->dma_regs + CPDMA_TXCP_VER2 + 4
  10.         * i);

以上就完成了对cpsw设备的初始化，网卡的配置也基本完成

3、实现网卡的发送 
网卡的发送函数主要是调用cpsw_send函数，比如当输入ping命令时，经过一系列的装包，最后调用cpsw_send函数进行发送，在发送ICMP包之前，会先调用arp发送arp地址解析协议，然后根据收到的arp的包得知主机的mac地址。然后再发送icmp包，因此在这里首先要看如何实现arp包的发送。

首先了解arp协议的格式：

                     

                                                                                           图4

然后分析cpsw_send函数：

  1. static int cpsw_send(struct eth_device *dev, void *packet, int length)
  2. {
  3.     struct cpsw_priv    *priv = dev->priv;
  4.     void *buffer;
  5.     int len;
  6.     int timeout = CPDMA_TIMEOUT;
  7.  
  8.     flush_dcache_range((unsigned long)packet,
  9.                (unsigned long)packet + length);
  10.  
  11.     /* first reap completed packets */
  12.     while (timeout-- &&
  13.         (cpdma_process(priv, &priv->tx_chan, &buffer, &len) &= 0))
  14.         ;
  15.  
  16.     if (timeout == -1) {
  17.         printf("cpdma_process timeout\n");
  18.         return -ETIMEDOUT;
  19.     }
  20.  
  21.     return cpdma_submit(priv, &priv->tx_chan, packet, length);
  22. }

该函数调用flush_dcache_range函数对数据缓存进行刷新，刷新的地址就是packet的地址，因为要保证缓存和内存的一致性，也就是一致性DMA。然后调用cpdma_process和cpdma_submit函数将数据传给DMA描述符，再传送给DMA通道，DMA通过MII发送给网卡，网卡再将数据发送出去。 
转载结束。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。地址： 
https://blog.csdn.net/hahachenchen789/article/details/53339181

 UBOOT中对于网络的收发机制是基于描述符DMA的，它的每一次传输或者接收都有相应的一个描述符，这个描述符里包含的信息如下图5是发送描述符，图6是接收描述符。一个描述符包含了一次传输的所有信息，看图中可以看出报货，下一个描述符的地址，数据buffer的地址，数据的长度，SOP,EOP,Owner，EOQ等等传输状态信息，这些状态信息，我们人为 在传输前的设置初值，然后传输过程中，这些值会由芯片改变，我们去读取这些值，可以判断有没有传输完成，有没有收完。

Start of Packet(SOP) Flag

若置位，表示描述符指针指向一个新报文的缓冲区。如是单个帧报文，sop和结束帧eop标志置位。否则，描述符指针指向上一个报文缓冲区，此报文EOP标志置位。此位通过软件应用置位，不允许EMAC修改。

End of Packet（EOP）Flag

若置位，表示描述符指针指向当下报文的最后。若是一个单个的帧报文，sop和eop同时置位。否则，描述符指针指向设置eop标志的报文的包缓冲区最后。软件应该置位此位，EMAC不允许修改。

Ownership

若置位，表示当下包（从sop到eop）的所有描述符被EMAC拥有。此标志在增加描述符到发送队列之前由软件在sop包描述符上设定。对于单个分片包，sop/eop/OWNER标志同时置位。此标志被EMAC清除，一旦当下包的所有描述符完成之后。注：此标志仅当SOP描述符上有效。

EOQ

若置位，表示有问题的描述符是当下发送通道的发送队列中的上一个描述符，发送器停止。软件应用在增加描述符到发送队列前清楚此标志。当EMAC识别出一个描述符是当下报文的最后一个描述符时，置位此标志。（eop标志置位）没有其它描述符在发送队列。（下一个描述符指针为NULL）

                        

                                                                                            图5

                          

                                                                                           图6

这些描述符存放在固定的内存中，从参考手册中可以看到这块区域叫做CPPI_RAM,地址是在0x4A102000，这是ti专门为网络模块dma所设置的一块区域，从上面的收发描述符可以看出它是一个链表（每一个描述符占据48个字节，上图中只显示了32个字节，实际上在程序中定义的描述符结构体如下所示）。

  1. struct cpdma_desc {
  2. 	/* hardware fields */
  3.     u32	hw_next;
  4.     u32	hw_buffer;
  5.     u32	hw_len;
  6.     u32	hw_mode;
  7. 	/* software fields */
  8.     u32	sw_buffer;
  9.     u32	sw_len;
  10. };

 

以ping命令进行情景分析：

  1. Uboot菜单界面执行ping命令实际上调用的是cmd_net.c中的do_ping函数，调用netloop函数，传给netloop的参数决定了你要执行的功能，netloop中一开始有一个大的switch来根据你传入的参数执行相应的功能函数，这里我们执行ping功能，传入的参数就是PING
  2. Switch中ping分支调用的是ping_start()
    ping_start()先设定ping_timeout时间，超出这个时间没有回应就是ping失败
    然后调用ping_send();
  3. ping_send()首先进行icmp头部封装
    然后调用ArpRequest()
    ArpRequest()进行arp封装，然后调用arp_raw_request发送。arp_raw_request最终调用的是cpsw_send函数
  4. 然后就是一个大循环，等待接收包，进行包解析，循环内容如下
    {
    eth_rx();函数接收数据包，
    ArpTimeoutCheck();判断ping_timeou时间有没有到
    然后一个大switch根据net_state这个状态值执行相应操作，net_state状态包括
        NETLOOP_CONTINUE,
        NETLOOP_RESTART,
        NETLOOP_SUCCESS,
        NETLOOP_FAIL
    这些状态在接收包的时候会做出改变，接收到正确的ping返回包即状态变为NETLOOP_SUCCESS，未超时，第一次接收失败，为NETLOOP_CONTINUE,。超时未收到，则NETLOOP_FAIL。（具体详见函数）
    }
  5. 返回失败值或成功值
    到此结束

分析第二步的ping_send()，ping_send调用cpsw_send

  1. static int cpdma_process(struct cpsw_priv *priv, struct cpdma_chan *chan,
  2. 			 void **buffer, int *len)
  3. {
  4. 	struct cpdma_desc *desc = chan->head;
  5. 	u32 status;
  6.            return -ENOENT;
  7.  //发送过程只会执行到这，因为它预先没有提交描述符信息，需要直接返回去调用cpdma_submit，从
  8. //CPSW_init中可以看出了注册的时候只注册了接受描述符，发送描述符，是在每一次发送前注册的，原因也很
  9. //简单，你发送的时候总归是知道你要发送了，但是接收你不知道什么时候接受，你得准备好位子去接收。
  10. 	      
  11. }
  12.  
  13. static int cpdma_submit(struct cpsw_priv *priv, struct cpdma_chan *chan,
  14. 			void *buffer, int len)
  15. {
  16. 	struct cpdma_desc *desc, *prev;
  17. 	u32 mode;
  18.                           u32 status;	
  19. 	desc = cpdma_desc_alloc(priv); //分配一个描述符
  20. 	if (!desc)
  21. 		return -ENOMEM;
  22. 	if (len < PKT_MIN)
  23. 		len = PKT_MIN;
  24.     status = desc_read(desc, hw_mode);
  25. 	mode = CPDMA_DESC_OWNER | CPDMA_DESC_SOP | CPDMA_DESC_EOP;//填充描述符
  26.  	desc_write(desc, hw_next,   0);//填充描述符
  27. 	desc_write(desc, hw_buffer, buffer);//填充描述符
  28. 	desc_write(desc, hw_len,    len);//填充描述符
  29. 	desc_write(desc, hw_mode,   mode | len);//填充描述符
  30. 	desc_write(desc, sw_buffer, buffer);//填充描述符
  31. 	desc_write(desc, sw_len,    len);//填充描述符
  32. 	if (!chan->head) {  //第一个包的话会构建队列
  33. 		/* simple case - first packet enqueued */
  34. 		chan->head = desc;
  35. 		chan->tail = desc;
  36. 		chan_write(chan, hdp, desc); //当把描述符地址填入描述符地址指针寄存器的时候这个发送就
  37. //开始了,重点就在这，这个地址在eboot中是虚拟地址，但是一档我们向这个寄存器写入这个地址，后面的传
  38. //输都是自动完成的，而这是个DMA模块，这边的操作必须是实际物理地址，所以必须在这边换成物理地址，但
  39. //是只能改写入寄存器的这部分地址为物理地址，不能影响程序的运行，这里面有些相互关联的地方，要仔细
  40. //的一一改错去。
  41. 		goto done;
  42. 	}
  43. 非第一个包的队列操作
  44. 	/* not the first packet - enqueue at the tail */
  45. 	prev = chan->tail;
  46. 	desc_write(prev, hw_next, desc);
  47. 	chan->tail = desc;
  48.  
  49. 	/* next check if EOQ has been triggered already */
  50. 	if (desc_read(prev, hw_mode) & CPDMA_DESC_EOQ)
  51. 		chan_write(chan, hdp, desc); //当把描述符地址填入描述符地址指针寄存器的时候这个发送就开始了
  52. done:
  53. 	if (chan->rxfree) 	
  54. 		chan_write(chan, rxfree, 1);
  55. 	return 0;
  56. }

AM335X内部机制，当一切初始化好的时候，将描述符地址填入描述符地址指针寄存器，这个时候发送就开始了。

然后我们来看接收部分：

eth_rx();函数接收数据包最终调用的是cpsw_recv

  1. static int cpsw_recv(struct eth_device *dev)
  2. {
  3. while (cpdma_process(priv, &priv->rx_chan, &buffer, &len) >= 0) {//读取状态，有收到包则把数据包读出来
  4. NetReceive(buffer, len);//处理数据包//如果收到的是arp回复包则在里面再送icmp（ping请求）
  5. cpdma_submit(priv, &priv->rx_chan, buffer, PKTSIZE);//构造新的等待接收的接收描述符信息
  6. 	}
  7. }
  8.  
  9. static int cpdma_process(struct cpsw_priv *priv, struct cpdma_chan *chan,
  10. 			 void **buffer, int *len)
  11. {
  12. 	struct cpdma_desc *desc = chan->head;
  13. 	u32 status;
  14.            return -ENOENT;
  15. 	      //接收描述符是初始化的时候就填好的，描述符中的状态是硬件自动改变的，根据这些状态可以知道接收成功没有，发送成功没有
  16. 	status = desc_read(desc, hw_mode);
  17.     //读取描述符中的状态
  18. 	if (len)
  19. 		*len = status & 0x7ff;
  20.  //读取包长度   
  21. 	if (buffer)
  22.         *buffer = desc_read_ptr(desc, sw_buffer);
  23. 	//读取数据buffer	
  24. 	if (status & CPDMA_DESC_OWNER) { //如果描述符得这一位还是CPDMA_DESC_OWNER说明没有收到数据，该位没有被改变
  25.     		if (chan_read(chan, hdp) == 0) {
  26. 			if (desc_read(desc, hw_mode) & CPDMA_DESC_OWNER)
  27.                 chan_write(chan, hdp, desc);
  28. 		}
  29. 		return -EBUSY;
  30. 	}
  31.  	chan->head = desc_read_ptr(desc, hw_next);//运行到这说明接收完成，就把下一个描述符放到队列头部
  32. 	chan_write(chan, cp, desc); //写入传输完成指针寄存器，表示传输完成
  33. 	cpdma_desc_free(priv, desc);
  34. 	return 0;
  35. }

总结一下分析网络问题的心路历程：利用wireshark捕捉不到arp包，进行如下分析

  1. 第一步：首先第一个确定mac与外部phy连接是否正常，这点比较好确认，
    mac与phy的配置引脚是mdio（一根时钟线，一根数据线），有点像IIC。但据说比IIC快，具体为什么快，没有研究。
    首先认清楚一点，所有的phy芯片内部的配置寄存器前一部分是国际统一的，是IEEE规定的（如右图IEEE定义的寄存器所示）
    我们要做的就是读写这些寄存器，读写成功了说明你的配置成功的,mac与外部phy连接是正常的，如果读写有问题，那就仔细检查AM335X关于MDIO寄存器的配置。并检查一下phy芯片定义的寄存器，phy初始化完成之后，把phy芯片的寄存器全部读出来，一一比较，看有没有什么配置错误的，有没有打开自动协商功能等等
  2. 第二步：用示波器看看发送引脚有没有数据，有没有时钟信号，如果没有时钟说明配置有误，检查配置寄存器，如果有时钟但是没有数据则确认在发送之前，你的发送数据包里面有没有数据，
    void arp_raw_request(IPaddr_t sourceIP, const uchar *targetEther,
        IPaddr_t targetIP)
    static int cpsw_send(struct eth_device *dev, void *packet, int length)
    static int cpdma_submit(struct cpsw_priv *priv, struct cpdma_chan *chan,
                void *buffer, int len)
    这三个函数中buffer都打印出来看看，是不是有数据的，没有数据的话就说明函数连接错误，没有连接到cpsw_send。有数据的话就检查这些数据的格式是不是正确的，不同的数据包的格式网上都有现成的可以查，如果发现数据格式不对，大概率是因为大小端实现函数未实现，或者实现有误
    大小端实现函数如下：
     #define htons( value ) ((UINT16)((((UINT16)value) << 8) | (((UINT16)((UINT16)value)) >> 8)))
        #define ntohs( value ) htons( value )
        #define htonl( value ) ((((ULONG)value) << 24) | ((0x0000FF00UL & ((ULONG)value)) << 8) | ((0x00FF0000UL & ((ULONG)value)) >> 8) | (((ULONG)value) >> 24))
        #define ntohl( value ) htonl( value )
  3. 第三步：如果有时钟信号，也有数据信号，则参考ti数据手册，网络部分RGMII或者GMII，你用的哪个就看哪个的时序图，看看时钟有数据之间的先后顺序，时间间隔对不对，如果不对，我用的外部芯片是KSZ9031,它可以提供数据的延时，或者时钟的延时，但是AM335X内部是不支持延时功能的，如果你用的phy芯片不支持，并且你用的是AM335X，而且时序不对，那只能请你换一个phy芯片了。
  4. 第四步：如果发送之前有数据，但是示波器上没有显示，说明没有发的出来，说明往描述符头地址指针寄存器里面写的地址是错误的，这个时候就需要去检查，将在cpdma_submit函数中的chan_write(chan, hdp, desc);之前将desc打印出来，这个值必须是实际物理地址，在0x4A102000到0x4A103FFFF之间，如果不是那需要你做地址转换，但是主要这里面地址不对的话一定是你打开了MMU，这就需要你在改的时候小心一点，最好是在用到这些地址的函数的开头，定义物理地址和虚拟地址，只在该用的地方用物理地址，达到的最终效果就是，描述符链表的每一个next中存的都是物理地址，因为一旦开启接收，整个过程都是全自动的，必须确保dma读到的每一个描述符都是在实地址上，如果你只改了第一个描述符，那你会发现，arp包能够发出去，也能收到arp返回包，也能再发送一个ping包，但是ping返回包就收不到了吗，因为你的描述符链表第二个接收地址不是实际地址。（有效的验证方式是将你描述符中定义的数据地址里的内容打印出来，看看是不是有数据，数据对不对）
  5. 所有的步骤之前都需要你确认，你的发送接收都已经使能了。

                                      

                                                                  图7 IEEE定义的phy芯片的寄存器

总而言之，脑子中的思路是：外部能不能收到包->有没有发出去->Phy配置对不对->Cpsw配置对不对->DMA配置对不对->实虚地址对不对->时钟时序对不对。

以下附上我的实虚地址改了哪些地方：我的实际地址 0x4A102000对应的虚拟地址是0xB0502000,这得根据你自己的改。修改以下三个函数就可以了。

  1. static void cpdma_desc_free(struct cpsw_priv *priv, struct cpdma_desc *desc)
  2. {
  3. 	unsigned int phsic_desc = 0;
  4. 	unsigned int viture = 0;
  5. 	struct cpdma_desc *viture_desc = NULL;
  6. 	unsigned int *pp = &desc;
  7. 	if((*pp >= 0x4A102000)&&(*pp <= 0x4A103FFF))
  8. 	{
  9. 		phsic_desc = *pp;
  10. 		viture = *pp + 0x66400000;
  11. 		viture_desc = (struct cpdma_desc *)viture;
  12. 	}
  13. 		if((*pp >= 0xB0502000)&&(*pp <= 0xB0503FFF))
  14. 	{
  15. 		phsic_desc = *pp - 0x66400000;
  16. 		viture = *pp;
  17. 		viture_desc = (struct cpdma_desc *)viture;
  18. 	}
  19. 	if (desc) {
  20. 		desc_write(viture_desc, hw_next, priv->desc_free);
  21. 		priv->desc_free = phsic_desc;
  22. 	}
  23. }
  24.  
  25. static int cpdma_submit(struct cpsw_priv *priv, struct cpdma_chan *chan,
  26. 			void *buffer, int len)
  27. {
  28. 	struct cpdma_desc *desc, *prev;
  29. 	u32 mode;
  30. 	int i=0; 
  31. 	unsigned char *buf = (unsigned char *)buffer;
  32. 	desc = cpdma_desc_alloc(priv);
  33. 	unsigned int phsic_desc = 0;
  34. 	unsigned int viture = 0;
  35. 	struct cpdma_desc *viture_desc = NULL;
  36. 	unsigned int *pp = &desc;
  37. 	if((*pp >= 0x4A102000)&&(*pp <= 0x4A103FFF))
  38. 	{
  39. 		phsic_desc = *pp;
  40. 		viture = *pp + 0x66400000;
  41. 		viture_desc = (struct cpdma_desc *)viture;
  42. 	}
  43. 		if((*pp >= 0xB0502000)&&(*pp <= 0xB0503FFF))
  44. 	{
  45. 		phsic_desc = *pp - 0x66400000;
  46. 		viture = *pp;
  47. 		viture_desc = (struct cpdma_desc *)viture;
  48. 	}
  49. 	printf("### cpdma_submit  \n");
  50. 	if (!desc)
  51. 		return -ENOMEM;
  52.  
  53. 	if (len < PKT_MIN)
  54. 		len = PKT_MIN;
  55. 	for(i=0; i<len; i++)
  56. 		printf("### buffer %x \n", *(buf+i));
  57. 	mode = CPDMA_DESC_OWNER | CPDMA_DESC_SOP | CPDMA_DESC_EOP;
  58.     
  59. 	desc_write(viture_desc, hw_next,   0);
  60. 	desc_write(viture_desc, hw_buffer, buffer);
  61. 	desc_write(viture_desc, hw_len,    len);
  62. 	desc_write(viture_desc, hw_mode,   mode | len);
  63. 	desc_write(viture_desc, sw_buffer, buffer);
  64. 	desc_write(viture_desc, sw_len,    len);
  65. 	printf("### desc_status %x descbuffer %x desclen %x desc next %x descsbuffer %x descslen %x  \n", desc->hw_mode, desc->hw_buffer, desc->hw_len, desc->hw_next, desc->sw_buffer, desc->sw_len);
  66. 	if (!chan->head) {
  67. 		/* simple case - first packet enqueued */
  68. 		chan->head = viture_desc;
  69. 		chan->tail = viture_desc;
  70. 		chan_write(chan, hdp, phsic_desc);
  71. 		goto done;
  72. 	}
  73.  
  74. 	/* not the first packet - enqueue at the tail */
  75. 	prev = chan->tail;
  76. 	desc_write(prev, hw_next, phsic_desc);
  77. 	chan->tail = viture_desc;
  78.  
  79. 	/* next check if EOQ has been triggered already */
  80. 	if (desc_read(prev, hw_mode) & CPDMA_DESC_EOQ)
  81. 		chan_write(chan, hdp, phsic_desc);
  82. 	printf("### chanhdp %x \n", &(chan->hdp));
  83. done:
  84. 	if (chan->rxfree)
  85. 		chan_write(chan, rxfree, 1);
  86. 	printf("### cpdma_submit \n");
  87. 	return 0;
  88. }
  89.  
  90. static int cpdma_process(struct cpsw_priv *priv, struct cpdma_chan *chan,
  91. 			 void **buffer, int *len)
  92. {
  93. 	struct cpdma_desc *desc = chan->head;
  94. 	u32 status;
  95. 	unsigned int phsic_desc = 0;
  96. 	unsigned int viture = 0;
  97. 	struct cpdma_desc *viture_desc = NULL;
  98. 	unsigned int *pp = &desc;
  99. 	if((*pp >= 0x4A102000)&&(*pp <= 0x4A103FFF))
  100. 	{
  101. 		phsic_desc = *pp;
  102. 		viture = *pp + 0x66400000;
  103. 		viture_desc = (struct cpdma_desc *)viture;
  104. 	}
  105. 		if((*pp >= 0xB0502000)&&(*pp <= 0xB0503FFF))
  106. 	{
  107. 		phsic_desc = *pp - 0x66400000;
  108. 		viture = *pp;
  109. 		viture_desc = (struct cpdma_desc *)viture;
  110. 	}
  111. 	printf("### desc  %x\n", desc);
  112. 	if (!desc)
  113. 		return -ENOENT;
  114.  
  115. 	status = desc_read(viture_desc, hw_mode);
  116. 	printf("### status  %x\n", status);
  117. 	if (len)
  118. 		*len = status & 0x7ff;
  119.  
  120. 	if (buffer)
  121. 		*buffer = desc_read_ptr(viture_desc, sw_buffer);
  122.  
  123. 	if (status & CPDMA_DESC_OWNER) {
  124. 		printf("### CPDMA_DESC_OWNER  \n");
  125. 		if (chan_read(chan, hdp) == 0) {
  126. 			if (desc_read(viture_desc, hw_mode) & CPDMA_DESC_OWNER)
  127. 				chan_write(chan, hdp, phsic_desc);
  128. 		}
  129.  
  130. 		return -EBUSY;
  131. 	}
  132. 	printf("### desc2  %x\n", desc);
  133. 	printf("### status2  %x\n", status);
  134. 	chan->head = desc_read_ptr(viture_desc, hw_next);
  135. 	chan_write(chan, cp, phsic_desc);
  136.  
  137. 	cpdma_desc_free(priv, viture_desc);
  138. 	return 0;
  139. }

转载请注明出处

https://blog.csdn.net/qq_20753873/article/details/89139365

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家自动化/article/detail/81789
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号