ethernet.c revision 4d9784522588302dccb7088c0d7dc541719e6d07
1/********************************************************************** 2 * Author: Cavium Networks 3 * 4 * Contact: support@caviumnetworks.com 5 * This file is part of the OCTEON SDK 6 * 7 * Copyright (c) 2003-2007 Cavium Networks 8 * 9 * This file is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License, Version 2, as 11 * published by the Free Software Foundation. 12 * 13 * This file is distributed in the hope that it will be useful, but 14 * AS-IS and WITHOUT ANY WARRANTY; without even the implied warranty 15 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE, TITLE, or 16 * NONINFRINGEMENT. See the GNU General Public License for more 17 * details. 18 * 19 * You should have received a copy of the GNU General Public License 20 * along with this file; if not, write to the Free Software 21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 22 * or visit http://www.gnu.org/licenses/. 23 * 24 * This file may also be available under a different license from Cavium. 25 * Contact Cavium Networks for more information 26**********************************************************************/ 27#include <linux/platform_device.h> 28#include <linux/kernel.h> 29#include <linux/init.h> 30#include <linux/module.h> 31#include <linux/netdevice.h> 32#include <linux/etherdevice.h> 33#include <linux/phy.h> 34#include <linux/slab.h> 35#include <linux/interrupt.h> 36#include <linux/of_net.h> 37 38#include <net/dst.h> 39 40#include <asm/octeon/octeon.h> 41 42#include "ethernet-defines.h" 43#include "octeon-ethernet.h" 44#include "ethernet-mem.h" 45#include "ethernet-rx.h" 46#include "ethernet-tx.h" 47#include "ethernet-mdio.h" 48#include "ethernet-util.h" 49 50#include <asm/octeon/cvmx-pip.h> 51#include <asm/octeon/cvmx-pko.h> 52#include <asm/octeon/cvmx-fau.h> 53#include <asm/octeon/cvmx-ipd.h> 54#include <asm/octeon/cvmx-helper.h> 55 56#include <asm/octeon/cvmx-gmxx-defs.h> 57#include <asm/octeon/cvmx-smix-defs.h> 58 59#if defined(CONFIG_CAVIUM_OCTEON_NUM_PACKET_BUFFERS) \ 60 && CONFIG_CAVIUM_OCTEON_NUM_PACKET_BUFFERS 61int num_packet_buffers = CONFIG_CAVIUM_OCTEON_NUM_PACKET_BUFFERS; 62#else 63int num_packet_buffers = 1024; 64#endif 65module_param(num_packet_buffers, int, 0444); 66MODULE_PARM_DESC(num_packet_buffers, "\n" 67 "\tNumber of packet buffers to allocate and store in the\n" 68 "\tFPA. By default, 1024 packet buffers are used unless\n" 69 "\tCONFIG_CAVIUM_OCTEON_NUM_PACKET_BUFFERS is defined."); 70 71int pow_receive_group = 15; 72module_param(pow_receive_group, int, 0444); 73MODULE_PARM_DESC(pow_receive_group, "\n" 74 "\tPOW group to receive packets from. All ethernet hardware\n" 75 "\twill be configured to send incoming packets to this POW\n" 76 "\tgroup. Also any other software can submit packets to this\n" 77 "\tgroup for the kernel to process."); 78 79int pow_send_group = -1; 80module_param(pow_send_group, int, 0644); 81MODULE_PARM_DESC(pow_send_group, "\n" 82 "\tPOW group to send packets to other software on. This\n" 83 "\tcontrols the creation of the virtual device pow0.\n" 84 "\talways_use_pow also depends on this value."); 85 86int always_use_pow; 87module_param(always_use_pow, int, 0444); 88MODULE_PARM_DESC(always_use_pow, "\n" 89 "\tWhen set, always send to the pow group. This will cause\n" 90 "\tpackets sent to real ethernet devices to be sent to the\n" 91 "\tPOW group instead of the hardware. Unless some other\n" 92 "\tapplication changes the config, packets will still be\n" 93 "\treceived from the low level hardware. Use this option\n" 94 "\tto allow a CVMX app to intercept all packets from the\n" 95 "\tlinux kernel. You must specify pow_send_group along with\n" 96 "\tthis option."); 97 98char pow_send_list[128] = ""; 99module_param_string(pow_send_list, pow_send_list, sizeof(pow_send_list), 0444); 100MODULE_PARM_DESC(pow_send_list, "\n" 101 "\tComma separated list of ethernet devices that should use the\n" 102 "\tPOW for transmit instead of the actual ethernet hardware. This\n" 103 "\tis a per port version of always_use_pow. always_use_pow takes\n" 104 "\tprecedence over this list. For example, setting this to\n" 105 "\t\"eth2,spi3,spi7\" would cause these three devices to transmit\n" 106 "\tusing the pow_send_group."); 107 108int max_rx_cpus = -1; 109module_param(max_rx_cpus, int, 0444); 110MODULE_PARM_DESC(max_rx_cpus, "\n" 111 "\t\tThe maximum number of CPUs to use for packet reception.\n" 112 "\t\tUse -1 to use all available CPUs."); 113 114int rx_napi_weight = 32; 115module_param(rx_napi_weight, int, 0444); 116MODULE_PARM_DESC(rx_napi_weight, "The NAPI WEIGHT parameter."); 117 118/** 119 * cvm_oct_poll_queue - Workqueue for polling operations. 120 */ 121struct workqueue_struct *cvm_oct_poll_queue; 122 123/** 124 * cvm_oct_poll_queue_stopping - flag to indicate polling should stop. 125 * 126 * Set to one right before cvm_oct_poll_queue is destroyed. 127 */ 128atomic_t cvm_oct_poll_queue_stopping = ATOMIC_INIT(0); 129 130/** 131 * Array of every ethernet device owned by this driver indexed by 132 * the ipd input port number. 133 */ 134struct net_device *cvm_oct_device[TOTAL_NUMBER_OF_PORTS]; 135 136u64 cvm_oct_tx_poll_interval; 137 138static void cvm_oct_rx_refill_worker(struct work_struct *work); 139static DECLARE_DELAYED_WORK(cvm_oct_rx_refill_work, cvm_oct_rx_refill_worker); 140 141static void cvm_oct_rx_refill_worker(struct work_struct *work) 142{ 143 /* 144 * FPA 0 may have been drained, try to refill it if we need 145 * more than num_packet_buffers / 2, otherwise normal receive 146 * processing will refill it. If it were drained, no packets 147 * could be received so cvm_oct_napi_poll would never be 148 * invoked to do the refill. 149 */ 150 cvm_oct_rx_refill_pool(num_packet_buffers / 2); 151 152 if (!atomic_read(&cvm_oct_poll_queue_stopping)) 153 queue_delayed_work(cvm_oct_poll_queue, 154 &cvm_oct_rx_refill_work, HZ); 155} 156 157static void cvm_oct_periodic_worker(struct work_struct *work) 158{ 159 struct octeon_ethernet *priv = container_of(work, 160 struct octeon_ethernet, 161 port_periodic_work.work); 162 163 if (priv->poll) 164 priv->poll(cvm_oct_device[priv->port]); 165 166 cvm_oct_device[priv->port]->netdev_ops->ndo_get_stats( 167 cvm_oct_device[priv->port]); 168 169 if (!atomic_read(&cvm_oct_poll_queue_stopping)) 170 queue_delayed_work(cvm_oct_poll_queue, 171 &priv->port_periodic_work, HZ); 172} 173 174static void cvm_oct_configure_common_hw(void) 175{ 176 /* Setup the FPA */ 177 cvmx_fpa_enable(); 178 cvm_oct_mem_fill_fpa(CVMX_FPA_PACKET_POOL, CVMX_FPA_PACKET_POOL_SIZE, 179 num_packet_buffers); 180 cvm_oct_mem_fill_fpa(CVMX_FPA_WQE_POOL, CVMX_FPA_WQE_POOL_SIZE, 181 num_packet_buffers); 182 if (CVMX_FPA_OUTPUT_BUFFER_POOL != CVMX_FPA_PACKET_POOL) 183 cvm_oct_mem_fill_fpa(CVMX_FPA_OUTPUT_BUFFER_POOL, 184 CVMX_FPA_OUTPUT_BUFFER_POOL_SIZE, 128); 185 186 if (USE_RED) 187 cvmx_helper_setup_red(num_packet_buffers / 4, 188 num_packet_buffers / 8); 189 190} 191 192/** 193 * cvm_oct_free_work- Free a work queue entry 194 * 195 * @work_queue_entry: Work queue entry to free 196 * 197 * Returns Zero on success, Negative on failure. 198 */ 199int cvm_oct_free_work(void *work_queue_entry) 200{ 201 cvmx_wqe_t *work = work_queue_entry; 202 203 int segments = work->word2.s.bufs; 204 union cvmx_buf_ptr segment_ptr = work->packet_ptr; 205 206 while (segments--) { 207 union cvmx_buf_ptr next_ptr = *(union cvmx_buf_ptr *) 208 cvmx_phys_to_ptr(segment_ptr.s.addr - 8); 209 if (unlikely(!segment_ptr.s.i)) 210 cvmx_fpa_free(cvm_oct_get_buffer_ptr(segment_ptr), 211 segment_ptr.s.pool, 212 DONT_WRITEBACK(CVMX_FPA_PACKET_POOL_SIZE / 213 128)); 214 segment_ptr = next_ptr; 215 } 216 cvmx_fpa_free(work, CVMX_FPA_WQE_POOL, DONT_WRITEBACK(1)); 217 218 return 0; 219} 220EXPORT_SYMBOL(cvm_oct_free_work); 221 222/** 223 * cvm_oct_common_get_stats - get the low level ethernet statistics 224 * @dev: Device to get the statistics from 225 * 226 * Returns Pointer to the statistics 227 */ 228static struct net_device_stats *cvm_oct_common_get_stats(struct net_device *dev) 229{ 230 cvmx_pip_port_status_t rx_status; 231 cvmx_pko_port_status_t tx_status; 232 struct octeon_ethernet *priv = netdev_priv(dev); 233 234 if (priv->port < CVMX_PIP_NUM_INPUT_PORTS) { 235 if (octeon_is_simulation()) { 236 /* The simulator doesn't support statistics */ 237 memset(&rx_status, 0, sizeof(rx_status)); 238 memset(&tx_status, 0, sizeof(tx_status)); 239 } else { 240 cvmx_pip_get_port_status(priv->port, 1, &rx_status); 241 cvmx_pko_get_port_status(priv->port, 1, &tx_status); 242 } 243 244 priv->stats.rx_packets += rx_status.inb_packets; 245 priv->stats.tx_packets += tx_status.packets; 246 priv->stats.rx_bytes += rx_status.inb_octets; 247 priv->stats.tx_bytes += tx_status.octets; 248 priv->stats.multicast += rx_status.multicast_packets; 249 priv->stats.rx_crc_errors += rx_status.inb_errors; 250 priv->stats.rx_frame_errors += rx_status.fcs_align_err_packets; 251 252 /* 253 * The drop counter must be incremented atomically 254 * since the RX tasklet also increments it. 255 */ 256#ifdef CONFIG_64BIT 257 atomic64_add(rx_status.dropped_packets, 258 (atomic64_t *)&priv->stats.rx_dropped); 259#else 260 atomic_add(rx_status.dropped_packets, 261 (atomic_t *)&priv->stats.rx_dropped); 262#endif 263 } 264 265 return &priv->stats; 266} 267 268/** 269 * cvm_oct_common_change_mtu - change the link MTU 270 * @dev: Device to change 271 * @new_mtu: The new MTU 272 * 273 * Returns Zero on success 274 */ 275static int cvm_oct_common_change_mtu(struct net_device *dev, int new_mtu) 276{ 277 struct octeon_ethernet *priv = netdev_priv(dev); 278 int interface = INTERFACE(priv->port); 279 int index = INDEX(priv->port); 280#if defined(CONFIG_VLAN_8021Q) || defined(CONFIG_VLAN_8021Q_MODULE) 281 int vlan_bytes = 4; 282#else 283 int vlan_bytes = 0; 284#endif 285 286 /* 287 * Limit the MTU to make sure the ethernet packets are between 288 * 64 bytes and 65535 bytes. 289 */ 290 if ((new_mtu + 14 + 4 + vlan_bytes < 64) 291 || (new_mtu + 14 + 4 + vlan_bytes > 65392)) { 292 pr_err("MTU must be between %d and %d.\n", 293 64 - 14 - 4 - vlan_bytes, 65392 - 14 - 4 - vlan_bytes); 294 return -EINVAL; 295 } 296 dev->mtu = new_mtu; 297 298 if ((interface < 2) 299 && (cvmx_helper_interface_get_mode(interface) != 300 CVMX_HELPER_INTERFACE_MODE_SPI)) { 301 /* Add ethernet header and FCS, and VLAN if configured. */ 302 int max_packet = new_mtu + 14 + 4 + vlan_bytes; 303 304 if (OCTEON_IS_MODEL(OCTEON_CN3XXX) 305 || OCTEON_IS_MODEL(OCTEON_CN58XX)) { 306 /* Signal errors on packets larger than the MTU */ 307 cvmx_write_csr(CVMX_GMXX_RXX_FRM_MAX(index, interface), 308 max_packet); 309 } else { 310 /* 311 * Set the hardware to truncate packets larger 312 * than the MTU and smaller the 64 bytes. 313 */ 314 union cvmx_pip_frm_len_chkx frm_len_chk; 315 frm_len_chk.u64 = 0; 316 frm_len_chk.s.minlen = 64; 317 frm_len_chk.s.maxlen = max_packet; 318 cvmx_write_csr(CVMX_PIP_FRM_LEN_CHKX(interface), 319 frm_len_chk.u64); 320 } 321 /* 322 * Set the hardware to truncate packets larger than 323 * the MTU. The jabber register must be set to a 324 * multiple of 8 bytes, so round up. 325 */ 326 cvmx_write_csr(CVMX_GMXX_RXX_JABBER(index, interface), 327 (max_packet + 7) & ~7u); 328 } 329 return 0; 330} 331 332/** 333 * cvm_oct_common_set_multicast_list - set the multicast list 334 * @dev: Device to work on 335 */ 336static void cvm_oct_common_set_multicast_list(struct net_device *dev) 337{ 338 union cvmx_gmxx_prtx_cfg gmx_cfg; 339 struct octeon_ethernet *priv = netdev_priv(dev); 340 int interface = INTERFACE(priv->port); 341 int index = INDEX(priv->port); 342 343 if ((interface < 2) 344 && (cvmx_helper_interface_get_mode(interface) != 345 CVMX_HELPER_INTERFACE_MODE_SPI)) { 346 union cvmx_gmxx_rxx_adr_ctl control; 347 control.u64 = 0; 348 control.s.bcst = 1; /* Allow broadcast MAC addresses */ 349 350 if (!netdev_mc_empty(dev) || (dev->flags & IFF_ALLMULTI) || 351 (dev->flags & IFF_PROMISC)) 352 /* Force accept multicast packets */ 353 control.s.mcst = 2; 354 else 355 /* Force reject multicast packets */ 356 control.s.mcst = 1; 357 358 if (dev->flags & IFF_PROMISC) 359 /* 360 * Reject matches if promisc. Since CAM is 361 * shut off, should accept everything. 362 */ 363 control.s.cam_mode = 0; 364 else 365 /* Filter packets based on the CAM */ 366 control.s.cam_mode = 1; 367 368 gmx_cfg.u64 = 369 cvmx_read_csr(CVMX_GMXX_PRTX_CFG(index, interface)); 370 cvmx_write_csr(CVMX_GMXX_PRTX_CFG(index, interface), 371 gmx_cfg.u64 & ~1ull); 372 373 cvmx_write_csr(CVMX_GMXX_RXX_ADR_CTL(index, interface), 374 control.u64); 375 if (dev->flags & IFF_PROMISC) 376 cvmx_write_csr(CVMX_GMXX_RXX_ADR_CAM_EN 377 (index, interface), 0); 378 else 379 cvmx_write_csr(CVMX_GMXX_RXX_ADR_CAM_EN 380 (index, interface), 1); 381 382 cvmx_write_csr(CVMX_GMXX_PRTX_CFG(index, interface), 383 gmx_cfg.u64); 384 } 385} 386 387/** 388 * cvm_oct_common_set_mac_address - set the hardware MAC address for a device 389 * @dev: The device in question. 390 * @addr: Address structure to change it too. 391 392 * Returns Zero on success 393 */ 394static int cvm_oct_set_mac_filter(struct net_device *dev) 395{ 396 struct octeon_ethernet *priv = netdev_priv(dev); 397 union cvmx_gmxx_prtx_cfg gmx_cfg; 398 int interface = INTERFACE(priv->port); 399 int index = INDEX(priv->port); 400 401 if ((interface < 2) 402 && (cvmx_helper_interface_get_mode(interface) != 403 CVMX_HELPER_INTERFACE_MODE_SPI)) { 404 int i; 405 uint8_t *ptr = dev->dev_addr; 406 uint64_t mac = 0; 407 for (i = 0; i < 6; i++) 408 mac = (mac << 8) | (uint64_t)ptr[i]; 409 410 gmx_cfg.u64 = 411 cvmx_read_csr(CVMX_GMXX_PRTX_CFG(index, interface)); 412 cvmx_write_csr(CVMX_GMXX_PRTX_CFG(index, interface), 413 gmx_cfg.u64 & ~1ull); 414 415 cvmx_write_csr(CVMX_GMXX_SMACX(index, interface), mac); 416 cvmx_write_csr(CVMX_GMXX_RXX_ADR_CAM0(index, interface), 417 ptr[0]); 418 cvmx_write_csr(CVMX_GMXX_RXX_ADR_CAM1(index, interface), 419 ptr[1]); 420 cvmx_write_csr(CVMX_GMXX_RXX_ADR_CAM2(index, interface), 421 ptr[2]); 422 cvmx_write_csr(CVMX_GMXX_RXX_ADR_CAM3(index, interface), 423 ptr[3]); 424 cvmx_write_csr(CVMX_GMXX_RXX_ADR_CAM4(index, interface), 425 ptr[4]); 426 cvmx_write_csr(CVMX_GMXX_RXX_ADR_CAM5(index, interface), 427 ptr[5]); 428 cvm_oct_common_set_multicast_list(dev); 429 cvmx_write_csr(CVMX_GMXX_PRTX_CFG(index, interface), 430 gmx_cfg.u64); 431 } 432 return 0; 433} 434 435static int cvm_oct_common_set_mac_address(struct net_device *dev, void *addr) 436{ 437 int r = eth_mac_addr(dev, addr); 438 439 if (r) 440 return r; 441 return cvm_oct_set_mac_filter(dev); 442} 443 444/** 445 * cvm_oct_common_init - per network device initialization 446 * @dev: Device to initialize 447 * 448 * Returns Zero on success 449 */ 450int cvm_oct_common_init(struct net_device *dev) 451{ 452 struct octeon_ethernet *priv = netdev_priv(dev); 453 const u8 *mac = NULL; 454 455 if (priv->of_node) 456 mac = of_get_mac_address(priv->of_node); 457 458 if (mac) 459 memcpy(dev->dev_addr, mac, ETH_ALEN); 460 else 461 eth_hw_addr_random(dev); 462 463 /* 464 * Force the interface to use the POW send if always_use_pow 465 * was specified or it is in the pow send list. 466 */ 467 if ((pow_send_group != -1) 468 && (always_use_pow || strstr(pow_send_list, dev->name))) 469 priv->queue = -1; 470 471 if (priv->queue != -1) { 472 dev->features |= NETIF_F_SG; 473 if (USE_HW_TCPUDP_CHECKSUM) 474 dev->features |= NETIF_F_IP_CSUM; 475 } 476 477 /* We do our own locking, Linux doesn't need to */ 478 dev->features |= NETIF_F_LLTX; 479 SET_ETHTOOL_OPS(dev, &cvm_oct_ethtool_ops); 480 481 cvm_oct_phy_setup_device(dev); 482 cvm_oct_set_mac_filter(dev); 483 dev->netdev_ops->ndo_change_mtu(dev, dev->mtu); 484 485 /* 486 * Zero out stats for port so we won't mistakenly show 487 * counters from the bootloader. 488 */ 489 memset(dev->netdev_ops->ndo_get_stats(dev), 0, 490 sizeof(struct net_device_stats)); 491 492 return 0; 493} 494 495void cvm_oct_common_uninit(struct net_device *dev) 496{ 497 struct octeon_ethernet *priv = netdev_priv(dev); 498 499 if (priv->phydev) 500 phy_disconnect(priv->phydev); 501} 502 503static const struct net_device_ops cvm_oct_npi_netdev_ops = { 504 .ndo_init = cvm_oct_common_init, 505 .ndo_uninit = cvm_oct_common_uninit, 506 .ndo_start_xmit = cvm_oct_xmit, 507 .ndo_set_rx_mode = cvm_oct_common_set_multicast_list, 508 .ndo_set_mac_address = cvm_oct_common_set_mac_address, 509 .ndo_do_ioctl = cvm_oct_ioctl, 510 .ndo_change_mtu = cvm_oct_common_change_mtu, 511 .ndo_get_stats = cvm_oct_common_get_stats, 512#ifdef CONFIG_NET_POLL_CONTROLLER 513 .ndo_poll_controller = cvm_oct_poll_controller, 514#endif 515}; 516static const struct net_device_ops cvm_oct_xaui_netdev_ops = { 517 .ndo_init = cvm_oct_xaui_init, 518 .ndo_uninit = cvm_oct_xaui_uninit, 519 .ndo_open = cvm_oct_xaui_open, 520 .ndo_stop = cvm_oct_xaui_stop, 521 .ndo_start_xmit = cvm_oct_xmit, 522 .ndo_set_rx_mode = cvm_oct_common_set_multicast_list, 523 .ndo_set_mac_address = cvm_oct_common_set_mac_address, 524 .ndo_do_ioctl = cvm_oct_ioctl, 525 .ndo_change_mtu = cvm_oct_common_change_mtu, 526 .ndo_get_stats = cvm_oct_common_get_stats, 527#ifdef CONFIG_NET_POLL_CONTROLLER 528 .ndo_poll_controller = cvm_oct_poll_controller, 529#endif 530}; 531static const struct net_device_ops cvm_oct_sgmii_netdev_ops = { 532 .ndo_init = cvm_oct_sgmii_init, 533 .ndo_uninit = cvm_oct_sgmii_uninit, 534 .ndo_open = cvm_oct_sgmii_open, 535 .ndo_stop = cvm_oct_sgmii_stop, 536 .ndo_start_xmit = cvm_oct_xmit, 537 .ndo_set_rx_mode = cvm_oct_common_set_multicast_list, 538 .ndo_set_mac_address = cvm_oct_common_set_mac_address, 539 .ndo_do_ioctl = cvm_oct_ioctl, 540 .ndo_change_mtu = cvm_oct_common_change_mtu, 541 .ndo_get_stats = cvm_oct_common_get_stats, 542#ifdef CONFIG_NET_POLL_CONTROLLER 543 .ndo_poll_controller = cvm_oct_poll_controller, 544#endif 545}; 546static const struct net_device_ops cvm_oct_spi_netdev_ops = { 547 .ndo_init = cvm_oct_spi_init, 548 .ndo_uninit = cvm_oct_spi_uninit, 549 .ndo_start_xmit = cvm_oct_xmit, 550 .ndo_set_rx_mode = cvm_oct_common_set_multicast_list, 551 .ndo_set_mac_address = cvm_oct_common_set_mac_address, 552 .ndo_do_ioctl = cvm_oct_ioctl, 553 .ndo_change_mtu = cvm_oct_common_change_mtu, 554 .ndo_get_stats = cvm_oct_common_get_stats, 555#ifdef CONFIG_NET_POLL_CONTROLLER 556 .ndo_poll_controller = cvm_oct_poll_controller, 557#endif 558}; 559static const struct net_device_ops cvm_oct_rgmii_netdev_ops = { 560 .ndo_init = cvm_oct_rgmii_init, 561 .ndo_uninit = cvm_oct_rgmii_uninit, 562 .ndo_open = cvm_oct_rgmii_open, 563 .ndo_stop = cvm_oct_rgmii_stop, 564 .ndo_start_xmit = cvm_oct_xmit, 565 .ndo_set_rx_mode = cvm_oct_common_set_multicast_list, 566 .ndo_set_mac_address = cvm_oct_common_set_mac_address, 567 .ndo_do_ioctl = cvm_oct_ioctl, 568 .ndo_change_mtu = cvm_oct_common_change_mtu, 569 .ndo_get_stats = cvm_oct_common_get_stats, 570#ifdef CONFIG_NET_POLL_CONTROLLER 571 .ndo_poll_controller = cvm_oct_poll_controller, 572#endif 573}; 574static const struct net_device_ops cvm_oct_pow_netdev_ops = { 575 .ndo_init = cvm_oct_common_init, 576 .ndo_start_xmit = cvm_oct_xmit_pow, 577 .ndo_set_rx_mode = cvm_oct_common_set_multicast_list, 578 .ndo_set_mac_address = cvm_oct_common_set_mac_address, 579 .ndo_do_ioctl = cvm_oct_ioctl, 580 .ndo_change_mtu = cvm_oct_common_change_mtu, 581 .ndo_get_stats = cvm_oct_common_get_stats, 582#ifdef CONFIG_NET_POLL_CONTROLLER 583 .ndo_poll_controller = cvm_oct_poll_controller, 584#endif 585}; 586 587extern void octeon_mdiobus_force_mod_depencency(void); 588 589static struct device_node *cvm_oct_of_get_child( 590 const struct device_node *parent, int reg_val) 591{ 592 struct device_node *node = NULL; 593 int size; 594 const __be32 *addr; 595 596 for (;;) { 597 node = of_get_next_child(parent, node); 598 if (!node) 599 break; 600 addr = of_get_property(node, "reg", &size); 601 if (addr && (be32_to_cpu(*addr) == reg_val)) 602 break; 603 } 604 return node; 605} 606 607static struct device_node *cvm_oct_node_for_port(struct device_node *pip, 608 int interface, int port) 609{ 610 struct device_node *ni, *np; 611 612 ni = cvm_oct_of_get_child(pip, interface); 613 if (!ni) 614 return NULL; 615 616 np = cvm_oct_of_get_child(ni, port); 617 of_node_put(ni); 618 619 return np; 620} 621 622static int cvm_oct_probe(struct platform_device *pdev) 623{ 624 int num_interfaces; 625 int interface; 626 int fau = FAU_NUM_PACKET_BUFFERS_TO_FREE; 627 int qos; 628 struct device_node *pip; 629 630 octeon_mdiobus_force_mod_depencency(); 631 pr_notice("cavium-ethernet %s\n", OCTEON_ETHERNET_VERSION); 632 633 pip = pdev->dev.of_node; 634 if (!pip) { 635 pr_err("Error: No 'pip' in /aliases\n"); 636 return -EINVAL; 637 } 638 639 cvm_oct_poll_queue = create_singlethread_workqueue("octeon-ethernet"); 640 if (cvm_oct_poll_queue == NULL) { 641 pr_err("octeon-ethernet: Cannot create workqueue"); 642 return -ENOMEM; 643 } 644 645 cvm_oct_configure_common_hw(); 646 647 cvmx_helper_initialize_packet_io_global(); 648 649 /* Change the input group for all ports before input is enabled */ 650 num_interfaces = cvmx_helper_get_number_of_interfaces(); 651 for (interface = 0; interface < num_interfaces; interface++) { 652 int num_ports = cvmx_helper_ports_on_interface(interface); 653 int port; 654 655 for (port = cvmx_helper_get_ipd_port(interface, 0); 656 port < cvmx_helper_get_ipd_port(interface, num_ports); 657 port++) { 658 union cvmx_pip_prt_tagx pip_prt_tagx; 659 pip_prt_tagx.u64 = 660 cvmx_read_csr(CVMX_PIP_PRT_TAGX(port)); 661 pip_prt_tagx.s.grp = pow_receive_group; 662 cvmx_write_csr(CVMX_PIP_PRT_TAGX(port), 663 pip_prt_tagx.u64); 664 } 665 } 666 667 cvmx_helper_ipd_and_packet_input_enable(); 668 669 memset(cvm_oct_device, 0, sizeof(cvm_oct_device)); 670 671 /* 672 * Initialize the FAU used for counting packet buffers that 673 * need to be freed. 674 */ 675 cvmx_fau_atomic_write32(FAU_NUM_PACKET_BUFFERS_TO_FREE, 0); 676 677 /* Initialize the FAU used for counting tx SKBs that need to be freed */ 678 cvmx_fau_atomic_write32(FAU_TOTAL_TX_TO_CLEAN, 0); 679 680 if ((pow_send_group != -1)) { 681 struct net_device *dev; 682 pr_info("\tConfiguring device for POW only access\n"); 683 dev = alloc_etherdev(sizeof(struct octeon_ethernet)); 684 if (dev) { 685 /* Initialize the device private structure. */ 686 struct octeon_ethernet *priv = netdev_priv(dev); 687 688 dev->netdev_ops = &cvm_oct_pow_netdev_ops; 689 priv->imode = CVMX_HELPER_INTERFACE_MODE_DISABLED; 690 priv->port = CVMX_PIP_NUM_INPUT_PORTS; 691 priv->queue = -1; 692 strcpy(dev->name, "pow%d"); 693 for (qos = 0; qos < 16; qos++) 694 skb_queue_head_init(&priv->tx_free_list[qos]); 695 696 if (register_netdev(dev) < 0) { 697 pr_err("Failed to register ethernet device for POW\n"); 698 free_netdev(dev); 699 } else { 700 cvm_oct_device[CVMX_PIP_NUM_INPUT_PORTS] = dev; 701 pr_info("%s: POW send group %d, receive group %d\n", 702 dev->name, pow_send_group, 703 pow_receive_group); 704 } 705 } else { 706 pr_err("Failed to allocate ethernet device for POW\n"); 707 } 708 } 709 710 num_interfaces = cvmx_helper_get_number_of_interfaces(); 711 for (interface = 0; interface < num_interfaces; interface++) { 712 cvmx_helper_interface_mode_t imode = 713 cvmx_helper_interface_get_mode(interface); 714 int num_ports = cvmx_helper_ports_on_interface(interface); 715 int port; 716 int port_index; 717 718 for (port_index = 0, 719 port = cvmx_helper_get_ipd_port(interface, 0); 720 port < cvmx_helper_get_ipd_port(interface, num_ports); 721 port_index++, port++) { 722 struct octeon_ethernet *priv; 723 struct net_device *dev = 724 alloc_etherdev(sizeof(struct octeon_ethernet)); 725 if (!dev) { 726 pr_err("Failed to allocate ethernet device for port %d\n", port); 727 continue; 728 } 729 730 /* Initialize the device private structure. */ 731 priv = netdev_priv(dev); 732 priv->of_node = cvm_oct_node_for_port(pip, interface, 733 port_index); 734 735 INIT_DELAYED_WORK(&priv->port_periodic_work, 736 cvm_oct_periodic_worker); 737 priv->imode = imode; 738 priv->port = port; 739 priv->queue = cvmx_pko_get_base_queue(priv->port); 740 priv->fau = fau - cvmx_pko_get_num_queues(port) * 4; 741 for (qos = 0; qos < 16; qos++) 742 skb_queue_head_init(&priv->tx_free_list[qos]); 743 for (qos = 0; qos < cvmx_pko_get_num_queues(port); 744 qos++) 745 cvmx_fau_atomic_write32(priv->fau + qos * 4, 0); 746 747 switch (priv->imode) { 748 749 /* These types don't support ports to IPD/PKO */ 750 case CVMX_HELPER_INTERFACE_MODE_DISABLED: 751 case CVMX_HELPER_INTERFACE_MODE_PCIE: 752 case CVMX_HELPER_INTERFACE_MODE_PICMG: 753 break; 754 755 case CVMX_HELPER_INTERFACE_MODE_NPI: 756 dev->netdev_ops = &cvm_oct_npi_netdev_ops; 757 strcpy(dev->name, "npi%d"); 758 break; 759 760 case CVMX_HELPER_INTERFACE_MODE_XAUI: 761 dev->netdev_ops = &cvm_oct_xaui_netdev_ops; 762 strcpy(dev->name, "xaui%d"); 763 break; 764 765 case CVMX_HELPER_INTERFACE_MODE_LOOP: 766 dev->netdev_ops = &cvm_oct_npi_netdev_ops; 767 strcpy(dev->name, "loop%d"); 768 break; 769 770 case CVMX_HELPER_INTERFACE_MODE_SGMII: 771 dev->netdev_ops = &cvm_oct_sgmii_netdev_ops; 772 strcpy(dev->name, "eth%d"); 773 break; 774 775 case CVMX_HELPER_INTERFACE_MODE_SPI: 776 dev->netdev_ops = &cvm_oct_spi_netdev_ops; 777 strcpy(dev->name, "spi%d"); 778 break; 779 780 case CVMX_HELPER_INTERFACE_MODE_RGMII: 781 case CVMX_HELPER_INTERFACE_MODE_GMII: 782 dev->netdev_ops = &cvm_oct_rgmii_netdev_ops; 783 strcpy(dev->name, "eth%d"); 784 break; 785 } 786 787 if (!dev->netdev_ops) { 788 free_netdev(dev); 789 } else if (register_netdev(dev) < 0) { 790 pr_err("Failed to register ethernet device " 791 "for interface %d, port %d\n", 792 interface, priv->port); 793 free_netdev(dev); 794 } else { 795 cvm_oct_device[priv->port] = dev; 796 fau -= 797 cvmx_pko_get_num_queues(priv->port) * 798 sizeof(uint32_t); 799 queue_delayed_work(cvm_oct_poll_queue, 800 &priv->port_periodic_work, HZ); 801 } 802 } 803 } 804 805 cvm_oct_tx_initialize(); 806 cvm_oct_rx_initialize(); 807 808 /* 809 * 150 uS: about 10 1500-byte packtes at 1GE. 810 */ 811 cvm_oct_tx_poll_interval = 150 * (octeon_get_clock_rate() / 1000000); 812 813 queue_delayed_work(cvm_oct_poll_queue, &cvm_oct_rx_refill_work, HZ); 814 815 return 0; 816} 817 818static int cvm_oct_remove(struct platform_device *pdev) 819{ 820 int port; 821 822 /* Disable POW interrupt */ 823 cvmx_write_csr(CVMX_POW_WQ_INT_THRX(pow_receive_group), 0); 824 825 cvmx_ipd_disable(); 826 827 /* Free the interrupt handler */ 828 free_irq(OCTEON_IRQ_WORKQ0 + pow_receive_group, cvm_oct_device); 829 830 atomic_inc_return(&cvm_oct_poll_queue_stopping); 831 cancel_delayed_work_sync(&cvm_oct_rx_refill_work); 832 833 cvm_oct_rx_shutdown(); 834 cvm_oct_tx_shutdown(); 835 836 cvmx_pko_disable(); 837 838 /* Free the ethernet devices */ 839 for (port = 0; port < TOTAL_NUMBER_OF_PORTS; port++) { 840 if (cvm_oct_device[port]) { 841 struct net_device *dev = cvm_oct_device[port]; 842 struct octeon_ethernet *priv = netdev_priv(dev); 843 cancel_delayed_work_sync(&priv->port_periodic_work); 844 845 cvm_oct_tx_shutdown_dev(dev); 846 unregister_netdev(dev); 847 free_netdev(dev); 848 cvm_oct_device[port] = NULL; 849 } 850 } 851 852 destroy_workqueue(cvm_oct_poll_queue); 853 854 cvmx_pko_shutdown(); 855 856 cvmx_ipd_free_ptr(); 857 858 /* Free the HW pools */ 859 cvm_oct_mem_empty_fpa(CVMX_FPA_PACKET_POOL, CVMX_FPA_PACKET_POOL_SIZE, 860 num_packet_buffers); 861 cvm_oct_mem_empty_fpa(CVMX_FPA_WQE_POOL, CVMX_FPA_WQE_POOL_SIZE, 862 num_packet_buffers); 863 if (CVMX_FPA_OUTPUT_BUFFER_POOL != CVMX_FPA_PACKET_POOL) 864 cvm_oct_mem_empty_fpa(CVMX_FPA_OUTPUT_BUFFER_POOL, 865 CVMX_FPA_OUTPUT_BUFFER_POOL_SIZE, 128); 866 return 0; 867} 868 869static struct of_device_id cvm_oct_match[] = { 870 { 871 .compatible = "cavium,octeon-3860-pip", 872 }, 873 {}, 874}; 875MODULE_DEVICE_TABLE(of, cvm_oct_match); 876 877static struct platform_driver cvm_oct_driver = { 878 .probe = cvm_oct_probe, 879 .remove = cvm_oct_remove, 880 .driver = { 881 .owner = THIS_MODULE, 882 .name = KBUILD_MODNAME, 883 .of_match_table = cvm_oct_match, 884 }, 885}; 886 887module_platform_driver(cvm_oct_driver); 888 889MODULE_LICENSE("GPL"); 890MODULE_AUTHOR("Cavium Networks <support@caviumnetworks.com>"); 891MODULE_DESCRIPTION("Cavium Networks Octeon ethernet driver."); 892