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 int pow_send_group = -1;
57 module_param(pow_send_group, int, 0644);
58 MODULE_PARM_DESC(pow_send_group, "\n"
59 "\tPOW group to send packets to other software on. This\n"
60 "\tcontrols the creation of the virtual device pow0.\n"
61 "\talways_use_pow also depends on this value.");
64 module_param(always_use_pow, int, 0444);
65 MODULE_PARM_DESC(always_use_pow, "\n"
66 "\tWhen set, always send to the pow group. This will cause\n"
67 "\tpackets sent to real ethernet devices to be sent to the\n"
68 "\tPOW group instead of the hardware. Unless some other\n"
69 "\tapplication changes the config, packets will still be\n"
70 "\treceived from the low level hardware. Use this option\n"
71 "\tto allow a CVMX app to intercept all packets from the\n"
72 "\tlinux kernel. You must specify pow_send_group along with\n"
75 char pow_send_list[128] = "";
76 module_param_string(pow_send_list, pow_send_list, sizeof(pow_send_list), 0444);
77 MODULE_PARM_DESC(pow_send_list, "\n"
78 "\tComma separated list of ethernet devices that should use the\n"
79 "\tPOW for transmit instead of the actual ethernet hardware. This\n"
80 "\tis a per port version of always_use_pow. always_use_pow takes\n"
81 "\tprecedence over this list. For example, setting this to\n"
82 "\t\"eth2,spi3,spi7\" would cause these three devices to transmit\n"
83 "\tusing the pow_send_group.");
85 int rx_napi_weight = 32;
86 module_param(rx_napi_weight, int, 0444);
87 MODULE_PARM_DESC(rx_napi_weight, "The NAPI WEIGHT parameter.");
89 /* Mask indicating which receive groups are in use. */
90 int pow_receive_groups;
93 * cvm_oct_poll_queue_stopping - flag to indicate polling should stop.
95 * Set to one right before cvm_oct_poll_queue is destroyed.
97 atomic_t cvm_oct_poll_queue_stopping = ATOMIC_INIT(0);
100 * Array of every ethernet device owned by this driver indexed by
101 * the ipd input port number.
103 struct net_device *cvm_oct_device[TOTAL_NUMBER_OF_PORTS];
105 u64 cvm_oct_tx_poll_interval;
107 static void cvm_oct_rx_refill_worker(struct work_struct *work);
108 static DECLARE_DELAYED_WORK(cvm_oct_rx_refill_work, cvm_oct_rx_refill_worker);
110 static void cvm_oct_rx_refill_worker(struct work_struct *work)
113 * FPA 0 may have been drained, try to refill it if we need
114 * more than num_packet_buffers / 2, otherwise normal receive
115 * processing will refill it. If it were drained, no packets
116 * could be received so cvm_oct_napi_poll would never be
117 * invoked to do the refill.
119 cvm_oct_rx_refill_pool(num_packet_buffers / 2);
121 if (!atomic_read(&cvm_oct_poll_queue_stopping))
122 schedule_delayed_work(&cvm_oct_rx_refill_work, HZ);
125 static void cvm_oct_periodic_worker(struct work_struct *work)
127 struct octeon_ethernet *priv = container_of(work,
128 struct octeon_ethernet,
129 port_periodic_work.work);
132 priv->poll(cvm_oct_device[priv->port]);
134 cvm_oct_device[priv->port]->netdev_ops->ndo_get_stats(
135 cvm_oct_device[priv->port]);
137 if (!atomic_read(&cvm_oct_poll_queue_stopping))
138 schedule_delayed_work(&priv->port_periodic_work, HZ);
141 static void cvm_oct_configure_common_hw(void)
145 cvm_oct_mem_fill_fpa(CVMX_FPA_PACKET_POOL, CVMX_FPA_PACKET_POOL_SIZE,
147 cvm_oct_mem_fill_fpa(CVMX_FPA_WQE_POOL, CVMX_FPA_WQE_POOL_SIZE,
149 if (CVMX_FPA_OUTPUT_BUFFER_POOL != CVMX_FPA_PACKET_POOL)
150 cvm_oct_mem_fill_fpa(CVMX_FPA_OUTPUT_BUFFER_POOL,
151 CVMX_FPA_OUTPUT_BUFFER_POOL_SIZE, 1024);
153 #ifdef __LITTLE_ENDIAN
155 union cvmx_ipd_ctl_status ipd_ctl_status;
157 ipd_ctl_status.u64 = cvmx_read_csr(CVMX_IPD_CTL_STATUS);
158 ipd_ctl_status.s.pkt_lend = 1;
159 ipd_ctl_status.s.wqe_lend = 1;
160 cvmx_write_csr(CVMX_IPD_CTL_STATUS, ipd_ctl_status.u64);
164 cvmx_helper_setup_red(num_packet_buffers / 4, num_packet_buffers / 8);
168 * cvm_oct_free_work- Free a work queue entry
170 * @work_queue_entry: Work queue entry to free
172 * Returns Zero on success, Negative on failure.
174 int cvm_oct_free_work(void *work_queue_entry)
176 cvmx_wqe_t *work = work_queue_entry;
178 int segments = work->word2.s.bufs;
179 union cvmx_buf_ptr segment_ptr = work->packet_ptr;
182 union cvmx_buf_ptr next_ptr = *(union cvmx_buf_ptr *)
183 cvmx_phys_to_ptr(segment_ptr.s.addr - 8);
184 if (unlikely(!segment_ptr.s.i))
185 cvmx_fpa_free(cvm_oct_get_buffer_ptr(segment_ptr),
187 CVMX_FPA_PACKET_POOL_SIZE / 128);
188 segment_ptr = next_ptr;
190 cvmx_fpa_free(work, CVMX_FPA_WQE_POOL, 1);
194 EXPORT_SYMBOL(cvm_oct_free_work);
197 * cvm_oct_common_get_stats - get the low level ethernet statistics
198 * @dev: Device to get the statistics from
200 * Returns Pointer to the statistics
202 static struct net_device_stats *cvm_oct_common_get_stats(struct net_device *dev)
204 cvmx_pip_port_status_t rx_status;
205 cvmx_pko_port_status_t tx_status;
206 struct octeon_ethernet *priv = netdev_priv(dev);
208 if (priv->port < CVMX_PIP_NUM_INPUT_PORTS) {
209 if (octeon_is_simulation()) {
210 /* The simulator doesn't support statistics */
211 memset(&rx_status, 0, sizeof(rx_status));
212 memset(&tx_status, 0, sizeof(tx_status));
214 cvmx_pip_get_port_status(priv->port, 1, &rx_status);
215 cvmx_pko_get_port_status(priv->port, 1, &tx_status);
218 priv->stats.rx_packets += rx_status.inb_packets;
219 priv->stats.tx_packets += tx_status.packets;
220 priv->stats.rx_bytes += rx_status.inb_octets;
221 priv->stats.tx_bytes += tx_status.octets;
222 priv->stats.multicast += rx_status.multicast_packets;
223 priv->stats.rx_crc_errors += rx_status.inb_errors;
224 priv->stats.rx_frame_errors += rx_status.fcs_align_err_packets;
225 priv->stats.rx_dropped += rx_status.dropped_packets;
232 * cvm_oct_common_change_mtu - change the link MTU
233 * @dev: Device to change
234 * @new_mtu: The new MTU
236 * Returns Zero on success
238 static int cvm_oct_common_change_mtu(struct net_device *dev, int new_mtu)
240 struct octeon_ethernet *priv = netdev_priv(dev);
241 int interface = INTERFACE(priv->port);
242 #if defined(CONFIG_VLAN_8021Q) || defined(CONFIG_VLAN_8021Q_MODULE)
249 * Limit the MTU to make sure the ethernet packets are between
250 * 64 bytes and 65535 bytes.
252 if ((new_mtu + 14 + 4 + vlan_bytes < 64) ||
253 (new_mtu + 14 + 4 + vlan_bytes > 65392)) {
254 pr_err("MTU must be between %d and %d.\n",
255 64 - 14 - 4 - vlan_bytes, 65392 - 14 - 4 - vlan_bytes);
260 if ((interface < 2) &&
261 (cvmx_helper_interface_get_mode(interface) !=
262 CVMX_HELPER_INTERFACE_MODE_SPI)) {
263 int index = INDEX(priv->port);
264 /* Add ethernet header and FCS, and VLAN if configured. */
265 int max_packet = new_mtu + 14 + 4 + vlan_bytes;
267 if (OCTEON_IS_MODEL(OCTEON_CN3XXX) ||
268 OCTEON_IS_MODEL(OCTEON_CN58XX)) {
269 /* Signal errors on packets larger than the MTU */
270 cvmx_write_csr(CVMX_GMXX_RXX_FRM_MAX(index, interface),
274 * Set the hardware to truncate packets larger
275 * than the MTU and smaller the 64 bytes.
277 union cvmx_pip_frm_len_chkx frm_len_chk;
280 frm_len_chk.s.minlen = 64;
281 frm_len_chk.s.maxlen = max_packet;
282 cvmx_write_csr(CVMX_PIP_FRM_LEN_CHKX(interface),
286 * Set the hardware to truncate packets larger than
287 * the MTU. The jabber register must be set to a
288 * multiple of 8 bytes, so round up.
290 cvmx_write_csr(CVMX_GMXX_RXX_JABBER(index, interface),
291 (max_packet + 7) & ~7u);
297 * cvm_oct_common_set_multicast_list - set the multicast list
298 * @dev: Device to work on
300 static void cvm_oct_common_set_multicast_list(struct net_device *dev)
302 union cvmx_gmxx_prtx_cfg gmx_cfg;
303 struct octeon_ethernet *priv = netdev_priv(dev);
304 int interface = INTERFACE(priv->port);
306 if ((interface < 2) &&
307 (cvmx_helper_interface_get_mode(interface) !=
308 CVMX_HELPER_INTERFACE_MODE_SPI)) {
309 union cvmx_gmxx_rxx_adr_ctl control;
310 int index = INDEX(priv->port);
313 control.s.bcst = 1; /* Allow broadcast MAC addresses */
315 if (!netdev_mc_empty(dev) || (dev->flags & IFF_ALLMULTI) ||
316 (dev->flags & IFF_PROMISC))
317 /* Force accept multicast packets */
320 /* Force reject multicast packets */
323 if (dev->flags & IFF_PROMISC)
325 * Reject matches if promisc. Since CAM is
326 * shut off, should accept everything.
328 control.s.cam_mode = 0;
330 /* Filter packets based on the CAM */
331 control.s.cam_mode = 1;
334 cvmx_read_csr(CVMX_GMXX_PRTX_CFG(index, interface));
335 cvmx_write_csr(CVMX_GMXX_PRTX_CFG(index, interface),
336 gmx_cfg.u64 & ~1ull);
338 cvmx_write_csr(CVMX_GMXX_RXX_ADR_CTL(index, interface),
340 if (dev->flags & IFF_PROMISC)
341 cvmx_write_csr(CVMX_GMXX_RXX_ADR_CAM_EN
342 (index, interface), 0);
344 cvmx_write_csr(CVMX_GMXX_RXX_ADR_CAM_EN
345 (index, interface), 1);
347 cvmx_write_csr(CVMX_GMXX_PRTX_CFG(index, interface),
352 static int cvm_oct_set_mac_filter(struct net_device *dev)
354 struct octeon_ethernet *priv = netdev_priv(dev);
355 union cvmx_gmxx_prtx_cfg gmx_cfg;
356 int interface = INTERFACE(priv->port);
358 if ((interface < 2) &&
359 (cvmx_helper_interface_get_mode(interface) !=
360 CVMX_HELPER_INTERFACE_MODE_SPI)) {
362 u8 *ptr = dev->dev_addr;
364 int index = INDEX(priv->port);
366 for (i = 0; i < 6; i++)
367 mac = (mac << 8) | (u64)ptr[i];
370 cvmx_read_csr(CVMX_GMXX_PRTX_CFG(index, interface));
371 cvmx_write_csr(CVMX_GMXX_PRTX_CFG(index, interface),
372 gmx_cfg.u64 & ~1ull);
374 cvmx_write_csr(CVMX_GMXX_SMACX(index, interface), mac);
375 cvmx_write_csr(CVMX_GMXX_RXX_ADR_CAM0(index, interface),
377 cvmx_write_csr(CVMX_GMXX_RXX_ADR_CAM1(index, interface),
379 cvmx_write_csr(CVMX_GMXX_RXX_ADR_CAM2(index, interface),
381 cvmx_write_csr(CVMX_GMXX_RXX_ADR_CAM3(index, interface),
383 cvmx_write_csr(CVMX_GMXX_RXX_ADR_CAM4(index, interface),
385 cvmx_write_csr(CVMX_GMXX_RXX_ADR_CAM5(index, interface),
387 cvm_oct_common_set_multicast_list(dev);
388 cvmx_write_csr(CVMX_GMXX_PRTX_CFG(index, interface),
395 * cvm_oct_common_set_mac_address - set the hardware MAC address for a device
396 * @dev: The device in question.
397 * @addr: Socket address.
399 * Returns Zero on success
401 static int cvm_oct_common_set_mac_address(struct net_device *dev, void *addr)
403 int r = eth_mac_addr(dev, addr);
407 return cvm_oct_set_mac_filter(dev);
411 * cvm_oct_common_init - per network device initialization
412 * @dev: Device to initialize
414 * Returns Zero on success
416 int cvm_oct_common_init(struct net_device *dev)
418 struct octeon_ethernet *priv = netdev_priv(dev);
419 const u8 *mac = NULL;
422 mac = of_get_mac_address(priv->of_node);
425 ether_addr_copy(dev->dev_addr, mac);
427 eth_hw_addr_random(dev);
430 * Force the interface to use the POW send if always_use_pow
431 * was specified or it is in the pow send list.
433 if ((pow_send_group != -1) &&
434 (always_use_pow || strstr(pow_send_list, dev->name)))
437 if (priv->queue != -1)
438 dev->features |= NETIF_F_SG | NETIF_F_IP_CSUM;
440 /* We do our own locking, Linux doesn't need to */
441 dev->features |= NETIF_F_LLTX;
442 dev->ethtool_ops = &cvm_oct_ethtool_ops;
444 cvm_oct_set_mac_filter(dev);
445 dev->netdev_ops->ndo_change_mtu(dev, dev->mtu);
448 * Zero out stats for port so we won't mistakenly show
449 * counters from the bootloader.
451 memset(dev->netdev_ops->ndo_get_stats(dev), 0,
452 sizeof(struct net_device_stats));
454 if (dev->netdev_ops->ndo_stop)
455 dev->netdev_ops->ndo_stop(dev);
460 void cvm_oct_common_uninit(struct net_device *dev)
463 phy_disconnect(dev->phydev);
466 int cvm_oct_common_open(struct net_device *dev,
467 void (*link_poll)(struct net_device *))
469 union cvmx_gmxx_prtx_cfg gmx_cfg;
470 struct octeon_ethernet *priv = netdev_priv(dev);
471 int interface = INTERFACE(priv->port);
472 int index = INDEX(priv->port);
473 cvmx_helper_link_info_t link_info;
476 rv = cvm_oct_phy_setup_device(dev);
480 gmx_cfg.u64 = cvmx_read_csr(CVMX_GMXX_PRTX_CFG(index, interface));
482 cvmx_write_csr(CVMX_GMXX_PRTX_CFG(index, interface), gmx_cfg.u64);
484 if (octeon_is_simulation())
488 int r = phy_read_status(dev->phydev);
490 if (r == 0 && dev->phydev->link == 0)
491 netif_carrier_off(dev);
492 cvm_oct_adjust_link(dev);
494 link_info = cvmx_helper_link_get(priv->port);
495 if (!link_info.s.link_up)
496 netif_carrier_off(dev);
497 priv->poll = link_poll;
504 void cvm_oct_link_poll(struct net_device *dev)
506 struct octeon_ethernet *priv = netdev_priv(dev);
507 cvmx_helper_link_info_t link_info;
509 link_info = cvmx_helper_link_get(priv->port);
510 if (link_info.u64 == priv->link_info)
513 link_info = cvmx_helper_link_autoconf(priv->port);
514 priv->link_info = link_info.u64;
516 if (link_info.s.link_up) {
517 if (!netif_carrier_ok(dev))
518 netif_carrier_on(dev);
519 } else if (netif_carrier_ok(dev)) {
520 netif_carrier_off(dev);
522 cvm_oct_note_carrier(priv, link_info);
525 static int cvm_oct_xaui_open(struct net_device *dev)
527 return cvm_oct_common_open(dev, cvm_oct_link_poll);
530 static const struct net_device_ops cvm_oct_npi_netdev_ops = {
531 .ndo_init = cvm_oct_common_init,
532 .ndo_uninit = cvm_oct_common_uninit,
533 .ndo_start_xmit = cvm_oct_xmit,
534 .ndo_set_rx_mode = cvm_oct_common_set_multicast_list,
535 .ndo_set_mac_address = cvm_oct_common_set_mac_address,
536 .ndo_do_ioctl = cvm_oct_ioctl,
537 .ndo_change_mtu = cvm_oct_common_change_mtu,
538 .ndo_get_stats = cvm_oct_common_get_stats,
539 #ifdef CONFIG_NET_POLL_CONTROLLER
540 .ndo_poll_controller = cvm_oct_poll_controller,
544 static const struct net_device_ops cvm_oct_xaui_netdev_ops = {
545 .ndo_init = cvm_oct_common_init,
546 .ndo_uninit = cvm_oct_common_uninit,
547 .ndo_open = cvm_oct_xaui_open,
548 .ndo_stop = cvm_oct_common_stop,
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,
560 static const struct net_device_ops cvm_oct_sgmii_netdev_ops = {
561 .ndo_init = cvm_oct_sgmii_init,
562 .ndo_uninit = cvm_oct_common_uninit,
563 .ndo_open = cvm_oct_sgmii_open,
564 .ndo_stop = cvm_oct_common_stop,
565 .ndo_start_xmit = cvm_oct_xmit,
566 .ndo_set_rx_mode = cvm_oct_common_set_multicast_list,
567 .ndo_set_mac_address = cvm_oct_common_set_mac_address,
568 .ndo_do_ioctl = cvm_oct_ioctl,
569 .ndo_change_mtu = cvm_oct_common_change_mtu,
570 .ndo_get_stats = cvm_oct_common_get_stats,
571 #ifdef CONFIG_NET_POLL_CONTROLLER
572 .ndo_poll_controller = cvm_oct_poll_controller,
576 static const struct net_device_ops cvm_oct_spi_netdev_ops = {
577 .ndo_init = cvm_oct_spi_init,
578 .ndo_uninit = cvm_oct_spi_uninit,
579 .ndo_start_xmit = cvm_oct_xmit,
580 .ndo_set_rx_mode = cvm_oct_common_set_multicast_list,
581 .ndo_set_mac_address = cvm_oct_common_set_mac_address,
582 .ndo_do_ioctl = cvm_oct_ioctl,
583 .ndo_change_mtu = cvm_oct_common_change_mtu,
584 .ndo_get_stats = cvm_oct_common_get_stats,
585 #ifdef CONFIG_NET_POLL_CONTROLLER
586 .ndo_poll_controller = cvm_oct_poll_controller,
590 static const struct net_device_ops cvm_oct_rgmii_netdev_ops = {
591 .ndo_init = cvm_oct_common_init,
592 .ndo_uninit = cvm_oct_common_uninit,
593 .ndo_open = cvm_oct_rgmii_open,
594 .ndo_stop = cvm_oct_common_stop,
595 .ndo_start_xmit = cvm_oct_xmit,
596 .ndo_set_rx_mode = cvm_oct_common_set_multicast_list,
597 .ndo_set_mac_address = cvm_oct_common_set_mac_address,
598 .ndo_do_ioctl = cvm_oct_ioctl,
599 .ndo_change_mtu = cvm_oct_common_change_mtu,
600 .ndo_get_stats = cvm_oct_common_get_stats,
601 #ifdef CONFIG_NET_POLL_CONTROLLER
602 .ndo_poll_controller = cvm_oct_poll_controller,
606 static const struct net_device_ops cvm_oct_pow_netdev_ops = {
607 .ndo_init = cvm_oct_common_init,
608 .ndo_start_xmit = cvm_oct_xmit_pow,
609 .ndo_set_rx_mode = cvm_oct_common_set_multicast_list,
610 .ndo_set_mac_address = cvm_oct_common_set_mac_address,
611 .ndo_do_ioctl = cvm_oct_ioctl,
612 .ndo_change_mtu = cvm_oct_common_change_mtu,
613 .ndo_get_stats = cvm_oct_common_get_stats,
614 #ifdef CONFIG_NET_POLL_CONTROLLER
615 .ndo_poll_controller = cvm_oct_poll_controller,
619 static struct device_node *cvm_oct_of_get_child(
620 const struct device_node *parent, int reg_val)
622 struct device_node *node = NULL;
627 node = of_get_next_child(parent, node);
630 addr = of_get_property(node, "reg", &size);
631 if (addr && (be32_to_cpu(*addr) == reg_val))
637 static struct device_node *cvm_oct_node_for_port(struct device_node *pip,
638 int interface, int port)
640 struct device_node *ni, *np;
642 ni = cvm_oct_of_get_child(pip, interface);
646 np = cvm_oct_of_get_child(ni, port);
652 static void cvm_set_rgmii_delay(struct device_node *np, int iface, int port)
656 if (!of_property_read_u32(np, "rx-delay", &delay_value))
657 cvmx_write_csr(CVMX_ASXX_RX_CLK_SETX(port, iface), delay_value);
658 if (!of_property_read_u32(np, "tx-delay", &delay_value))
659 cvmx_write_csr(CVMX_ASXX_TX_CLK_SETX(port, iface), delay_value);
662 static int cvm_oct_probe(struct platform_device *pdev)
666 int fau = FAU_NUM_PACKET_BUFFERS_TO_FREE;
668 struct device_node *pip;
670 octeon_mdiobus_force_mod_depencency();
672 pip = pdev->dev.of_node;
674 pr_err("Error: No 'pip' in /aliases\n");
679 cvm_oct_configure_common_hw();
681 cvmx_helper_initialize_packet_io_global();
683 pow_receive_groups = BIT(pow_receive_group);
685 /* Change the input group for all ports before input is enabled */
686 num_interfaces = cvmx_helper_get_number_of_interfaces();
687 for (interface = 0; interface < num_interfaces; interface++) {
688 int num_ports = cvmx_helper_ports_on_interface(interface);
691 for (port = cvmx_helper_get_ipd_port(interface, 0);
692 port < cvmx_helper_get_ipd_port(interface, num_ports);
694 union cvmx_pip_prt_tagx pip_prt_tagx;
697 cvmx_read_csr(CVMX_PIP_PRT_TAGX(port));
698 pip_prt_tagx.s.grp = pow_receive_group;
699 cvmx_write_csr(CVMX_PIP_PRT_TAGX(port),
704 cvmx_helper_ipd_and_packet_input_enable();
706 memset(cvm_oct_device, 0, sizeof(cvm_oct_device));
709 * Initialize the FAU used for counting packet buffers that
712 cvmx_fau_atomic_write32(FAU_NUM_PACKET_BUFFERS_TO_FREE, 0);
714 /* Initialize the FAU used for counting tx SKBs that need to be freed */
715 cvmx_fau_atomic_write32(FAU_TOTAL_TX_TO_CLEAN, 0);
717 if ((pow_send_group != -1)) {
718 struct net_device *dev;
720 dev = alloc_etherdev(sizeof(struct octeon_ethernet));
722 /* Initialize the device private structure. */
723 struct octeon_ethernet *priv = netdev_priv(dev);
725 dev->netdev_ops = &cvm_oct_pow_netdev_ops;
726 priv->imode = CVMX_HELPER_INTERFACE_MODE_DISABLED;
727 priv->port = CVMX_PIP_NUM_INPUT_PORTS;
729 strcpy(dev->name, "pow%d");
730 for (qos = 0; qos < 16; qos++)
731 skb_queue_head_init(&priv->tx_free_list[qos]);
733 if (register_netdev(dev) < 0) {
734 pr_err("Failed to register ethernet device for POW\n");
737 cvm_oct_device[CVMX_PIP_NUM_INPUT_PORTS] = dev;
738 pr_info("%s: POW send group %d, receive group %d\n",
739 dev->name, pow_send_group,
743 pr_err("Failed to allocate ethernet device for POW\n");
747 num_interfaces = cvmx_helper_get_number_of_interfaces();
748 for (interface = 0; interface < num_interfaces; interface++) {
749 cvmx_helper_interface_mode_t imode =
750 cvmx_helper_interface_get_mode(interface);
751 int num_ports = cvmx_helper_ports_on_interface(interface);
756 port = cvmx_helper_get_ipd_port(interface, 0);
757 port < cvmx_helper_get_ipd_port(interface, num_ports);
758 port_index++, port++) {
759 struct octeon_ethernet *priv;
760 struct net_device *dev =
761 alloc_etherdev(sizeof(struct octeon_ethernet));
763 pr_err("Failed to allocate ethernet device for port %d\n",
768 /* Initialize the device private structure. */
769 priv = netdev_priv(dev);
771 priv->of_node = cvm_oct_node_for_port(pip, interface,
774 INIT_DELAYED_WORK(&priv->port_periodic_work,
775 cvm_oct_periodic_worker);
778 priv->queue = cvmx_pko_get_base_queue(priv->port);
779 priv->fau = fau - cvmx_pko_get_num_queues(port) * 4;
780 for (qos = 0; qos < 16; qos++)
781 skb_queue_head_init(&priv->tx_free_list[qos]);
782 for (qos = 0; qos < cvmx_pko_get_num_queues(port);
784 cvmx_fau_atomic_write32(priv->fau + qos * 4, 0);
786 switch (priv->imode) {
787 /* These types don't support ports to IPD/PKO */
788 case CVMX_HELPER_INTERFACE_MODE_DISABLED:
789 case CVMX_HELPER_INTERFACE_MODE_PCIE:
790 case CVMX_HELPER_INTERFACE_MODE_PICMG:
793 case CVMX_HELPER_INTERFACE_MODE_NPI:
794 dev->netdev_ops = &cvm_oct_npi_netdev_ops;
795 strcpy(dev->name, "npi%d");
798 case CVMX_HELPER_INTERFACE_MODE_XAUI:
799 dev->netdev_ops = &cvm_oct_xaui_netdev_ops;
800 strcpy(dev->name, "xaui%d");
803 case CVMX_HELPER_INTERFACE_MODE_LOOP:
804 dev->netdev_ops = &cvm_oct_npi_netdev_ops;
805 strcpy(dev->name, "loop%d");
808 case CVMX_HELPER_INTERFACE_MODE_SGMII:
809 dev->netdev_ops = &cvm_oct_sgmii_netdev_ops;
810 strcpy(dev->name, "eth%d");
813 case CVMX_HELPER_INTERFACE_MODE_SPI:
814 dev->netdev_ops = &cvm_oct_spi_netdev_ops;
815 strcpy(dev->name, "spi%d");
818 case CVMX_HELPER_INTERFACE_MODE_RGMII:
819 case CVMX_HELPER_INTERFACE_MODE_GMII:
820 dev->netdev_ops = &cvm_oct_rgmii_netdev_ops;
821 strcpy(dev->name, "eth%d");
822 cvm_set_rgmii_delay(priv->of_node, interface,
827 if (!dev->netdev_ops) {
829 } else if (register_netdev(dev) < 0) {
830 pr_err("Failed to register ethernet device for interface %d, port %d\n",
831 interface, priv->port);
834 cvm_oct_device[priv->port] = dev;
836 cvmx_pko_get_num_queues(priv->port) *
838 schedule_delayed_work(&priv->port_periodic_work, HZ);
843 cvm_oct_tx_initialize();
844 cvm_oct_rx_initialize();
847 * 150 uS: about 10 1500-byte packets at 1GE.
849 cvm_oct_tx_poll_interval = 150 * (octeon_get_clock_rate() / 1000000);
851 schedule_delayed_work(&cvm_oct_rx_refill_work, HZ);
856 static int cvm_oct_remove(struct platform_device *pdev)
862 atomic_inc_return(&cvm_oct_poll_queue_stopping);
863 cancel_delayed_work_sync(&cvm_oct_rx_refill_work);
865 cvm_oct_rx_shutdown();
866 cvm_oct_tx_shutdown();
870 /* Free the ethernet devices */
871 for (port = 0; port < TOTAL_NUMBER_OF_PORTS; port++) {
872 if (cvm_oct_device[port]) {
873 struct net_device *dev = cvm_oct_device[port];
874 struct octeon_ethernet *priv = netdev_priv(dev);
876 cancel_delayed_work_sync(&priv->port_periodic_work);
878 cvm_oct_tx_shutdown_dev(dev);
879 unregister_netdev(dev);
881 cvm_oct_device[port] = NULL;
890 /* Free the HW pools */
891 cvm_oct_mem_empty_fpa(CVMX_FPA_PACKET_POOL, CVMX_FPA_PACKET_POOL_SIZE,
893 cvm_oct_mem_empty_fpa(CVMX_FPA_WQE_POOL, CVMX_FPA_WQE_POOL_SIZE,
895 if (CVMX_FPA_OUTPUT_BUFFER_POOL != CVMX_FPA_PACKET_POOL)
896 cvm_oct_mem_empty_fpa(CVMX_FPA_OUTPUT_BUFFER_POOL,
897 CVMX_FPA_OUTPUT_BUFFER_POOL_SIZE, 128);
901 static const struct of_device_id cvm_oct_match[] = {
903 .compatible = "cavium,octeon-3860-pip",
907 MODULE_DEVICE_TABLE(of, cvm_oct_match);
909 static struct platform_driver cvm_oct_driver = {
910 .probe = cvm_oct_probe,
911 .remove = cvm_oct_remove,
913 .name = KBUILD_MODNAME,
914 .of_match_table = cvm_oct_match,
918 module_platform_driver(cvm_oct_driver);
920 MODULE_LICENSE("GPL");
921 MODULE_AUTHOR("Cavium Networks <support@caviumnetworks.com>");
922 MODULE_DESCRIPTION("Cavium Networks Octeon ethernet driver.");