Hi Alexander,

I love your patch! Yet something to improve:

[auto build test ERROR on staging/staging-testing]

url:    
https://github.com/0day-ci/linux/commits/Alexander-A-Sverdlin/staging-octeon-repair-fixed-link-support/20201009-174828
base:   https://git.kernel.org/pub/scm/linux/kernel/git/gregkh/staging.git 
76c3bdd67d27289b9e407113821eab2a70bbcca6
config: x86_64-allyesconfig (attached as .config)
compiler: gcc-9 (Debian 9.3.0-15) 9.3.0
reproduce (this is a W=1 build):
        # 
https://github.com/0day-ci/linux/commit/99d271d0a7dda48d064e12957a8846907220bf44
        git remote add linux-review https://github.com/0day-ci/linux
        git fetch --no-tags linux-review 
Alexander-A-Sverdlin/staging-octeon-repair-fixed-link-support/20201009-174828
        git checkout 99d271d0a7dda48d064e12957a8846907220bf44
        # save the attached .config to linux build tree
        make W=1 ARCH=x86_64 

If you fix the issue, kindly add following tag as appropriate
Reported-by: kernel test robot <l...@intel.com>

All errors (new ones prefixed by >>):

   drivers/staging/octeon/ethernet.c: In function 'cvm_oct_probe':
>> drivers/staging/octeon/ethernet.c:897:5: error: 'r' undeclared (first use in 
>> this function); did you mean 'rq'?
     897 |     r = of_phy_register_fixed_link(priv->of_node);
         |     ^
         |     rq
   drivers/staging/octeon/ethernet.c:897:5: note: each undeclared identifier is 
reported only once for each function it appears in
>> drivers/staging/octeon/ethernet.c:900:25: error: 'struct octeon_ethernet' 
>> has no member named 'ipd_port'
     900 |          interface, priv->ipd_port);
         |                         ^~

vim +897 drivers/staging/octeon/ethernet.c

   692  
   693          pip = pdev->dev.of_node;
   694          if (!pip) {
   695                  pr_err("Error: No 'pip' in /aliases\n");
   696                  return -EINVAL;
   697          }
   698  
   699          cvm_oct_configure_common_hw();
   700  
   701          cvmx_helper_initialize_packet_io_global();
   702  
   703          if (receive_group_order) {
   704                  if (receive_group_order > 4)
   705                          receive_group_order = 4;
   706                  pow_receive_groups = (1 << (1 << receive_group_order)) 
- 1;
   707          } else {
   708                  pow_receive_groups = BIT(pow_receive_group);
   709          }
   710  
   711          /* Change the input group for all ports before input is enabled 
*/
   712          num_interfaces = cvmx_helper_get_number_of_interfaces();
   713          for (interface = 0; interface < num_interfaces; interface++) {
   714                  int num_ports = 
cvmx_helper_ports_on_interface(interface);
   715                  int port;
   716  
   717                  for (port = cvmx_helper_get_ipd_port(interface, 0);
   718                       port < cvmx_helper_get_ipd_port(interface, 
num_ports);
   719                       port++) {
   720                          union cvmx_pip_prt_tagx pip_prt_tagx;
   721  
   722                          pip_prt_tagx.u64 =
   723                              cvmx_read_csr(CVMX_PIP_PRT_TAGX(port));
   724  
   725                          if (receive_group_order) {
   726                                  int tag_mask;
   727  
   728                                  /* We support only 16 groups at the 
moment, so
   729                                   * always disable the two additional 
"hidden"
   730                                   * tag_mask bits on CN68XX.
   731                                   */
   732                                  if (OCTEON_IS_MODEL(OCTEON_CN68XX))
   733                                          pip_prt_tagx.u64 |= 0x3ull << 
44;
   734  
   735                                  tag_mask = ~((1 << receive_group_order) 
- 1);
   736                                  pip_prt_tagx.s.grptagbase       = 0;
   737                                  pip_prt_tagx.s.grptagmask       = 
tag_mask;
   738                                  pip_prt_tagx.s.grptag           = 1;
   739                                  pip_prt_tagx.s.tag_mode         = 0;
   740                                  pip_prt_tagx.s.inc_prt_flag     = 1;
   741                                  pip_prt_tagx.s.ip6_dprt_flag    = 1;
   742                                  pip_prt_tagx.s.ip4_dprt_flag    = 1;
   743                                  pip_prt_tagx.s.ip6_sprt_flag    = 1;
   744                                  pip_prt_tagx.s.ip4_sprt_flag    = 1;
   745                                  pip_prt_tagx.s.ip6_dst_flag     = 1;
   746                                  pip_prt_tagx.s.ip4_dst_flag     = 1;
   747                                  pip_prt_tagx.s.ip6_src_flag     = 1;
   748                                  pip_prt_tagx.s.ip4_src_flag     = 1;
   749                                  pip_prt_tagx.s.grp              = 0;
   750                          } else {
   751                                  pip_prt_tagx.s.grptag   = 0;
   752                                  pip_prt_tagx.s.grp      = 
pow_receive_group;
   753                          }
   754  
   755                          cvmx_write_csr(CVMX_PIP_PRT_TAGX(port),
   756                                         pip_prt_tagx.u64);
   757                  }
   758          }
   759  
   760          cvmx_helper_ipd_and_packet_input_enable();
   761  
   762          memset(cvm_oct_device, 0, sizeof(cvm_oct_device));
   763  
   764          /*
   765           * Initialize the FAU used for counting packet buffers that
   766           * need to be freed.
   767           */
   768          cvmx_fau_atomic_write32(FAU_NUM_PACKET_BUFFERS_TO_FREE, 0);
   769  
   770          /* Initialize the FAU used for counting tx SKBs that need to be 
freed */
   771          cvmx_fau_atomic_write32(FAU_TOTAL_TX_TO_CLEAN, 0);
   772  
   773          if ((pow_send_group != -1)) {
   774                  struct net_device *dev;
   775  
   776                  dev = alloc_etherdev(sizeof(struct octeon_ethernet));
   777                  if (dev) {
   778                          /* Initialize the device private structure. */
   779                          struct octeon_ethernet *priv = netdev_priv(dev);
   780  
   781                          SET_NETDEV_DEV(dev, &pdev->dev);
   782                          dev->netdev_ops = &cvm_oct_pow_netdev_ops;
   783                          priv->imode = 
CVMX_HELPER_INTERFACE_MODE_DISABLED;
   784                          priv->port = CVMX_PIP_NUM_INPUT_PORTS;
   785                          priv->queue = -1;
   786                          strscpy(dev->name, "pow%d", sizeof(dev->name));
   787                          for (qos = 0; qos < 16; qos++)
   788                                  
skb_queue_head_init(&priv->tx_free_list[qos]);
   789                          dev->min_mtu = VLAN_ETH_ZLEN - mtu_overhead;
   790                          dev->max_mtu = OCTEON_MAX_MTU - mtu_overhead;
   791  
   792                          if (register_netdev(dev) < 0) {
   793                                  pr_err("Failed to register ethernet 
device for POW\n");
   794                                  free_netdev(dev);
   795                          } else {
   796                                  
cvm_oct_device[CVMX_PIP_NUM_INPUT_PORTS] = dev;
   797                                  pr_info("%s: POW send group %d, receive 
group %d\n",
   798                                          dev->name, pow_send_group,
   799                                          pow_receive_group);
   800                          }
   801                  } else {
   802                          pr_err("Failed to allocate ethernet device for 
POW\n");
   803                  }
   804          }
   805  
   806          num_interfaces = cvmx_helper_get_number_of_interfaces();
   807          for (interface = 0; interface < num_interfaces; interface++) {
   808                  cvmx_helper_interface_mode_t imode =
   809                      cvmx_helper_interface_get_mode(interface);
   810                  int num_ports = 
cvmx_helper_ports_on_interface(interface);
   811                  int port;
   812                  int port_index;
   813  
   814                  for (port_index = 0,
   815                       port = cvmx_helper_get_ipd_port(interface, 0);
   816                       port < cvmx_helper_get_ipd_port(interface, 
num_ports);
   817                       port_index++, port++) {
   818                          struct octeon_ethernet *priv;
   819                          struct net_device *dev =
   820                              alloc_etherdev(sizeof(struct 
octeon_ethernet));
   821                          if (!dev) {
   822                                  pr_err("Failed to allocate ethernet 
device for port %d\n",
   823                                         port);
   824                                  continue;
   825                          }
   826  
   827                          /* Initialize the device private structure. */
   828                          SET_NETDEV_DEV(dev, &pdev->dev);
   829                          priv = netdev_priv(dev);
   830                          priv->netdev = dev;
   831                          priv->of_node = cvm_oct_node_for_port(pip, 
interface,
   832                                                                
port_index);
   833  
   834                          INIT_DELAYED_WORK(&priv->port_periodic_work,
   835                                            cvm_oct_periodic_worker);
   836                          priv->imode = imode;
   837                          priv->port = port;
   838                          priv->queue = 
cvmx_pko_get_base_queue(priv->port);
   839                          priv->fau = fau - cvmx_pko_get_num_queues(port) 
* 4;
   840                          priv->phy_mode = PHY_INTERFACE_MODE_NA;
   841                          for (qos = 0; qos < 16; qos++)
   842                                  
skb_queue_head_init(&priv->tx_free_list[qos]);
   843                          for (qos = 0; qos < 
cvmx_pko_get_num_queues(port);
   844                               qos++)
   845                                  cvmx_fau_atomic_write32(priv->fau + qos 
* 4, 0);
   846                          dev->min_mtu = VLAN_ETH_ZLEN - mtu_overhead;
   847                          dev->max_mtu = OCTEON_MAX_MTU - mtu_overhead;
   848  
   849                          switch (priv->imode) {
   850                          /* These types don't support ports to IPD/PKO */
   851                          case CVMX_HELPER_INTERFACE_MODE_DISABLED:
   852                          case CVMX_HELPER_INTERFACE_MODE_PCIE:
   853                          case CVMX_HELPER_INTERFACE_MODE_PICMG:
   854                                  break;
   855  
   856                          case CVMX_HELPER_INTERFACE_MODE_NPI:
   857                                  dev->netdev_ops = 
&cvm_oct_npi_netdev_ops;
   858                                  strscpy(dev->name, "npi%d", 
sizeof(dev->name));
   859                                  break;
   860  
   861                          case CVMX_HELPER_INTERFACE_MODE_XAUI:
   862                                  dev->netdev_ops = 
&cvm_oct_xaui_netdev_ops;
   863                                  strscpy(dev->name, "xaui%d", 
sizeof(dev->name));
   864                                  break;
   865  
   866                          case CVMX_HELPER_INTERFACE_MODE_LOOP:
   867                                  dev->netdev_ops = 
&cvm_oct_npi_netdev_ops;
   868                                  strscpy(dev->name, "loop%d", 
sizeof(dev->name));
   869                                  break;
   870  
   871                          case CVMX_HELPER_INTERFACE_MODE_SGMII:
   872                                  priv->phy_mode = 
PHY_INTERFACE_MODE_SGMII;
   873                                  dev->netdev_ops = 
&cvm_oct_sgmii_netdev_ops;
   874                                  strscpy(dev->name, "eth%d", 
sizeof(dev->name));
   875                                  break;
   876  
   877                          case CVMX_HELPER_INTERFACE_MODE_SPI:
   878                                  dev->netdev_ops = 
&cvm_oct_spi_netdev_ops;
   879                                  strscpy(dev->name, "spi%d", 
sizeof(dev->name));
   880                                  break;
   881  
   882                          case CVMX_HELPER_INTERFACE_MODE_GMII:
   883                                  priv->phy_mode = 
PHY_INTERFACE_MODE_GMII;
   884                                  dev->netdev_ops = 
&cvm_oct_rgmii_netdev_ops;
   885                                  strscpy(dev->name, "eth%d", 
sizeof(dev->name));
   886                                  break;
   887  
   888                          case CVMX_HELPER_INTERFACE_MODE_RGMII:
   889                                  dev->netdev_ops = 
&cvm_oct_rgmii_netdev_ops;
   890                                  strscpy(dev->name, "eth%d", 
sizeof(dev->name));
   891                                  cvm_set_rgmii_delay(priv, interface,
   892                                                      port_index);
   893                                  break;
   894                          }
   895  
   896                          if (priv->of_node && 
of_phy_is_fixed_link(priv->of_node)) {
 > 897                                  r = 
 > of_phy_register_fixed_link(priv->of_node);
   898                                  if (r) {
   899                                          netdev_err(dev, "Failed to 
register fixed link for interface %d, port %d\n",
 > 900                                                     interface, 
 > priv->ipd_port);
   901                                          dev->netdev_ops = NULL;
   902                                  }
   903                          }
   904  
   905                          if (!dev->netdev_ops) {
   906                                  free_netdev(dev);
   907                          } else if (register_netdev(dev) < 0) {
   908                                  pr_err("Failed to register ethernet 
device for interface %d, port %d\n",
   909                                         interface, priv->port);
   910                                  free_netdev(dev);
   911                          } else {
   912                                  cvm_oct_device[priv->port] = dev;
   913                                  fau -=
   914                                      cvmx_pko_get_num_queues(priv->port) 
*
   915                                      sizeof(u32);
   916                                  
schedule_delayed_work(&priv->port_periodic_work,
   917                                                        HZ);
   918                          }
   919                  }
   920          }
   921  
   922          cvm_oct_tx_initialize();
   923          cvm_oct_rx_initialize();
   924  
   925          /*
   926           * 150 uS: about 10 1500-byte packets at 1GE.
   927           */
   928          cvm_oct_tx_poll_interval = 150 * (octeon_get_clock_rate() / 
1000000);
   929  
   930          schedule_delayed_work(&cvm_oct_rx_refill_work, HZ);
   931  
   932          return 0;
   933  }
   934  

---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-...@lists.01.org

Attachment: .config.gz
Description: application/gzip

Reply via email to