1 /**********************************************************************
2 * Author: Cavium Networks
4 * Contact: support@caviumnetworks.com
5 * This file is part of the OCTEON SDK
7 * Copyright (c) 2003-2007 Cavium Networks
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.
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
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/.
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/module.h>
30 #include <linux/netdevice.h>
31 #include <linux/etherdevice.h>
32 #include <linux/phy.h>
33 #include <linux/slab.h>
34 #include <linux/interrupt.h>
35 #include <linux/of_net.h>
39 #include <asm/octeon/octeon.h>
41 #include "ethernet-defines.h"
42 #include "octeon-ethernet.h"
43 #include "ethernet-mem.h"
44 #include "ethernet-rx.h"
45 #include "ethernet-tx.h"
46 #include "ethernet-mdio.h"
47 #include "ethernet-util.h"
49 #include <asm/octeon/cvmx-pip.h>
50 #include <asm/octeon/cvmx-pko.h>
51 #include <asm/octeon/cvmx-fau.h>
52 #include <asm/octeon/cvmx-ipd.h>
53 #include <asm/octeon/cvmx-helper.h>
55 #include <asm/octeon/cvmx-gmxx-defs.h>
56 #include <asm/octeon/cvmx-smix-defs.h>
58 static int num_packet_buffers = 1024;
59 module_param(num_packet_buffers, int, 0444);
60 MODULE_PARM_DESC(num_packet_buffers, "\n"
61 "\tNumber of packet buffers to allocate and store in the\n"
62 "\tFPA. By default, 1024 packet buffers are used.\n");
64 int pow_receive_group = 15;
65 module_param(pow_receive_group, int, 0444);
66 MODULE_PARM_DESC(pow_receive_group, "\n"
67 "\tPOW group to receive packets from. All ethernet hardware\n"
68 "\twill be configured to send incoming packets to this POW\n"
69 "\tgroup. Also any other software can submit packets to this\n"
70 "\tgroup for the kernel to process.");
72 int pow_send_group = -1;
73 module_param(pow_send_group, int, 0644);
74 MODULE_PARM_DESC(pow_send_group, "\n"
75 "\tPOW group to send packets to other software on. This\n"
76 "\tcontrols the creation of the virtual device pow0.\n"
77 "\talways_use_pow also depends on this value.");
80 module_param(always_use_pow, int, 0444);
81 MODULE_PARM_DESC(always_use_pow, "\n"
82 "\tWhen set, always send to the pow group. This will cause\n"
83 "\tpackets sent to real ethernet devices to be sent to the\n"
84 "\tPOW group instead of the hardware. Unless some other\n"
85 "\tapplication changes the config, packets will still be\n"
86 "\treceived from the low level hardware. Use this option\n"
87 "\tto allow a CVMX app to intercept all packets from the\n"
88 "\tlinux kernel. You must specify pow_send_group along with\n"
91 char pow_send_list[128] = "";
92 module_param_string(pow_send_list, pow_send_list, sizeof(pow_send_list), 0444);
93 MODULE_PARM_DESC(pow_send_list, "\n"
94 "\tComma separated list of ethernet devices that should use the\n"
95 "\tPOW for transmit instead of the actual ethernet hardware. This\n"
96 "\tis a per port version of always_use_pow. always_use_pow takes\n"
97 "\tprecedence over this list. For example, setting this to\n"
98 "\t\"eth2,spi3,spi7\" would cause these three devices to transmit\n"
99 "\tusing the pow_send_group.");
101 int rx_napi_weight = 32;
102 module_param(rx_napi_weight, int, 0444);
103 MODULE_PARM_DESC(rx_napi_weight, "The NAPI WEIGHT parameter.");
106 * cvm_oct_poll_queue - Workqueue for polling operations.
108 struct workqueue_struct *cvm_oct_poll_queue;
111 * cvm_oct_poll_queue_stopping - flag to indicate polling should stop.
113 * Set to one right before cvm_oct_poll_queue is destroyed.
115 atomic_t cvm_oct_poll_queue_stopping = ATOMIC_INIT(0);
118 * Array of every ethernet device owned by this driver indexed by
119 * the ipd input port number.
121 struct net_device *cvm_oct_device[TOTAL_NUMBER_OF_PORTS];
123 u64 cvm_oct_tx_poll_interval;
125 static void cvm_oct_rx_refill_worker(struct work_struct *work);
126 static DECLARE_DELAYED_WORK(cvm_oct_rx_refill_work, cvm_oct_rx_refill_worker);
128 static void cvm_oct_rx_refill_worker(struct work_struct *work)
131 * FPA 0 may have been drained, try to refill it if we need
132 * more than num_packet_buffers / 2, otherwise normal receive
133 * processing will refill it. If it were drained, no packets
134 * could be received so cvm_oct_napi_poll would never be
135 * invoked to do the refill.
137 cvm_oct_rx_refill_pool(num_packet_buffers / 2);
139 if (!atomic_read(&cvm_oct_poll_queue_stopping))
140 queue_delayed_work(cvm_oct_poll_queue,
141 &cvm_oct_rx_refill_work, HZ);
144 static void cvm_oct_periodic_worker(struct work_struct *work)
146 struct octeon_ethernet *priv = container_of(work,
147 struct octeon_ethernet,
148 port_periodic_work.work);
151 priv->poll(cvm_oct_device[priv->port]);
153 cvm_oct_device[priv->port]->netdev_ops->ndo_get_stats(
154 cvm_oct_device[priv->port]);
156 if (!atomic_read(&cvm_oct_poll_queue_stopping))
157 queue_delayed_work(cvm_oct_poll_queue,
158 &priv->port_periodic_work, HZ);
161 static void cvm_oct_configure_common_hw(void)
165 cvm_oct_mem_fill_fpa(CVMX_FPA_PACKET_POOL, CVMX_FPA_PACKET_POOL_SIZE,
167 cvm_oct_mem_fill_fpa(CVMX_FPA_WQE_POOL, CVMX_FPA_WQE_POOL_SIZE,
169 if (CVMX_FPA_OUTPUT_BUFFER_POOL != CVMX_FPA_PACKET_POOL)
170 cvm_oct_mem_fill_fpa(CVMX_FPA_OUTPUT_BUFFER_POOL,
171 CVMX_FPA_OUTPUT_BUFFER_POOL_SIZE, 128);
173 #ifdef __LITTLE_ENDIAN
175 union cvmx_ipd_ctl_status ipd_ctl_status;
176 ipd_ctl_status.u64 = cvmx_read_csr(CVMX_IPD_CTL_STATUS);
177 ipd_ctl_status.s.pkt_lend = 1;
178 ipd_ctl_status.s.wqe_lend = 1;
179 cvmx_write_csr(CVMX_IPD_CTL_STATUS, ipd_ctl_status.u64);
184 cvmx_helper_setup_red(num_packet_buffers / 4,
185 num_packet_buffers / 8);
190 * cvm_oct_free_work- Free a work queue entry
192 * @work_queue_entry: Work queue entry to free
194 * Returns Zero on success, Negative on failure.
196 int cvm_oct_free_work(void *work_queue_entry)
198 cvmx_wqe_t *work = work_queue_entry;
200 int segments = work->word2.s.bufs;
201 union cvmx_buf_ptr segment_ptr = work->packet_ptr;
204 union cvmx_buf_ptr next_ptr = *(union cvmx_buf_ptr *)
205 cvmx_phys_to_ptr(segment_ptr.s.addr - 8);
206 if (unlikely(!segment_ptr.s.i))
207 cvmx_fpa_free(cvm_oct_get_buffer_ptr(segment_ptr),
209 DONT_WRITEBACK(CVMX_FPA_PACKET_POOL_SIZE /
211 segment_ptr = next_ptr;
213 cvmx_fpa_free(work, CVMX_FPA_WQE_POOL, DONT_WRITEBACK(1));
217 EXPORT_SYMBOL(cvm_oct_free_work);
220 * cvm_oct_common_get_stats - get the low level ethernet statistics
221 * @dev: Device to get the statistics from
223 * Returns Pointer to the statistics
225 static struct net_device_stats *cvm_oct_common_get_stats(struct net_device *dev)
227 cvmx_pip_port_status_t rx_status;
228 cvmx_pko_port_status_t tx_status;
229 struct octeon_ethernet *priv = netdev_priv(dev);
231 if (priv->port < CVMX_PIP_NUM_INPUT_PORTS) {
232 if (octeon_is_simulation()) {
233 /* The simulator doesn't support statistics */
234 memset(&rx_status, 0, sizeof(rx_status));
235 memset(&tx_status, 0, sizeof(tx_status));
237 cvmx_pip_get_port_status(priv->port, 1, &rx_status);
238 cvmx_pko_get_port_status(priv->port, 1, &tx_status);
241 priv->stats.rx_packets += rx_status.inb_packets;
242 priv->stats.tx_packets += tx_status.packets;
243 priv->stats.rx_bytes += rx_status.inb_octets;
244 priv->stats.tx_bytes += tx_status.octets;
245 priv->stats.multicast += rx_status.multicast_packets;
246 priv->stats.rx_crc_errors += rx_status.inb_errors;
247 priv->stats.rx_frame_errors += rx_status.fcs_align_err_packets;
250 * The drop counter must be incremented atomically
251 * since the RX tasklet also increments it.
254 atomic64_add(rx_status.dropped_packets,
255 (atomic64_t *)&priv->stats.rx_dropped);
257 atomic_add(rx_status.dropped_packets,
258 (atomic_t *)&priv->stats.rx_dropped);
266 * cvm_oct_common_change_mtu - change the link MTU
267 * @dev: Device to change
268 * @new_mtu: The new MTU
270 * Returns Zero on success
272 static int cvm_oct_common_change_mtu(struct net_device *dev, int new_mtu)
274 struct octeon_ethernet *priv = netdev_priv(dev);
275 int interface = INTERFACE(priv->port);
276 int index = INDEX(priv->port);
277 #if defined(CONFIG_VLAN_8021Q) || defined(CONFIG_VLAN_8021Q_MODULE)
284 * Limit the MTU to make sure the ethernet packets are between
285 * 64 bytes and 65535 bytes.
287 if ((new_mtu + 14 + 4 + vlan_bytes < 64)
288 || (new_mtu + 14 + 4 + vlan_bytes > 65392)) {
289 pr_err("MTU must be between %d and %d.\n",
290 64 - 14 - 4 - vlan_bytes, 65392 - 14 - 4 - vlan_bytes);
296 && (cvmx_helper_interface_get_mode(interface) !=
297 CVMX_HELPER_INTERFACE_MODE_SPI)) {
298 /* Add ethernet header and FCS, and VLAN if configured. */
299 int max_packet = new_mtu + 14 + 4 + vlan_bytes;
301 if (OCTEON_IS_MODEL(OCTEON_CN3XXX)
302 || OCTEON_IS_MODEL(OCTEON_CN58XX)) {
303 /* Signal errors on packets larger than the MTU */
304 cvmx_write_csr(CVMX_GMXX_RXX_FRM_MAX(index, interface),
308 * Set the hardware to truncate packets larger
309 * than the MTU and smaller the 64 bytes.
311 union cvmx_pip_frm_len_chkx frm_len_chk;
314 frm_len_chk.s.minlen = 64;
315 frm_len_chk.s.maxlen = max_packet;
316 cvmx_write_csr(CVMX_PIP_FRM_LEN_CHKX(interface),
320 * Set the hardware to truncate packets larger than
321 * the MTU. The jabber register must be set to a
322 * multiple of 8 bytes, so round up.
324 cvmx_write_csr(CVMX_GMXX_RXX_JABBER(index, interface),
325 (max_packet + 7) & ~7u);
331 * cvm_oct_common_set_multicast_list - set the multicast list
332 * @dev: Device to work on
334 static void cvm_oct_common_set_multicast_list(struct net_device *dev)
336 union cvmx_gmxx_prtx_cfg gmx_cfg;
337 struct octeon_ethernet *priv = netdev_priv(dev);
338 int interface = INTERFACE(priv->port);
339 int index = INDEX(priv->port);
342 && (cvmx_helper_interface_get_mode(interface) !=
343 CVMX_HELPER_INTERFACE_MODE_SPI)) {
344 union cvmx_gmxx_rxx_adr_ctl control;
347 control.s.bcst = 1; /* Allow broadcast MAC addresses */
349 if (!netdev_mc_empty(dev) || (dev->flags & IFF_ALLMULTI) ||
350 (dev->flags & IFF_PROMISC))
351 /* Force accept multicast packets */
354 /* Force reject multicast packets */
357 if (dev->flags & IFF_PROMISC)
359 * Reject matches if promisc. Since CAM is
360 * shut off, should accept everything.
362 control.s.cam_mode = 0;
364 /* Filter packets based on the CAM */
365 control.s.cam_mode = 1;
368 cvmx_read_csr(CVMX_GMXX_PRTX_CFG(index, interface));
369 cvmx_write_csr(CVMX_GMXX_PRTX_CFG(index, interface),
370 gmx_cfg.u64 & ~1ull);
372 cvmx_write_csr(CVMX_GMXX_RXX_ADR_CTL(index, interface),
374 if (dev->flags & IFF_PROMISC)
375 cvmx_write_csr(CVMX_GMXX_RXX_ADR_CAM_EN
376 (index, interface), 0);
378 cvmx_write_csr(CVMX_GMXX_RXX_ADR_CAM_EN
379 (index, interface), 1);
381 cvmx_write_csr(CVMX_GMXX_PRTX_CFG(index, interface),
387 * cvm_oct_common_set_mac_address - set the hardware MAC address for a device
388 * @dev: The device in question.
389 * @addr: Address structure to change it too.
391 * Returns Zero on success
393 static int cvm_oct_set_mac_filter(struct net_device *dev)
395 struct octeon_ethernet *priv = netdev_priv(dev);
396 union cvmx_gmxx_prtx_cfg gmx_cfg;
397 int interface = INTERFACE(priv->port);
398 int index = INDEX(priv->port);
401 && (cvmx_helper_interface_get_mode(interface) !=
402 CVMX_HELPER_INTERFACE_MODE_SPI)) {
404 uint8_t *ptr = dev->dev_addr;
407 for (i = 0; i < 6; i++)
408 mac = (mac << 8) | (uint64_t)ptr[i];
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);
415 cvmx_write_csr(CVMX_GMXX_SMACX(index, interface), mac);
416 cvmx_write_csr(CVMX_GMXX_RXX_ADR_CAM0(index, interface),
418 cvmx_write_csr(CVMX_GMXX_RXX_ADR_CAM1(index, interface),
420 cvmx_write_csr(CVMX_GMXX_RXX_ADR_CAM2(index, interface),
422 cvmx_write_csr(CVMX_GMXX_RXX_ADR_CAM3(index, interface),
424 cvmx_write_csr(CVMX_GMXX_RXX_ADR_CAM4(index, interface),
426 cvmx_write_csr(CVMX_GMXX_RXX_ADR_CAM5(index, interface),
428 cvm_oct_common_set_multicast_list(dev);
429 cvmx_write_csr(CVMX_GMXX_PRTX_CFG(index, interface),
435 static int cvm_oct_common_set_mac_address(struct net_device *dev, void *addr)
437 int r = eth_mac_addr(dev, addr);
441 return cvm_oct_set_mac_filter(dev);
445 * cvm_oct_common_init - per network device initialization
446 * @dev: Device to initialize
448 * Returns Zero on success
450 int cvm_oct_common_init(struct net_device *dev)
452 struct octeon_ethernet *priv = netdev_priv(dev);
453 const u8 *mac = NULL;
456 mac = of_get_mac_address(priv->of_node);
459 ether_addr_copy(dev->dev_addr, mac);
461 eth_hw_addr_random(dev);
464 * Force the interface to use the POW send if always_use_pow
465 * was specified or it is in the pow send list.
467 if ((pow_send_group != -1)
468 && (always_use_pow || strstr(pow_send_list, dev->name)))
471 if (priv->queue != -1) {
472 dev->features |= NETIF_F_SG;
473 if (USE_HW_TCPUDP_CHECKSUM)
474 dev->features |= NETIF_F_IP_CSUM;
477 /* We do our own locking, Linux doesn't need to */
478 dev->features |= NETIF_F_LLTX;
479 dev->ethtool_ops = &cvm_oct_ethtool_ops;
481 cvm_oct_set_mac_filter(dev);
482 dev->netdev_ops->ndo_change_mtu(dev, dev->mtu);
485 * Zero out stats for port so we won't mistakenly show
486 * counters from the bootloader.
488 memset(dev->netdev_ops->ndo_get_stats(dev), 0,
489 sizeof(struct net_device_stats));
491 if (dev->netdev_ops->ndo_stop)
492 dev->netdev_ops->ndo_stop(dev);
497 void cvm_oct_common_uninit(struct net_device *dev)
499 struct octeon_ethernet *priv = netdev_priv(dev);
502 phy_disconnect(priv->phydev);
505 int cvm_oct_common_open(struct net_device *dev,
506 void (*link_poll)(struct net_device *), bool poll_now)
508 union cvmx_gmxx_prtx_cfg gmx_cfg;
509 struct octeon_ethernet *priv = netdev_priv(dev);
510 int interface = INTERFACE(priv->port);
511 int index = INDEX(priv->port);
512 cvmx_helper_link_info_t link_info;
515 rv = cvm_oct_phy_setup_device(dev);
519 gmx_cfg.u64 = cvmx_read_csr(CVMX_GMXX_PRTX_CFG(index, interface));
521 cvmx_write_csr(CVMX_GMXX_PRTX_CFG(index, interface), gmx_cfg.u64);
523 if (octeon_is_simulation())
527 int r = phy_read_status(priv->phydev);
529 if (r == 0 && priv->phydev->link == 0)
530 netif_carrier_off(dev);
531 cvm_oct_adjust_link(dev);
533 link_info = cvmx_helper_link_get(priv->port);
534 if (!link_info.s.link_up)
535 netif_carrier_off(dev);
536 priv->poll = link_poll;
544 void cvm_oct_link_poll(struct net_device *dev)
546 struct octeon_ethernet *priv = netdev_priv(dev);
547 cvmx_helper_link_info_t link_info;
549 link_info = cvmx_helper_link_get(priv->port);
550 if (link_info.u64 == priv->link_info)
553 link_info = cvmx_helper_link_autoconf(priv->port);
554 priv->link_info = link_info.u64;
556 if (link_info.s.link_up) {
557 if (!netif_carrier_ok(dev))
558 netif_carrier_on(dev);
559 } else if (netif_carrier_ok(dev)) {
560 netif_carrier_off(dev);
562 cvm_oct_note_carrier(priv, link_info);
565 static const struct net_device_ops cvm_oct_npi_netdev_ops = {
566 .ndo_init = cvm_oct_common_init,
567 .ndo_uninit = cvm_oct_common_uninit,
568 .ndo_start_xmit = cvm_oct_xmit,
569 .ndo_set_rx_mode = cvm_oct_common_set_multicast_list,
570 .ndo_set_mac_address = cvm_oct_common_set_mac_address,
571 .ndo_do_ioctl = cvm_oct_ioctl,
572 .ndo_change_mtu = cvm_oct_common_change_mtu,
573 .ndo_get_stats = cvm_oct_common_get_stats,
574 #ifdef CONFIG_NET_POLL_CONTROLLER
575 .ndo_poll_controller = cvm_oct_poll_controller,
578 static const struct net_device_ops cvm_oct_xaui_netdev_ops = {
579 .ndo_init = cvm_oct_xaui_init,
580 .ndo_uninit = cvm_oct_common_uninit,
581 .ndo_open = cvm_oct_xaui_open,
582 .ndo_stop = cvm_oct_common_stop,
583 .ndo_start_xmit = cvm_oct_xmit,
584 .ndo_set_rx_mode = cvm_oct_common_set_multicast_list,
585 .ndo_set_mac_address = cvm_oct_common_set_mac_address,
586 .ndo_do_ioctl = cvm_oct_ioctl,
587 .ndo_change_mtu = cvm_oct_common_change_mtu,
588 .ndo_get_stats = cvm_oct_common_get_stats,
589 #ifdef CONFIG_NET_POLL_CONTROLLER
590 .ndo_poll_controller = cvm_oct_poll_controller,
593 static const struct net_device_ops cvm_oct_sgmii_netdev_ops = {
594 .ndo_init = cvm_oct_sgmii_init,
595 .ndo_uninit = cvm_oct_common_uninit,
596 .ndo_open = cvm_oct_sgmii_open,
597 .ndo_stop = cvm_oct_common_stop,
598 .ndo_start_xmit = cvm_oct_xmit,
599 .ndo_set_rx_mode = cvm_oct_common_set_multicast_list,
600 .ndo_set_mac_address = cvm_oct_common_set_mac_address,
601 .ndo_do_ioctl = cvm_oct_ioctl,
602 .ndo_change_mtu = cvm_oct_common_change_mtu,
603 .ndo_get_stats = cvm_oct_common_get_stats,
604 #ifdef CONFIG_NET_POLL_CONTROLLER
605 .ndo_poll_controller = cvm_oct_poll_controller,
608 static const struct net_device_ops cvm_oct_spi_netdev_ops = {
609 .ndo_init = cvm_oct_spi_init,
610 .ndo_uninit = cvm_oct_spi_uninit,
611 .ndo_start_xmit = cvm_oct_xmit,
612 .ndo_set_rx_mode = cvm_oct_common_set_multicast_list,
613 .ndo_set_mac_address = cvm_oct_common_set_mac_address,
614 .ndo_do_ioctl = cvm_oct_ioctl,
615 .ndo_change_mtu = cvm_oct_common_change_mtu,
616 .ndo_get_stats = cvm_oct_common_get_stats,
617 #ifdef CONFIG_NET_POLL_CONTROLLER
618 .ndo_poll_controller = cvm_oct_poll_controller,
621 static const struct net_device_ops cvm_oct_rgmii_netdev_ops = {
622 .ndo_init = cvm_oct_rgmii_init,
623 .ndo_uninit = cvm_oct_rgmii_uninit,
624 .ndo_open = cvm_oct_rgmii_open,
625 .ndo_stop = cvm_oct_common_stop,
626 .ndo_start_xmit = cvm_oct_xmit,
627 .ndo_set_rx_mode = cvm_oct_common_set_multicast_list,
628 .ndo_set_mac_address = cvm_oct_common_set_mac_address,
629 .ndo_do_ioctl = cvm_oct_ioctl,
630 .ndo_change_mtu = cvm_oct_common_change_mtu,
631 .ndo_get_stats = cvm_oct_common_get_stats,
632 #ifdef CONFIG_NET_POLL_CONTROLLER
633 .ndo_poll_controller = cvm_oct_poll_controller,
636 static const struct net_device_ops cvm_oct_pow_netdev_ops = {
637 .ndo_init = cvm_oct_common_init,
638 .ndo_start_xmit = cvm_oct_xmit_pow,
639 .ndo_set_rx_mode = cvm_oct_common_set_multicast_list,
640 .ndo_set_mac_address = cvm_oct_common_set_mac_address,
641 .ndo_do_ioctl = cvm_oct_ioctl,
642 .ndo_change_mtu = cvm_oct_common_change_mtu,
643 .ndo_get_stats = cvm_oct_common_get_stats,
644 #ifdef CONFIG_NET_POLL_CONTROLLER
645 .ndo_poll_controller = cvm_oct_poll_controller,
649 static struct device_node *cvm_oct_of_get_child(
650 const struct device_node *parent, int reg_val)
652 struct device_node *node = NULL;
657 node = of_get_next_child(parent, node);
660 addr = of_get_property(node, "reg", &size);
661 if (addr && (be32_to_cpu(*addr) == reg_val))
667 static struct device_node *cvm_oct_node_for_port(struct device_node *pip,
668 int interface, int port)
670 struct device_node *ni, *np;
672 ni = cvm_oct_of_get_child(pip, interface);
676 np = cvm_oct_of_get_child(ni, port);
682 static int cvm_oct_probe(struct platform_device *pdev)
686 int fau = FAU_NUM_PACKET_BUFFERS_TO_FREE;
688 struct device_node *pip;
690 octeon_mdiobus_force_mod_depencency();
691 pr_notice("cavium-ethernet %s\n", OCTEON_ETHERNET_VERSION);
693 pip = pdev->dev.of_node;
695 pr_err("Error: No 'pip' in /aliases\n");
699 cvm_oct_poll_queue = create_singlethread_workqueue("octeon-ethernet");
700 if (cvm_oct_poll_queue == NULL) {
701 pr_err("octeon-ethernet: Cannot create workqueue");
705 cvm_oct_configure_common_hw();
707 cvmx_helper_initialize_packet_io_global();
709 /* Change the input group for all ports before input is enabled */
710 num_interfaces = cvmx_helper_get_number_of_interfaces();
711 for (interface = 0; interface < num_interfaces; interface++) {
712 int num_ports = cvmx_helper_ports_on_interface(interface);
715 for (port = cvmx_helper_get_ipd_port(interface, 0);
716 port < cvmx_helper_get_ipd_port(interface, num_ports);
718 union cvmx_pip_prt_tagx pip_prt_tagx;
721 cvmx_read_csr(CVMX_PIP_PRT_TAGX(port));
722 pip_prt_tagx.s.grp = pow_receive_group;
723 cvmx_write_csr(CVMX_PIP_PRT_TAGX(port),
728 cvmx_helper_ipd_and_packet_input_enable();
730 memset(cvm_oct_device, 0, sizeof(cvm_oct_device));
733 * Initialize the FAU used for counting packet buffers that
736 cvmx_fau_atomic_write32(FAU_NUM_PACKET_BUFFERS_TO_FREE, 0);
738 /* Initialize the FAU used for counting tx SKBs that need to be freed */
739 cvmx_fau_atomic_write32(FAU_TOTAL_TX_TO_CLEAN, 0);
741 if ((pow_send_group != -1)) {
742 struct net_device *dev;
744 pr_info("\tConfiguring device for POW only access\n");
745 dev = alloc_etherdev(sizeof(struct octeon_ethernet));
747 /* Initialize the device private structure. */
748 struct octeon_ethernet *priv = netdev_priv(dev);
750 dev->netdev_ops = &cvm_oct_pow_netdev_ops;
751 priv->imode = CVMX_HELPER_INTERFACE_MODE_DISABLED;
752 priv->port = CVMX_PIP_NUM_INPUT_PORTS;
754 strcpy(dev->name, "pow%d");
755 for (qos = 0; qos < 16; qos++)
756 skb_queue_head_init(&priv->tx_free_list[qos]);
758 if (register_netdev(dev) < 0) {
759 pr_err("Failed to register ethernet device for POW\n");
762 cvm_oct_device[CVMX_PIP_NUM_INPUT_PORTS] = dev;
763 pr_info("%s: POW send group %d, receive group %d\n",
764 dev->name, pow_send_group,
768 pr_err("Failed to allocate ethernet device for POW\n");
772 num_interfaces = cvmx_helper_get_number_of_interfaces();
773 for (interface = 0; interface < num_interfaces; interface++) {
774 cvmx_helper_interface_mode_t imode =
775 cvmx_helper_interface_get_mode(interface);
776 int num_ports = cvmx_helper_ports_on_interface(interface);
781 port = cvmx_helper_get_ipd_port(interface, 0);
782 port < cvmx_helper_get_ipd_port(interface, num_ports);
783 port_index++, port++) {
784 struct octeon_ethernet *priv;
785 struct net_device *dev =
786 alloc_etherdev(sizeof(struct octeon_ethernet));
788 pr_err("Failed to allocate ethernet device for port %d\n",
793 /* Initialize the device private structure. */
794 priv = netdev_priv(dev);
796 priv->of_node = cvm_oct_node_for_port(pip, interface,
799 INIT_DELAYED_WORK(&priv->port_periodic_work,
800 cvm_oct_periodic_worker);
803 priv->queue = cvmx_pko_get_base_queue(priv->port);
804 priv->fau = fau - cvmx_pko_get_num_queues(port) * 4;
805 for (qos = 0; qos < 16; qos++)
806 skb_queue_head_init(&priv->tx_free_list[qos]);
807 for (qos = 0; qos < cvmx_pko_get_num_queues(port);
809 cvmx_fau_atomic_write32(priv->fau + qos * 4, 0);
811 switch (priv->imode) {
813 /* These types don't support ports to IPD/PKO */
814 case CVMX_HELPER_INTERFACE_MODE_DISABLED:
815 case CVMX_HELPER_INTERFACE_MODE_PCIE:
816 case CVMX_HELPER_INTERFACE_MODE_PICMG:
819 case CVMX_HELPER_INTERFACE_MODE_NPI:
820 dev->netdev_ops = &cvm_oct_npi_netdev_ops;
821 strcpy(dev->name, "npi%d");
824 case CVMX_HELPER_INTERFACE_MODE_XAUI:
825 dev->netdev_ops = &cvm_oct_xaui_netdev_ops;
826 strcpy(dev->name, "xaui%d");
829 case CVMX_HELPER_INTERFACE_MODE_LOOP:
830 dev->netdev_ops = &cvm_oct_npi_netdev_ops;
831 strcpy(dev->name, "loop%d");
834 case CVMX_HELPER_INTERFACE_MODE_SGMII:
835 dev->netdev_ops = &cvm_oct_sgmii_netdev_ops;
836 strcpy(dev->name, "eth%d");
839 case CVMX_HELPER_INTERFACE_MODE_SPI:
840 dev->netdev_ops = &cvm_oct_spi_netdev_ops;
841 strcpy(dev->name, "spi%d");
844 case CVMX_HELPER_INTERFACE_MODE_RGMII:
845 case CVMX_HELPER_INTERFACE_MODE_GMII:
846 dev->netdev_ops = &cvm_oct_rgmii_netdev_ops;
847 strcpy(dev->name, "eth%d");
851 if (!dev->netdev_ops) {
853 } else if (register_netdev(dev) < 0) {
854 pr_err("Failed to register ethernet device for interface %d, port %d\n",
855 interface, priv->port);
858 cvm_oct_device[priv->port] = dev;
860 cvmx_pko_get_num_queues(priv->port) *
862 queue_delayed_work(cvm_oct_poll_queue,
863 &priv->port_periodic_work, HZ);
868 cvm_oct_tx_initialize();
869 cvm_oct_rx_initialize();
872 * 150 uS: about 10 1500-byte packets at 1GE.
874 cvm_oct_tx_poll_interval = 150 * (octeon_get_clock_rate() / 1000000);
876 queue_delayed_work(cvm_oct_poll_queue, &cvm_oct_rx_refill_work, HZ);
881 static int cvm_oct_remove(struct platform_device *pdev)
885 /* Disable POW interrupt */
886 cvmx_write_csr(CVMX_POW_WQ_INT_THRX(pow_receive_group), 0);
890 /* Free the interrupt handler */
891 free_irq(OCTEON_IRQ_WORKQ0 + pow_receive_group, cvm_oct_device);
893 atomic_inc_return(&cvm_oct_poll_queue_stopping);
894 cancel_delayed_work_sync(&cvm_oct_rx_refill_work);
896 cvm_oct_rx_shutdown();
897 cvm_oct_tx_shutdown();
901 /* Free the ethernet devices */
902 for (port = 0; port < TOTAL_NUMBER_OF_PORTS; port++) {
903 if (cvm_oct_device[port]) {
904 struct net_device *dev = cvm_oct_device[port];
905 struct octeon_ethernet *priv = netdev_priv(dev);
907 cancel_delayed_work_sync(&priv->port_periodic_work);
909 cvm_oct_tx_shutdown_dev(dev);
910 unregister_netdev(dev);
912 cvm_oct_device[port] = NULL;
916 destroy_workqueue(cvm_oct_poll_queue);
922 /* Free the HW pools */
923 cvm_oct_mem_empty_fpa(CVMX_FPA_PACKET_POOL, CVMX_FPA_PACKET_POOL_SIZE,
925 cvm_oct_mem_empty_fpa(CVMX_FPA_WQE_POOL, CVMX_FPA_WQE_POOL_SIZE,
927 if (CVMX_FPA_OUTPUT_BUFFER_POOL != CVMX_FPA_PACKET_POOL)
928 cvm_oct_mem_empty_fpa(CVMX_FPA_OUTPUT_BUFFER_POOL,
929 CVMX_FPA_OUTPUT_BUFFER_POOL_SIZE, 128);
933 static const struct of_device_id cvm_oct_match[] = {
935 .compatible = "cavium,octeon-3860-pip",
939 MODULE_DEVICE_TABLE(of, cvm_oct_match);
941 static struct platform_driver cvm_oct_driver = {
942 .probe = cvm_oct_probe,
943 .remove = cvm_oct_remove,
945 .name = KBUILD_MODNAME,
946 .of_match_table = cvm_oct_match,
950 module_platform_driver(cvm_oct_driver);
952 MODULE_LICENSE("GPL");
953 MODULE_AUTHOR("Cavium Networks <support@caviumnetworks.com>");
954 MODULE_DESCRIPTION("Cavium Networks Octeon ethernet driver.");