2 * This file is based on code from OCTEON SDK by Cavium Networks.
4 * Copyright (c) 2003-2007 Cavium Networks
6 * This file is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License, Version 2, as
8 * published by the Free Software Foundation.
11 #include <linux/platform_device.h>
12 #include <linux/kernel.h>
13 #include <linux/module.h>
14 #include <linux/netdevice.h>
15 #include <linux/etherdevice.h>
16 #include <linux/phy.h>
17 #include <linux/slab.h>
18 #include <linux/interrupt.h>
19 #include <linux/of_net.h>
23 #include <asm/octeon/octeon.h>
25 #include "ethernet-defines.h"
26 #include "octeon-ethernet.h"
27 #include "ethernet-mem.h"
28 #include "ethernet-rx.h"
29 #include "ethernet-tx.h"
30 #include "ethernet-mdio.h"
31 #include "ethernet-util.h"
33 #include <asm/octeon/cvmx-pip.h>
34 #include <asm/octeon/cvmx-pko.h>
35 #include <asm/octeon/cvmx-fau.h>
36 #include <asm/octeon/cvmx-ipd.h>
37 #include <asm/octeon/cvmx-helper.h>
38 #include <asm/octeon/cvmx-asxx-defs.h>
39 #include <asm/octeon/cvmx-gmxx-defs.h>
40 #include <asm/octeon/cvmx-smix-defs.h>
42 static int num_packet_buffers = 1024;
43 module_param(num_packet_buffers, int, 0444);
44 MODULE_PARM_DESC(num_packet_buffers, "\n"
45 "\tNumber of packet buffers to allocate and store in the\n"
46 "\tFPA. By default, 1024 packet buffers are used.\n");
48 static int pow_receive_group = 15;
49 module_param(pow_receive_group, int, 0444);
50 MODULE_PARM_DESC(pow_receive_group, "\n"
51 "\tPOW group to receive packets from. All ethernet hardware\n"
52 "\twill be configured to send incoming packets to this POW\n"
53 "\tgroup. Also any other software can submit packets to this\n"
54 "\tgroup for the kernel to process.");
56 static int receive_group_order;
57 module_param(receive_group_order, int, 0444);
58 MODULE_PARM_DESC(receive_group_order, "\n"
59 "\tOrder (0..4) of receive groups to take into use. Ethernet hardware\n"
60 "\twill be configured to send incoming packets to multiple POW\n"
61 "\tgroups. pow_receive_group parameter is ignored when multiple\n"
62 "\tgroups are taken into use and groups are allocated starting\n"
63 "\tfrom 0. By default, a single group is used.\n");
65 int pow_send_group = -1;
66 module_param(pow_send_group, int, 0644);
67 MODULE_PARM_DESC(pow_send_group, "\n"
68 "\tPOW group to send packets to other software on. This\n"
69 "\tcontrols the creation of the virtual device pow0.\n"
70 "\talways_use_pow also depends on this value.");
73 module_param(always_use_pow, int, 0444);
74 MODULE_PARM_DESC(always_use_pow, "\n"
75 "\tWhen set, always send to the pow group. This will cause\n"
76 "\tpackets sent to real ethernet devices to be sent to the\n"
77 "\tPOW group instead of the hardware. Unless some other\n"
78 "\tapplication changes the config, packets will still be\n"
79 "\treceived from the low level hardware. Use this option\n"
80 "\tto allow a CVMX app to intercept all packets from the\n"
81 "\tlinux kernel. You must specify pow_send_group along with\n"
84 char pow_send_list[128] = "";
85 module_param_string(pow_send_list, pow_send_list, sizeof(pow_send_list), 0444);
86 MODULE_PARM_DESC(pow_send_list, "\n"
87 "\tComma separated list of ethernet devices that should use the\n"
88 "\tPOW for transmit instead of the actual ethernet hardware. This\n"
89 "\tis a per port version of always_use_pow. always_use_pow takes\n"
90 "\tprecedence over this list. For example, setting this to\n"
91 "\t\"eth2,spi3,spi7\" would cause these three devices to transmit\n"
92 "\tusing the pow_send_group.");
94 int rx_napi_weight = 32;
95 module_param(rx_napi_weight, int, 0444);
96 MODULE_PARM_DESC(rx_napi_weight, "The NAPI WEIGHT parameter.");
98 /* Mask indicating which receive groups are in use. */
99 int pow_receive_groups;
102 * cvm_oct_poll_queue_stopping - flag to indicate polling should stop.
104 * Set to one right before cvm_oct_poll_queue is destroyed.
106 atomic_t cvm_oct_poll_queue_stopping = ATOMIC_INIT(0);
109 * Array of every ethernet device owned by this driver indexed by
110 * the ipd input port number.
112 struct net_device *cvm_oct_device[TOTAL_NUMBER_OF_PORTS];
114 u64 cvm_oct_tx_poll_interval;
116 static void cvm_oct_rx_refill_worker(struct work_struct *work);
117 static DECLARE_DELAYED_WORK(cvm_oct_rx_refill_work, cvm_oct_rx_refill_worker);
119 static void cvm_oct_rx_refill_worker(struct work_struct *work)
122 * FPA 0 may have been drained, try to refill it if we need
123 * more than num_packet_buffers / 2, otherwise normal receive
124 * processing will refill it. If it were drained, no packets
125 * could be received so cvm_oct_napi_poll would never be
126 * invoked to do the refill.
128 cvm_oct_rx_refill_pool(num_packet_buffers / 2);
130 if (!atomic_read(&cvm_oct_poll_queue_stopping))
131 schedule_delayed_work(&cvm_oct_rx_refill_work, HZ);
134 static void cvm_oct_periodic_worker(struct work_struct *work)
136 struct octeon_ethernet *priv = container_of(work,
137 struct octeon_ethernet,
138 port_periodic_work.work);
141 priv->poll(cvm_oct_device[priv->port]);
143 cvm_oct_device[priv->port]->netdev_ops->ndo_get_stats(
144 cvm_oct_device[priv->port]);
146 if (!atomic_read(&cvm_oct_poll_queue_stopping))
147 schedule_delayed_work(&priv->port_periodic_work, HZ);
150 static void cvm_oct_configure_common_hw(void)
154 cvm_oct_mem_fill_fpa(CVMX_FPA_PACKET_POOL, CVMX_FPA_PACKET_POOL_SIZE,
156 cvm_oct_mem_fill_fpa(CVMX_FPA_WQE_POOL, CVMX_FPA_WQE_POOL_SIZE,
158 if (CVMX_FPA_OUTPUT_BUFFER_POOL != CVMX_FPA_PACKET_POOL)
159 cvm_oct_mem_fill_fpa(CVMX_FPA_OUTPUT_BUFFER_POOL,
160 CVMX_FPA_OUTPUT_BUFFER_POOL_SIZE, 1024);
162 #ifdef __LITTLE_ENDIAN
164 union cvmx_ipd_ctl_status ipd_ctl_status;
166 ipd_ctl_status.u64 = cvmx_read_csr(CVMX_IPD_CTL_STATUS);
167 ipd_ctl_status.s.pkt_lend = 1;
168 ipd_ctl_status.s.wqe_lend = 1;
169 cvmx_write_csr(CVMX_IPD_CTL_STATUS, ipd_ctl_status.u64);
173 cvmx_helper_setup_red(num_packet_buffers / 4, num_packet_buffers / 8);
177 * cvm_oct_free_work- Free a work queue entry
179 * @work_queue_entry: Work queue entry to free
181 * Returns Zero on success, Negative on failure.
183 int cvm_oct_free_work(void *work_queue_entry)
185 cvmx_wqe_t *work = work_queue_entry;
187 int segments = work->word2.s.bufs;
188 union cvmx_buf_ptr segment_ptr = work->packet_ptr;
191 union cvmx_buf_ptr next_ptr = *(union cvmx_buf_ptr *)
192 cvmx_phys_to_ptr(segment_ptr.s.addr - 8);
193 if (unlikely(!segment_ptr.s.i))
194 cvmx_fpa_free(cvm_oct_get_buffer_ptr(segment_ptr),
196 CVMX_FPA_PACKET_POOL_SIZE / 128);
197 segment_ptr = next_ptr;
199 cvmx_fpa_free(work, CVMX_FPA_WQE_POOL, 1);
203 EXPORT_SYMBOL(cvm_oct_free_work);
206 * cvm_oct_common_get_stats - get the low level ethernet statistics
207 * @dev: Device to get the statistics from
209 * Returns Pointer to the statistics
211 static struct net_device_stats *cvm_oct_common_get_stats(struct net_device *dev)
213 cvmx_pip_port_status_t rx_status;
214 cvmx_pko_port_status_t tx_status;
215 struct octeon_ethernet *priv = netdev_priv(dev);
217 if (priv->port < CVMX_PIP_NUM_INPUT_PORTS) {
218 if (octeon_is_simulation()) {
219 /* The simulator doesn't support statistics */
220 memset(&rx_status, 0, sizeof(rx_status));
221 memset(&tx_status, 0, sizeof(tx_status));
223 cvmx_pip_get_port_status(priv->port, 1, &rx_status);
224 cvmx_pko_get_port_status(priv->port, 1, &tx_status);
227 priv->stats.rx_packets += rx_status.inb_packets;
228 priv->stats.tx_packets += tx_status.packets;
229 priv->stats.rx_bytes += rx_status.inb_octets;
230 priv->stats.tx_bytes += tx_status.octets;
231 priv->stats.multicast += rx_status.multicast_packets;
232 priv->stats.rx_crc_errors += rx_status.inb_errors;
233 priv->stats.rx_frame_errors += rx_status.fcs_align_err_packets;
234 priv->stats.rx_dropped += rx_status.dropped_packets;
241 * cvm_oct_common_change_mtu - change the link MTU
242 * @dev: Device to change
243 * @new_mtu: The new MTU
245 * Returns Zero on success
247 static int cvm_oct_common_change_mtu(struct net_device *dev, int new_mtu)
249 struct octeon_ethernet *priv = netdev_priv(dev);
250 int interface = INTERFACE(priv->port);
251 #if IS_ENABLED(CONFIG_VLAN_8021Q)
258 * Limit the MTU to make sure the ethernet packets are between
259 * 64 bytes and 65535 bytes.
261 if ((new_mtu + 14 + 4 + vlan_bytes < 64) ||
262 (new_mtu + 14 + 4 + vlan_bytes > 65392)) {
263 pr_err("MTU must be between %d and %d.\n",
264 64 - 14 - 4 - vlan_bytes, 65392 - 14 - 4 - vlan_bytes);
269 if ((interface < 2) &&
270 (cvmx_helper_interface_get_mode(interface) !=
271 CVMX_HELPER_INTERFACE_MODE_SPI)) {
272 int index = INDEX(priv->port);
273 /* Add ethernet header and FCS, and VLAN if configured. */
274 int max_packet = new_mtu + 14 + 4 + vlan_bytes;
276 if (OCTEON_IS_MODEL(OCTEON_CN3XXX) ||
277 OCTEON_IS_MODEL(OCTEON_CN58XX)) {
278 /* Signal errors on packets larger than the MTU */
279 cvmx_write_csr(CVMX_GMXX_RXX_FRM_MAX(index, interface),
283 * Set the hardware to truncate packets larger
284 * than the MTU and smaller the 64 bytes.
286 union cvmx_pip_frm_len_chkx frm_len_chk;
289 frm_len_chk.s.minlen = 64;
290 frm_len_chk.s.maxlen = max_packet;
291 cvmx_write_csr(CVMX_PIP_FRM_LEN_CHKX(interface),
295 * Set the hardware to truncate packets larger than
296 * the MTU. The jabber register must be set to a
297 * multiple of 8 bytes, so round up.
299 cvmx_write_csr(CVMX_GMXX_RXX_JABBER(index, interface),
300 (max_packet + 7) & ~7u);
306 * cvm_oct_common_set_multicast_list - set the multicast list
307 * @dev: Device to work on
309 static void cvm_oct_common_set_multicast_list(struct net_device *dev)
311 union cvmx_gmxx_prtx_cfg gmx_cfg;
312 struct octeon_ethernet *priv = netdev_priv(dev);
313 int interface = INTERFACE(priv->port);
315 if ((interface < 2) &&
316 (cvmx_helper_interface_get_mode(interface) !=
317 CVMX_HELPER_INTERFACE_MODE_SPI)) {
318 union cvmx_gmxx_rxx_adr_ctl control;
319 int index = INDEX(priv->port);
322 control.s.bcst = 1; /* Allow broadcast MAC addresses */
324 if (!netdev_mc_empty(dev) || (dev->flags & IFF_ALLMULTI) ||
325 (dev->flags & IFF_PROMISC))
326 /* Force accept multicast packets */
329 /* Force reject multicast packets */
332 if (dev->flags & IFF_PROMISC)
334 * Reject matches if promisc. Since CAM is
335 * shut off, should accept everything.
337 control.s.cam_mode = 0;
339 /* Filter packets based on the CAM */
340 control.s.cam_mode = 1;
343 cvmx_read_csr(CVMX_GMXX_PRTX_CFG(index, interface));
344 cvmx_write_csr(CVMX_GMXX_PRTX_CFG(index, interface),
345 gmx_cfg.u64 & ~1ull);
347 cvmx_write_csr(CVMX_GMXX_RXX_ADR_CTL(index, interface),
349 if (dev->flags & IFF_PROMISC)
350 cvmx_write_csr(CVMX_GMXX_RXX_ADR_CAM_EN
351 (index, interface), 0);
353 cvmx_write_csr(CVMX_GMXX_RXX_ADR_CAM_EN
354 (index, interface), 1);
356 cvmx_write_csr(CVMX_GMXX_PRTX_CFG(index, interface),
361 static int cvm_oct_set_mac_filter(struct net_device *dev)
363 struct octeon_ethernet *priv = netdev_priv(dev);
364 union cvmx_gmxx_prtx_cfg gmx_cfg;
365 int interface = INTERFACE(priv->port);
367 if ((interface < 2) &&
368 (cvmx_helper_interface_get_mode(interface) !=
369 CVMX_HELPER_INTERFACE_MODE_SPI)) {
371 u8 *ptr = dev->dev_addr;
373 int index = INDEX(priv->port);
375 for (i = 0; i < 6; i++)
376 mac = (mac << 8) | (u64)ptr[i];
379 cvmx_read_csr(CVMX_GMXX_PRTX_CFG(index, interface));
380 cvmx_write_csr(CVMX_GMXX_PRTX_CFG(index, interface),
381 gmx_cfg.u64 & ~1ull);
383 cvmx_write_csr(CVMX_GMXX_SMACX(index, interface), mac);
384 cvmx_write_csr(CVMX_GMXX_RXX_ADR_CAM0(index, interface),
386 cvmx_write_csr(CVMX_GMXX_RXX_ADR_CAM1(index, interface),
388 cvmx_write_csr(CVMX_GMXX_RXX_ADR_CAM2(index, interface),
390 cvmx_write_csr(CVMX_GMXX_RXX_ADR_CAM3(index, interface),
392 cvmx_write_csr(CVMX_GMXX_RXX_ADR_CAM4(index, interface),
394 cvmx_write_csr(CVMX_GMXX_RXX_ADR_CAM5(index, interface),
396 cvm_oct_common_set_multicast_list(dev);
397 cvmx_write_csr(CVMX_GMXX_PRTX_CFG(index, interface),
404 * cvm_oct_common_set_mac_address - set the hardware MAC address for a device
405 * @dev: The device in question.
406 * @addr: Socket address.
408 * Returns Zero on success
410 static int cvm_oct_common_set_mac_address(struct net_device *dev, void *addr)
412 int r = eth_mac_addr(dev, addr);
416 return cvm_oct_set_mac_filter(dev);
420 * cvm_oct_common_init - per network device initialization
421 * @dev: Device to initialize
423 * Returns Zero on success
425 int cvm_oct_common_init(struct net_device *dev)
427 struct octeon_ethernet *priv = netdev_priv(dev);
428 const u8 *mac = NULL;
431 mac = of_get_mac_address(priv->of_node);
434 ether_addr_copy(dev->dev_addr, mac);
436 eth_hw_addr_random(dev);
439 * Force the interface to use the POW send if always_use_pow
440 * was specified or it is in the pow send list.
442 if ((pow_send_group != -1) &&
443 (always_use_pow || strstr(pow_send_list, dev->name)))
446 if (priv->queue != -1)
447 dev->features |= NETIF_F_SG | NETIF_F_IP_CSUM;
449 /* We do our own locking, Linux doesn't need to */
450 dev->features |= NETIF_F_LLTX;
451 dev->ethtool_ops = &cvm_oct_ethtool_ops;
453 cvm_oct_set_mac_filter(dev);
454 dev->netdev_ops->ndo_change_mtu(dev, dev->mtu);
457 * Zero out stats for port so we won't mistakenly show
458 * counters from the bootloader.
460 memset(dev->netdev_ops->ndo_get_stats(dev), 0,
461 sizeof(struct net_device_stats));
463 if (dev->netdev_ops->ndo_stop)
464 dev->netdev_ops->ndo_stop(dev);
469 void cvm_oct_common_uninit(struct net_device *dev)
472 phy_disconnect(dev->phydev);
475 int cvm_oct_common_open(struct net_device *dev,
476 void (*link_poll)(struct net_device *))
478 union cvmx_gmxx_prtx_cfg gmx_cfg;
479 struct octeon_ethernet *priv = netdev_priv(dev);
480 int interface = INTERFACE(priv->port);
481 int index = INDEX(priv->port);
482 cvmx_helper_link_info_t link_info;
485 rv = cvm_oct_phy_setup_device(dev);
489 gmx_cfg.u64 = cvmx_read_csr(CVMX_GMXX_PRTX_CFG(index, interface));
491 if (octeon_has_feature(OCTEON_FEATURE_PKND))
492 gmx_cfg.s.pknd = priv->port;
493 cvmx_write_csr(CVMX_GMXX_PRTX_CFG(index, interface), gmx_cfg.u64);
495 if (octeon_is_simulation())
499 int r = phy_read_status(dev->phydev);
501 if (r == 0 && dev->phydev->link == 0)
502 netif_carrier_off(dev);
503 cvm_oct_adjust_link(dev);
505 link_info = cvmx_helper_link_get(priv->port);
506 if (!link_info.s.link_up)
507 netif_carrier_off(dev);
508 priv->poll = link_poll;
515 void cvm_oct_link_poll(struct net_device *dev)
517 struct octeon_ethernet *priv = netdev_priv(dev);
518 cvmx_helper_link_info_t link_info;
520 link_info = cvmx_helper_link_get(priv->port);
521 if (link_info.u64 == priv->link_info)
524 link_info = cvmx_helper_link_autoconf(priv->port);
525 priv->link_info = link_info.u64;
527 if (link_info.s.link_up) {
528 if (!netif_carrier_ok(dev))
529 netif_carrier_on(dev);
530 } else if (netif_carrier_ok(dev)) {
531 netif_carrier_off(dev);
533 cvm_oct_note_carrier(priv, link_info);
536 static int cvm_oct_xaui_open(struct net_device *dev)
538 return cvm_oct_common_open(dev, cvm_oct_link_poll);
541 static const struct net_device_ops cvm_oct_npi_netdev_ops = {
542 .ndo_init = cvm_oct_common_init,
543 .ndo_uninit = cvm_oct_common_uninit,
544 .ndo_start_xmit = cvm_oct_xmit,
545 .ndo_set_rx_mode = cvm_oct_common_set_multicast_list,
546 .ndo_set_mac_address = cvm_oct_common_set_mac_address,
547 .ndo_do_ioctl = cvm_oct_ioctl,
548 .ndo_change_mtu = cvm_oct_common_change_mtu,
549 .ndo_get_stats = cvm_oct_common_get_stats,
550 #ifdef CONFIG_NET_POLL_CONTROLLER
551 .ndo_poll_controller = cvm_oct_poll_controller,
555 static const struct net_device_ops cvm_oct_xaui_netdev_ops = {
556 .ndo_init = cvm_oct_common_init,
557 .ndo_uninit = cvm_oct_common_uninit,
558 .ndo_open = cvm_oct_xaui_open,
559 .ndo_stop = cvm_oct_common_stop,
560 .ndo_start_xmit = cvm_oct_xmit,
561 .ndo_set_rx_mode = cvm_oct_common_set_multicast_list,
562 .ndo_set_mac_address = cvm_oct_common_set_mac_address,
563 .ndo_do_ioctl = cvm_oct_ioctl,
564 .ndo_change_mtu = cvm_oct_common_change_mtu,
565 .ndo_get_stats = cvm_oct_common_get_stats,
566 #ifdef CONFIG_NET_POLL_CONTROLLER
567 .ndo_poll_controller = cvm_oct_poll_controller,
571 static const struct net_device_ops cvm_oct_sgmii_netdev_ops = {
572 .ndo_init = cvm_oct_sgmii_init,
573 .ndo_uninit = cvm_oct_common_uninit,
574 .ndo_open = cvm_oct_sgmii_open,
575 .ndo_stop = cvm_oct_common_stop,
576 .ndo_start_xmit = cvm_oct_xmit,
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,
587 static const struct net_device_ops cvm_oct_spi_netdev_ops = {
588 .ndo_init = cvm_oct_spi_init,
589 .ndo_uninit = cvm_oct_spi_uninit,
590 .ndo_start_xmit = cvm_oct_xmit,
591 .ndo_set_rx_mode = cvm_oct_common_set_multicast_list,
592 .ndo_set_mac_address = cvm_oct_common_set_mac_address,
593 .ndo_do_ioctl = cvm_oct_ioctl,
594 .ndo_change_mtu = cvm_oct_common_change_mtu,
595 .ndo_get_stats = cvm_oct_common_get_stats,
596 #ifdef CONFIG_NET_POLL_CONTROLLER
597 .ndo_poll_controller = cvm_oct_poll_controller,
601 static const struct net_device_ops cvm_oct_rgmii_netdev_ops = {
602 .ndo_init = cvm_oct_common_init,
603 .ndo_uninit = cvm_oct_common_uninit,
604 .ndo_open = cvm_oct_rgmii_open,
605 .ndo_stop = cvm_oct_common_stop,
606 .ndo_start_xmit = cvm_oct_xmit,
607 .ndo_set_rx_mode = cvm_oct_common_set_multicast_list,
608 .ndo_set_mac_address = cvm_oct_common_set_mac_address,
609 .ndo_do_ioctl = cvm_oct_ioctl,
610 .ndo_change_mtu = cvm_oct_common_change_mtu,
611 .ndo_get_stats = cvm_oct_common_get_stats,
612 #ifdef CONFIG_NET_POLL_CONTROLLER
613 .ndo_poll_controller = cvm_oct_poll_controller,
617 static const struct net_device_ops cvm_oct_pow_netdev_ops = {
618 .ndo_init = cvm_oct_common_init,
619 .ndo_start_xmit = cvm_oct_xmit_pow,
620 .ndo_set_rx_mode = cvm_oct_common_set_multicast_list,
621 .ndo_set_mac_address = cvm_oct_common_set_mac_address,
622 .ndo_do_ioctl = cvm_oct_ioctl,
623 .ndo_change_mtu = cvm_oct_common_change_mtu,
624 .ndo_get_stats = cvm_oct_common_get_stats,
625 #ifdef CONFIG_NET_POLL_CONTROLLER
626 .ndo_poll_controller = cvm_oct_poll_controller,
630 static struct device_node *cvm_oct_of_get_child(
631 const struct device_node *parent, int reg_val)
633 struct device_node *node = NULL;
638 node = of_get_next_child(parent, node);
641 addr = of_get_property(node, "reg", &size);
642 if (addr && (be32_to_cpu(*addr) == reg_val))
648 static struct device_node *cvm_oct_node_for_port(struct device_node *pip,
649 int interface, int port)
651 struct device_node *ni, *np;
653 ni = cvm_oct_of_get_child(pip, interface);
657 np = cvm_oct_of_get_child(ni, port);
663 static void cvm_set_rgmii_delay(struct device_node *np, int iface, int port)
667 if (!of_property_read_u32(np, "rx-delay", &delay_value))
668 cvmx_write_csr(CVMX_ASXX_RX_CLK_SETX(port, iface), delay_value);
669 if (!of_property_read_u32(np, "tx-delay", &delay_value))
670 cvmx_write_csr(CVMX_ASXX_TX_CLK_SETX(port, iface), delay_value);
673 static int cvm_oct_probe(struct platform_device *pdev)
677 int fau = FAU_NUM_PACKET_BUFFERS_TO_FREE;
679 struct device_node *pip;
681 octeon_mdiobus_force_mod_depencency();
683 pip = pdev->dev.of_node;
685 pr_err("Error: No 'pip' in /aliases\n");
690 cvm_oct_configure_common_hw();
692 cvmx_helper_initialize_packet_io_global();
694 if (receive_group_order) {
695 if (receive_group_order > 4)
696 receive_group_order = 4;
697 pow_receive_groups = (1 << (1 << receive_group_order)) - 1;
699 pow_receive_groups = BIT(pow_receive_group);
702 /* Change the input group for all ports before input is enabled */
703 num_interfaces = cvmx_helper_get_number_of_interfaces();
704 for (interface = 0; interface < num_interfaces; interface++) {
705 int num_ports = cvmx_helper_ports_on_interface(interface);
708 for (port = cvmx_helper_get_ipd_port(interface, 0);
709 port < cvmx_helper_get_ipd_port(interface, num_ports);
711 union cvmx_pip_prt_tagx pip_prt_tagx;
714 cvmx_read_csr(CVMX_PIP_PRT_TAGX(port));
716 if (receive_group_order) {
719 /* We support only 16 groups at the moment, so
720 * always disable the two additional "hidden"
721 * tag_mask bits on CN68XX.
723 if (OCTEON_IS_MODEL(OCTEON_CN68XX))
724 pip_prt_tagx.u64 |= 0x3ull << 44;
726 tag_mask = ~((1 << receive_group_order) - 1);
727 pip_prt_tagx.s.grptagbase = 0;
728 pip_prt_tagx.s.grptagmask = tag_mask;
729 pip_prt_tagx.s.grptag = 1;
730 pip_prt_tagx.s.tag_mode = 0;
731 pip_prt_tagx.s.inc_prt_flag = 1;
732 pip_prt_tagx.s.ip6_dprt_flag = 1;
733 pip_prt_tagx.s.ip4_dprt_flag = 1;
734 pip_prt_tagx.s.ip6_sprt_flag = 1;
735 pip_prt_tagx.s.ip4_sprt_flag = 1;
736 pip_prt_tagx.s.ip6_dst_flag = 1;
737 pip_prt_tagx.s.ip4_dst_flag = 1;
738 pip_prt_tagx.s.ip6_src_flag = 1;
739 pip_prt_tagx.s.ip4_src_flag = 1;
740 pip_prt_tagx.s.grp = 0;
742 pip_prt_tagx.s.grptag = 0;
743 pip_prt_tagx.s.grp = pow_receive_group;
746 cvmx_write_csr(CVMX_PIP_PRT_TAGX(port),
751 cvmx_helper_ipd_and_packet_input_enable();
753 memset(cvm_oct_device, 0, sizeof(cvm_oct_device));
756 * Initialize the FAU used for counting packet buffers that
759 cvmx_fau_atomic_write32(FAU_NUM_PACKET_BUFFERS_TO_FREE, 0);
761 /* Initialize the FAU used for counting tx SKBs that need to be freed */
762 cvmx_fau_atomic_write32(FAU_TOTAL_TX_TO_CLEAN, 0);
764 if ((pow_send_group != -1)) {
765 struct net_device *dev;
767 dev = alloc_etherdev(sizeof(struct octeon_ethernet));
769 /* Initialize the device private structure. */
770 struct octeon_ethernet *priv = netdev_priv(dev);
772 dev->netdev_ops = &cvm_oct_pow_netdev_ops;
773 priv->imode = CVMX_HELPER_INTERFACE_MODE_DISABLED;
774 priv->port = CVMX_PIP_NUM_INPUT_PORTS;
776 strcpy(dev->name, "pow%d");
777 for (qos = 0; qos < 16; qos++)
778 skb_queue_head_init(&priv->tx_free_list[qos]);
780 if (register_netdev(dev) < 0) {
781 pr_err("Failed to register ethernet device for POW\n");
784 cvm_oct_device[CVMX_PIP_NUM_INPUT_PORTS] = dev;
785 pr_info("%s: POW send group %d, receive group %d\n",
786 dev->name, pow_send_group,
790 pr_err("Failed to allocate ethernet device for POW\n");
794 num_interfaces = cvmx_helper_get_number_of_interfaces();
795 for (interface = 0; interface < num_interfaces; interface++) {
796 cvmx_helper_interface_mode_t imode =
797 cvmx_helper_interface_get_mode(interface);
798 int num_ports = cvmx_helper_ports_on_interface(interface);
803 port = cvmx_helper_get_ipd_port(interface, 0);
804 port < cvmx_helper_get_ipd_port(interface, num_ports);
805 port_index++, port++) {
806 struct octeon_ethernet *priv;
807 struct net_device *dev =
808 alloc_etherdev(sizeof(struct octeon_ethernet));
810 pr_err("Failed to allocate ethernet device for port %d\n",
815 /* Initialize the device private structure. */
816 priv = netdev_priv(dev);
818 priv->of_node = cvm_oct_node_for_port(pip, interface,
821 INIT_DELAYED_WORK(&priv->port_periodic_work,
822 cvm_oct_periodic_worker);
825 priv->queue = cvmx_pko_get_base_queue(priv->port);
826 priv->fau = fau - cvmx_pko_get_num_queues(port) * 4;
827 for (qos = 0; qos < 16; qos++)
828 skb_queue_head_init(&priv->tx_free_list[qos]);
829 for (qos = 0; qos < cvmx_pko_get_num_queues(port);
831 cvmx_fau_atomic_write32(priv->fau + qos * 4, 0);
833 switch (priv->imode) {
834 /* These types don't support ports to IPD/PKO */
835 case CVMX_HELPER_INTERFACE_MODE_DISABLED:
836 case CVMX_HELPER_INTERFACE_MODE_PCIE:
837 case CVMX_HELPER_INTERFACE_MODE_PICMG:
840 case CVMX_HELPER_INTERFACE_MODE_NPI:
841 dev->netdev_ops = &cvm_oct_npi_netdev_ops;
842 strcpy(dev->name, "npi%d");
845 case CVMX_HELPER_INTERFACE_MODE_XAUI:
846 dev->netdev_ops = &cvm_oct_xaui_netdev_ops;
847 strcpy(dev->name, "xaui%d");
850 case CVMX_HELPER_INTERFACE_MODE_LOOP:
851 dev->netdev_ops = &cvm_oct_npi_netdev_ops;
852 strcpy(dev->name, "loop%d");
855 case CVMX_HELPER_INTERFACE_MODE_SGMII:
856 dev->netdev_ops = &cvm_oct_sgmii_netdev_ops;
857 strcpy(dev->name, "eth%d");
860 case CVMX_HELPER_INTERFACE_MODE_SPI:
861 dev->netdev_ops = &cvm_oct_spi_netdev_ops;
862 strcpy(dev->name, "spi%d");
865 case CVMX_HELPER_INTERFACE_MODE_RGMII:
866 case CVMX_HELPER_INTERFACE_MODE_GMII:
867 dev->netdev_ops = &cvm_oct_rgmii_netdev_ops;
868 strcpy(dev->name, "eth%d");
869 cvm_set_rgmii_delay(priv->of_node, interface,
874 if (!dev->netdev_ops) {
876 } else if (register_netdev(dev) < 0) {
877 pr_err("Failed to register ethernet device for interface %d, port %d\n",
878 interface, priv->port);
881 cvm_oct_device[priv->port] = dev;
883 cvmx_pko_get_num_queues(priv->port) *
885 schedule_delayed_work(&priv->port_periodic_work, HZ);
890 cvm_oct_tx_initialize();
891 cvm_oct_rx_initialize();
894 * 150 uS: about 10 1500-byte packets at 1GE.
896 cvm_oct_tx_poll_interval = 150 * (octeon_get_clock_rate() / 1000000);
898 schedule_delayed_work(&cvm_oct_rx_refill_work, HZ);
903 static int cvm_oct_remove(struct platform_device *pdev)
909 atomic_inc_return(&cvm_oct_poll_queue_stopping);
910 cancel_delayed_work_sync(&cvm_oct_rx_refill_work);
912 cvm_oct_rx_shutdown();
913 cvm_oct_tx_shutdown();
917 /* Free the ethernet devices */
918 for (port = 0; port < TOTAL_NUMBER_OF_PORTS; port++) {
919 if (cvm_oct_device[port]) {
920 struct net_device *dev = cvm_oct_device[port];
921 struct octeon_ethernet *priv = netdev_priv(dev);
923 cancel_delayed_work_sync(&priv->port_periodic_work);
925 cvm_oct_tx_shutdown_dev(dev);
926 unregister_netdev(dev);
928 cvm_oct_device[port] = NULL;
937 /* Free the HW pools */
938 cvm_oct_mem_empty_fpa(CVMX_FPA_PACKET_POOL, CVMX_FPA_PACKET_POOL_SIZE,
940 cvm_oct_mem_empty_fpa(CVMX_FPA_WQE_POOL, CVMX_FPA_WQE_POOL_SIZE,
942 if (CVMX_FPA_OUTPUT_BUFFER_POOL != CVMX_FPA_PACKET_POOL)
943 cvm_oct_mem_empty_fpa(CVMX_FPA_OUTPUT_BUFFER_POOL,
944 CVMX_FPA_OUTPUT_BUFFER_POOL_SIZE, 128);
948 static const struct of_device_id cvm_oct_match[] = {
950 .compatible = "cavium,octeon-3860-pip",
954 MODULE_DEVICE_TABLE(of, cvm_oct_match);
956 static struct platform_driver cvm_oct_driver = {
957 .probe = cvm_oct_probe,
958 .remove = cvm_oct_remove,
960 .name = KBUILD_MODNAME,
961 .of_match_table = cvm_oct_match,
965 module_platform_driver(cvm_oct_driver);
967 MODULE_LICENSE("GPL");
968 MODULE_AUTHOR("Cavium Networks <support@caviumnetworks.com>");
969 MODULE_DESCRIPTION("Cavium Networks Octeon ethernet driver.");