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
);
183 cvmx_helper_setup_red(num_packet_buffers
/ 4, num_packet_buffers
/ 8);
187 * cvm_oct_free_work- Free a work queue entry
189 * @work_queue_entry: Work queue entry to free
191 * Returns Zero on success, Negative on failure.
193 int cvm_oct_free_work(void *work_queue_entry
)
195 cvmx_wqe_t
*work
= work_queue_entry
;
197 int segments
= work
->word2
.s
.bufs
;
198 union cvmx_buf_ptr segment_ptr
= work
->packet_ptr
;
201 union cvmx_buf_ptr next_ptr
= *(union cvmx_buf_ptr
*)
202 cvmx_phys_to_ptr(segment_ptr
.s
.addr
- 8);
203 if (unlikely(!segment_ptr
.s
.i
))
204 cvmx_fpa_free(cvm_oct_get_buffer_ptr(segment_ptr
),
206 CVMX_FPA_PACKET_POOL_SIZE
/ 128);
207 segment_ptr
= next_ptr
;
209 cvmx_fpa_free(work
, CVMX_FPA_WQE_POOL
, 1);
213 EXPORT_SYMBOL(cvm_oct_free_work
);
216 * cvm_oct_common_get_stats - get the low level ethernet statistics
217 * @dev: Device to get the statistics from
219 * Returns Pointer to the statistics
221 static struct net_device_stats
*cvm_oct_common_get_stats(struct net_device
*dev
)
223 cvmx_pip_port_status_t rx_status
;
224 cvmx_pko_port_status_t tx_status
;
225 struct octeon_ethernet
*priv
= netdev_priv(dev
);
227 if (priv
->port
< CVMX_PIP_NUM_INPUT_PORTS
) {
228 if (octeon_is_simulation()) {
229 /* The simulator doesn't support statistics */
230 memset(&rx_status
, 0, sizeof(rx_status
));
231 memset(&tx_status
, 0, sizeof(tx_status
));
233 cvmx_pip_get_port_status(priv
->port
, 1, &rx_status
);
234 cvmx_pko_get_port_status(priv
->port
, 1, &tx_status
);
237 priv
->stats
.rx_packets
+= rx_status
.inb_packets
;
238 priv
->stats
.tx_packets
+= tx_status
.packets
;
239 priv
->stats
.rx_bytes
+= rx_status
.inb_octets
;
240 priv
->stats
.tx_bytes
+= tx_status
.octets
;
241 priv
->stats
.multicast
+= rx_status
.multicast_packets
;
242 priv
->stats
.rx_crc_errors
+= rx_status
.inb_errors
;
243 priv
->stats
.rx_frame_errors
+= rx_status
.fcs_align_err_packets
;
246 * The drop counter must be incremented atomically
247 * since the RX tasklet also increments it.
250 atomic64_add(rx_status
.dropped_packets
,
251 (atomic64_t
*)&priv
->stats
.rx_dropped
);
253 atomic_add(rx_status
.dropped_packets
,
254 (atomic_t
*)&priv
->stats
.rx_dropped
);
262 * cvm_oct_common_change_mtu - change the link MTU
263 * @dev: Device to change
264 * @new_mtu: The new MTU
266 * Returns Zero on success
268 static int cvm_oct_common_change_mtu(struct net_device
*dev
, int new_mtu
)
270 struct octeon_ethernet
*priv
= netdev_priv(dev
);
271 int interface
= INTERFACE(priv
->port
);
272 int index
= INDEX(priv
->port
);
273 #if defined(CONFIG_VLAN_8021Q) || defined(CONFIG_VLAN_8021Q_MODULE)
280 * Limit the MTU to make sure the ethernet packets are between
281 * 64 bytes and 65535 bytes.
283 if ((new_mtu
+ 14 + 4 + vlan_bytes
< 64)
284 || (new_mtu
+ 14 + 4 + vlan_bytes
> 65392)) {
285 pr_err("MTU must be between %d and %d.\n",
286 64 - 14 - 4 - vlan_bytes
, 65392 - 14 - 4 - vlan_bytes
);
292 && (cvmx_helper_interface_get_mode(interface
) !=
293 CVMX_HELPER_INTERFACE_MODE_SPI
)) {
294 /* Add ethernet header and FCS, and VLAN if configured. */
295 int max_packet
= new_mtu
+ 14 + 4 + vlan_bytes
;
297 if (OCTEON_IS_MODEL(OCTEON_CN3XXX
)
298 || OCTEON_IS_MODEL(OCTEON_CN58XX
)) {
299 /* Signal errors on packets larger than the MTU */
300 cvmx_write_csr(CVMX_GMXX_RXX_FRM_MAX(index
, interface
),
304 * Set the hardware to truncate packets larger
305 * than the MTU and smaller the 64 bytes.
307 union cvmx_pip_frm_len_chkx frm_len_chk
;
310 frm_len_chk
.s
.minlen
= 64;
311 frm_len_chk
.s
.maxlen
= max_packet
;
312 cvmx_write_csr(CVMX_PIP_FRM_LEN_CHKX(interface
),
316 * Set the hardware to truncate packets larger than
317 * the MTU. The jabber register must be set to a
318 * multiple of 8 bytes, so round up.
320 cvmx_write_csr(CVMX_GMXX_RXX_JABBER(index
, interface
),
321 (max_packet
+ 7) & ~7u);
327 * cvm_oct_common_set_multicast_list - set the multicast list
328 * @dev: Device to work on
330 static void cvm_oct_common_set_multicast_list(struct net_device
*dev
)
332 union cvmx_gmxx_prtx_cfg gmx_cfg
;
333 struct octeon_ethernet
*priv
= netdev_priv(dev
);
334 int interface
= INTERFACE(priv
->port
);
335 int index
= INDEX(priv
->port
);
338 && (cvmx_helper_interface_get_mode(interface
) !=
339 CVMX_HELPER_INTERFACE_MODE_SPI
)) {
340 union cvmx_gmxx_rxx_adr_ctl control
;
343 control
.s
.bcst
= 1; /* Allow broadcast MAC addresses */
345 if (!netdev_mc_empty(dev
) || (dev
->flags
& IFF_ALLMULTI
) ||
346 (dev
->flags
& IFF_PROMISC
))
347 /* Force accept multicast packets */
350 /* Force reject multicast packets */
353 if (dev
->flags
& IFF_PROMISC
)
355 * Reject matches if promisc. Since CAM is
356 * shut off, should accept everything.
358 control
.s
.cam_mode
= 0;
360 /* Filter packets based on the CAM */
361 control
.s
.cam_mode
= 1;
364 cvmx_read_csr(CVMX_GMXX_PRTX_CFG(index
, interface
));
365 cvmx_write_csr(CVMX_GMXX_PRTX_CFG(index
, interface
),
366 gmx_cfg
.u64
& ~1ull);
368 cvmx_write_csr(CVMX_GMXX_RXX_ADR_CTL(index
, interface
),
370 if (dev
->flags
& IFF_PROMISC
)
371 cvmx_write_csr(CVMX_GMXX_RXX_ADR_CAM_EN
372 (index
, interface
), 0);
374 cvmx_write_csr(CVMX_GMXX_RXX_ADR_CAM_EN
375 (index
, interface
), 1);
377 cvmx_write_csr(CVMX_GMXX_PRTX_CFG(index
, interface
),
383 * cvm_oct_common_set_mac_address - set the hardware MAC address for a device
384 * @dev: The device in question.
385 * @addr: Address structure to change it too.
387 * Returns Zero on success
389 static int cvm_oct_set_mac_filter(struct net_device
*dev
)
391 struct octeon_ethernet
*priv
= netdev_priv(dev
);
392 union cvmx_gmxx_prtx_cfg gmx_cfg
;
393 int interface
= INTERFACE(priv
->port
);
394 int index
= INDEX(priv
->port
);
397 && (cvmx_helper_interface_get_mode(interface
) !=
398 CVMX_HELPER_INTERFACE_MODE_SPI
)) {
400 uint8_t *ptr
= dev
->dev_addr
;
403 for (i
= 0; i
< 6; i
++)
404 mac
= (mac
<< 8) | (uint64_t)ptr
[i
];
407 cvmx_read_csr(CVMX_GMXX_PRTX_CFG(index
, interface
));
408 cvmx_write_csr(CVMX_GMXX_PRTX_CFG(index
, interface
),
409 gmx_cfg
.u64
& ~1ull);
411 cvmx_write_csr(CVMX_GMXX_SMACX(index
, interface
), mac
);
412 cvmx_write_csr(CVMX_GMXX_RXX_ADR_CAM0(index
, interface
),
414 cvmx_write_csr(CVMX_GMXX_RXX_ADR_CAM1(index
, interface
),
416 cvmx_write_csr(CVMX_GMXX_RXX_ADR_CAM2(index
, interface
),
418 cvmx_write_csr(CVMX_GMXX_RXX_ADR_CAM3(index
, interface
),
420 cvmx_write_csr(CVMX_GMXX_RXX_ADR_CAM4(index
, interface
),
422 cvmx_write_csr(CVMX_GMXX_RXX_ADR_CAM5(index
, interface
),
424 cvm_oct_common_set_multicast_list(dev
);
425 cvmx_write_csr(CVMX_GMXX_PRTX_CFG(index
, interface
),
431 static int cvm_oct_common_set_mac_address(struct net_device
*dev
, void *addr
)
433 int r
= eth_mac_addr(dev
, addr
);
437 return cvm_oct_set_mac_filter(dev
);
441 * cvm_oct_common_init - per network device initialization
442 * @dev: Device to initialize
444 * Returns Zero on success
446 int cvm_oct_common_init(struct net_device
*dev
)
448 struct octeon_ethernet
*priv
= netdev_priv(dev
);
449 const u8
*mac
= NULL
;
452 mac
= of_get_mac_address(priv
->of_node
);
455 ether_addr_copy(dev
->dev_addr
, mac
);
457 eth_hw_addr_random(dev
);
460 * Force the interface to use the POW send if always_use_pow
461 * was specified or it is in the pow send list.
463 if ((pow_send_group
!= -1)
464 && (always_use_pow
|| strstr(pow_send_list
, dev
->name
)))
467 if (priv
->queue
!= -1)
468 dev
->features
|= NETIF_F_SG
| NETIF_F_IP_CSUM
;
470 /* We do our own locking, Linux doesn't need to */
471 dev
->features
|= NETIF_F_LLTX
;
472 dev
->ethtool_ops
= &cvm_oct_ethtool_ops
;
474 cvm_oct_set_mac_filter(dev
);
475 dev
->netdev_ops
->ndo_change_mtu(dev
, dev
->mtu
);
478 * Zero out stats for port so we won't mistakenly show
479 * counters from the bootloader.
481 memset(dev
->netdev_ops
->ndo_get_stats(dev
), 0,
482 sizeof(struct net_device_stats
));
484 if (dev
->netdev_ops
->ndo_stop
)
485 dev
->netdev_ops
->ndo_stop(dev
);
490 void cvm_oct_common_uninit(struct net_device
*dev
)
492 struct octeon_ethernet
*priv
= netdev_priv(dev
);
495 phy_disconnect(priv
->phydev
);
498 int cvm_oct_common_open(struct net_device
*dev
,
499 void (*link_poll
)(struct net_device
*), bool poll_now
)
501 union cvmx_gmxx_prtx_cfg gmx_cfg
;
502 struct octeon_ethernet
*priv
= netdev_priv(dev
);
503 int interface
= INTERFACE(priv
->port
);
504 int index
= INDEX(priv
->port
);
505 cvmx_helper_link_info_t link_info
;
508 rv
= cvm_oct_phy_setup_device(dev
);
512 gmx_cfg
.u64
= cvmx_read_csr(CVMX_GMXX_PRTX_CFG(index
, interface
));
514 cvmx_write_csr(CVMX_GMXX_PRTX_CFG(index
, interface
), gmx_cfg
.u64
);
516 if (octeon_is_simulation())
520 int r
= phy_read_status(priv
->phydev
);
522 if (r
== 0 && priv
->phydev
->link
== 0)
523 netif_carrier_off(dev
);
524 cvm_oct_adjust_link(dev
);
526 link_info
= cvmx_helper_link_get(priv
->port
);
527 if (!link_info
.s
.link_up
)
528 netif_carrier_off(dev
);
529 priv
->poll
= link_poll
;
537 void cvm_oct_link_poll(struct net_device
*dev
)
539 struct octeon_ethernet
*priv
= netdev_priv(dev
);
540 cvmx_helper_link_info_t link_info
;
542 link_info
= cvmx_helper_link_get(priv
->port
);
543 if (link_info
.u64
== priv
->link_info
)
546 link_info
= cvmx_helper_link_autoconf(priv
->port
);
547 priv
->link_info
= link_info
.u64
;
549 if (link_info
.s
.link_up
) {
550 if (!netif_carrier_ok(dev
))
551 netif_carrier_on(dev
);
552 } else if (netif_carrier_ok(dev
)) {
553 netif_carrier_off(dev
);
555 cvm_oct_note_carrier(priv
, link_info
);
558 static const struct net_device_ops cvm_oct_npi_netdev_ops
= {
559 .ndo_init
= cvm_oct_common_init
,
560 .ndo_uninit
= cvm_oct_common_uninit
,
561 .ndo_start_xmit
= cvm_oct_xmit
,
562 .ndo_set_rx_mode
= cvm_oct_common_set_multicast_list
,
563 .ndo_set_mac_address
= cvm_oct_common_set_mac_address
,
564 .ndo_do_ioctl
= cvm_oct_ioctl
,
565 .ndo_change_mtu
= cvm_oct_common_change_mtu
,
566 .ndo_get_stats
= cvm_oct_common_get_stats
,
567 #ifdef CONFIG_NET_POLL_CONTROLLER
568 .ndo_poll_controller
= cvm_oct_poll_controller
,
571 static const struct net_device_ops cvm_oct_xaui_netdev_ops
= {
572 .ndo_init
= cvm_oct_xaui_init
,
573 .ndo_uninit
= cvm_oct_common_uninit
,
574 .ndo_open
= cvm_oct_xaui_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
,
586 static const struct net_device_ops cvm_oct_sgmii_netdev_ops
= {
587 .ndo_init
= cvm_oct_sgmii_init
,
588 .ndo_uninit
= cvm_oct_common_uninit
,
589 .ndo_open
= cvm_oct_sgmii_open
,
590 .ndo_stop
= cvm_oct_common_stop
,
591 .ndo_start_xmit
= cvm_oct_xmit
,
592 .ndo_set_rx_mode
= cvm_oct_common_set_multicast_list
,
593 .ndo_set_mac_address
= cvm_oct_common_set_mac_address
,
594 .ndo_do_ioctl
= cvm_oct_ioctl
,
595 .ndo_change_mtu
= cvm_oct_common_change_mtu
,
596 .ndo_get_stats
= cvm_oct_common_get_stats
,
597 #ifdef CONFIG_NET_POLL_CONTROLLER
598 .ndo_poll_controller
= cvm_oct_poll_controller
,
601 static const struct net_device_ops cvm_oct_spi_netdev_ops
= {
602 .ndo_init
= cvm_oct_spi_init
,
603 .ndo_uninit
= cvm_oct_spi_uninit
,
604 .ndo_start_xmit
= cvm_oct_xmit
,
605 .ndo_set_rx_mode
= cvm_oct_common_set_multicast_list
,
606 .ndo_set_mac_address
= cvm_oct_common_set_mac_address
,
607 .ndo_do_ioctl
= cvm_oct_ioctl
,
608 .ndo_change_mtu
= cvm_oct_common_change_mtu
,
609 .ndo_get_stats
= cvm_oct_common_get_stats
,
610 #ifdef CONFIG_NET_POLL_CONTROLLER
611 .ndo_poll_controller
= cvm_oct_poll_controller
,
614 static const struct net_device_ops cvm_oct_rgmii_netdev_ops
= {
615 .ndo_init
= cvm_oct_rgmii_init
,
616 .ndo_uninit
= cvm_oct_rgmii_uninit
,
617 .ndo_open
= cvm_oct_rgmii_open
,
618 .ndo_stop
= cvm_oct_common_stop
,
619 .ndo_start_xmit
= cvm_oct_xmit
,
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
,
629 static const struct net_device_ops cvm_oct_pow_netdev_ops
= {
630 .ndo_init
= cvm_oct_common_init
,
631 .ndo_start_xmit
= cvm_oct_xmit_pow
,
632 .ndo_set_rx_mode
= cvm_oct_common_set_multicast_list
,
633 .ndo_set_mac_address
= cvm_oct_common_set_mac_address
,
634 .ndo_do_ioctl
= cvm_oct_ioctl
,
635 .ndo_change_mtu
= cvm_oct_common_change_mtu
,
636 .ndo_get_stats
= cvm_oct_common_get_stats
,
637 #ifdef CONFIG_NET_POLL_CONTROLLER
638 .ndo_poll_controller
= cvm_oct_poll_controller
,
642 static struct device_node
*cvm_oct_of_get_child(
643 const struct device_node
*parent
, int reg_val
)
645 struct device_node
*node
= NULL
;
650 node
= of_get_next_child(parent
, node
);
653 addr
= of_get_property(node
, "reg", &size
);
654 if (addr
&& (be32_to_cpu(*addr
) == reg_val
))
660 static struct device_node
*cvm_oct_node_for_port(struct device_node
*pip
,
661 int interface
, int port
)
663 struct device_node
*ni
, *np
;
665 ni
= cvm_oct_of_get_child(pip
, interface
);
669 np
= cvm_oct_of_get_child(ni
, port
);
675 static int cvm_oct_probe(struct platform_device
*pdev
)
679 int fau
= FAU_NUM_PACKET_BUFFERS_TO_FREE
;
681 struct device_node
*pip
;
683 octeon_mdiobus_force_mod_depencency();
684 pr_notice("cavium-ethernet %s\n", OCTEON_ETHERNET_VERSION
);
686 pip
= pdev
->dev
.of_node
;
688 pr_err("Error: No 'pip' in /aliases\n");
692 cvm_oct_poll_queue
= create_singlethread_workqueue("octeon-ethernet");
693 if (cvm_oct_poll_queue
== NULL
) {
694 pr_err("octeon-ethernet: Cannot create workqueue");
698 cvm_oct_configure_common_hw();
700 cvmx_helper_initialize_packet_io_global();
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
));
715 pip_prt_tagx
.s
.grp
= pow_receive_group
;
716 cvmx_write_csr(CVMX_PIP_PRT_TAGX(port
),
721 cvmx_helper_ipd_and_packet_input_enable();
723 memset(cvm_oct_device
, 0, sizeof(cvm_oct_device
));
726 * Initialize the FAU used for counting packet buffers that
729 cvmx_fau_atomic_write32(FAU_NUM_PACKET_BUFFERS_TO_FREE
, 0);
731 /* Initialize the FAU used for counting tx SKBs that need to be freed */
732 cvmx_fau_atomic_write32(FAU_TOTAL_TX_TO_CLEAN
, 0);
734 if ((pow_send_group
!= -1)) {
735 struct net_device
*dev
;
737 pr_info("\tConfiguring device for POW only access\n");
738 dev
= alloc_etherdev(sizeof(struct octeon_ethernet
));
740 /* Initialize the device private structure. */
741 struct octeon_ethernet
*priv
= netdev_priv(dev
);
743 dev
->netdev_ops
= &cvm_oct_pow_netdev_ops
;
744 priv
->imode
= CVMX_HELPER_INTERFACE_MODE_DISABLED
;
745 priv
->port
= CVMX_PIP_NUM_INPUT_PORTS
;
747 strcpy(dev
->name
, "pow%d");
748 for (qos
= 0; qos
< 16; qos
++)
749 skb_queue_head_init(&priv
->tx_free_list
[qos
]);
751 if (register_netdev(dev
) < 0) {
752 pr_err("Failed to register ethernet device for POW\n");
755 cvm_oct_device
[CVMX_PIP_NUM_INPUT_PORTS
] = dev
;
756 pr_info("%s: POW send group %d, receive group %d\n",
757 dev
->name
, pow_send_group
,
761 pr_err("Failed to allocate ethernet device for POW\n");
765 num_interfaces
= cvmx_helper_get_number_of_interfaces();
766 for (interface
= 0; interface
< num_interfaces
; interface
++) {
767 cvmx_helper_interface_mode_t imode
=
768 cvmx_helper_interface_get_mode(interface
);
769 int num_ports
= cvmx_helper_ports_on_interface(interface
);
774 port
= cvmx_helper_get_ipd_port(interface
, 0);
775 port
< cvmx_helper_get_ipd_port(interface
, num_ports
);
776 port_index
++, port
++) {
777 struct octeon_ethernet
*priv
;
778 struct net_device
*dev
=
779 alloc_etherdev(sizeof(struct octeon_ethernet
));
781 pr_err("Failed to allocate ethernet device for port %d\n",
786 /* Initialize the device private structure. */
787 priv
= netdev_priv(dev
);
789 priv
->of_node
= cvm_oct_node_for_port(pip
, interface
,
792 INIT_DELAYED_WORK(&priv
->port_periodic_work
,
793 cvm_oct_periodic_worker
);
796 priv
->queue
= cvmx_pko_get_base_queue(priv
->port
);
797 priv
->fau
= fau
- cvmx_pko_get_num_queues(port
) * 4;
798 for (qos
= 0; qos
< 16; qos
++)
799 skb_queue_head_init(&priv
->tx_free_list
[qos
]);
800 for (qos
= 0; qos
< cvmx_pko_get_num_queues(port
);
802 cvmx_fau_atomic_write32(priv
->fau
+ qos
* 4, 0);
804 switch (priv
->imode
) {
806 /* These types don't support ports to IPD/PKO */
807 case CVMX_HELPER_INTERFACE_MODE_DISABLED
:
808 case CVMX_HELPER_INTERFACE_MODE_PCIE
:
809 case CVMX_HELPER_INTERFACE_MODE_PICMG
:
812 case CVMX_HELPER_INTERFACE_MODE_NPI
:
813 dev
->netdev_ops
= &cvm_oct_npi_netdev_ops
;
814 strcpy(dev
->name
, "npi%d");
817 case CVMX_HELPER_INTERFACE_MODE_XAUI
:
818 dev
->netdev_ops
= &cvm_oct_xaui_netdev_ops
;
819 strcpy(dev
->name
, "xaui%d");
822 case CVMX_HELPER_INTERFACE_MODE_LOOP
:
823 dev
->netdev_ops
= &cvm_oct_npi_netdev_ops
;
824 strcpy(dev
->name
, "loop%d");
827 case CVMX_HELPER_INTERFACE_MODE_SGMII
:
828 dev
->netdev_ops
= &cvm_oct_sgmii_netdev_ops
;
829 strcpy(dev
->name
, "eth%d");
832 case CVMX_HELPER_INTERFACE_MODE_SPI
:
833 dev
->netdev_ops
= &cvm_oct_spi_netdev_ops
;
834 strcpy(dev
->name
, "spi%d");
837 case CVMX_HELPER_INTERFACE_MODE_RGMII
:
838 case CVMX_HELPER_INTERFACE_MODE_GMII
:
839 dev
->netdev_ops
= &cvm_oct_rgmii_netdev_ops
;
840 strcpy(dev
->name
, "eth%d");
844 if (!dev
->netdev_ops
) {
846 } else if (register_netdev(dev
) < 0) {
847 pr_err("Failed to register ethernet device for interface %d, port %d\n",
848 interface
, priv
->port
);
851 cvm_oct_device
[priv
->port
] = dev
;
853 cvmx_pko_get_num_queues(priv
->port
) *
855 queue_delayed_work(cvm_oct_poll_queue
,
856 &priv
->port_periodic_work
, HZ
);
861 cvm_oct_tx_initialize();
862 cvm_oct_rx_initialize();
865 * 150 uS: about 10 1500-byte packets at 1GE.
867 cvm_oct_tx_poll_interval
= 150 * (octeon_get_clock_rate() / 1000000);
869 queue_delayed_work(cvm_oct_poll_queue
, &cvm_oct_rx_refill_work
, HZ
);
874 static int cvm_oct_remove(struct platform_device
*pdev
)
878 /* Disable POW interrupt */
879 cvmx_write_csr(CVMX_POW_WQ_INT_THRX(pow_receive_group
), 0);
883 /* Free the interrupt handler */
884 free_irq(OCTEON_IRQ_WORKQ0
+ pow_receive_group
, cvm_oct_device
);
886 atomic_inc_return(&cvm_oct_poll_queue_stopping
);
887 cancel_delayed_work_sync(&cvm_oct_rx_refill_work
);
889 cvm_oct_rx_shutdown();
890 cvm_oct_tx_shutdown();
894 /* Free the ethernet devices */
895 for (port
= 0; port
< TOTAL_NUMBER_OF_PORTS
; port
++) {
896 if (cvm_oct_device
[port
]) {
897 struct net_device
*dev
= cvm_oct_device
[port
];
898 struct octeon_ethernet
*priv
= netdev_priv(dev
);
900 cancel_delayed_work_sync(&priv
->port_periodic_work
);
902 cvm_oct_tx_shutdown_dev(dev
);
903 unregister_netdev(dev
);
905 cvm_oct_device
[port
] = NULL
;
909 destroy_workqueue(cvm_oct_poll_queue
);
915 /* Free the HW pools */
916 cvm_oct_mem_empty_fpa(CVMX_FPA_PACKET_POOL
, CVMX_FPA_PACKET_POOL_SIZE
,
918 cvm_oct_mem_empty_fpa(CVMX_FPA_WQE_POOL
, CVMX_FPA_WQE_POOL_SIZE
,
920 if (CVMX_FPA_OUTPUT_BUFFER_POOL
!= CVMX_FPA_PACKET_POOL
)
921 cvm_oct_mem_empty_fpa(CVMX_FPA_OUTPUT_BUFFER_POOL
,
922 CVMX_FPA_OUTPUT_BUFFER_POOL_SIZE
, 128);
926 static const struct of_device_id cvm_oct_match
[] = {
928 .compatible
= "cavium,octeon-3860-pip",
932 MODULE_DEVICE_TABLE(of
, cvm_oct_match
);
934 static struct platform_driver cvm_oct_driver
= {
935 .probe
= cvm_oct_probe
,
936 .remove
= cvm_oct_remove
,
938 .name
= KBUILD_MODNAME
,
939 .of_match_table
= cvm_oct_match
,
943 module_platform_driver(cvm_oct_driver
);
945 MODULE_LICENSE("GPL");
946 MODULE_AUTHOR("Cavium Networks <support@caviumnetworks.com>");
947 MODULE_DESCRIPTION("Cavium Networks Octeon ethernet driver.");