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>
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 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.");
91 * cvm_oct_poll_queue_stopping - flag to indicate polling should stop.
93 * Set to one right before cvm_oct_poll_queue is destroyed.
95 atomic_t cvm_oct_poll_queue_stopping
= ATOMIC_INIT(0);
98 * Array of every ethernet device owned by this driver indexed by
99 * the ipd input port number.
101 struct net_device
*cvm_oct_device
[TOTAL_NUMBER_OF_PORTS
];
103 u64 cvm_oct_tx_poll_interval
;
105 static void cvm_oct_rx_refill_worker(struct work_struct
*work
);
106 static DECLARE_DELAYED_WORK(cvm_oct_rx_refill_work
, cvm_oct_rx_refill_worker
);
108 static void cvm_oct_rx_refill_worker(struct work_struct
*work
)
111 * FPA 0 may have been drained, try to refill it if we need
112 * more than num_packet_buffers / 2, otherwise normal receive
113 * processing will refill it. If it were drained, no packets
114 * could be received so cvm_oct_napi_poll would never be
115 * invoked to do the refill.
117 cvm_oct_rx_refill_pool(num_packet_buffers
/ 2);
119 if (!atomic_read(&cvm_oct_poll_queue_stopping
))
120 schedule_delayed_work(&cvm_oct_rx_refill_work
, HZ
);
123 static void cvm_oct_periodic_worker(struct work_struct
*work
)
125 struct octeon_ethernet
*priv
= container_of(work
,
126 struct octeon_ethernet
,
127 port_periodic_work
.work
);
130 priv
->poll(cvm_oct_device
[priv
->port
]);
132 cvm_oct_device
[priv
->port
]->netdev_ops
->ndo_get_stats(
133 cvm_oct_device
[priv
->port
]);
135 if (!atomic_read(&cvm_oct_poll_queue_stopping
))
136 schedule_delayed_work(&priv
->port_periodic_work
, HZ
);
139 static void cvm_oct_configure_common_hw(void)
143 cvm_oct_mem_fill_fpa(CVMX_FPA_PACKET_POOL
, CVMX_FPA_PACKET_POOL_SIZE
,
145 cvm_oct_mem_fill_fpa(CVMX_FPA_WQE_POOL
, CVMX_FPA_WQE_POOL_SIZE
,
147 if (CVMX_FPA_OUTPUT_BUFFER_POOL
!= CVMX_FPA_PACKET_POOL
)
148 cvm_oct_mem_fill_fpa(CVMX_FPA_OUTPUT_BUFFER_POOL
,
149 CVMX_FPA_OUTPUT_BUFFER_POOL_SIZE
, 1024);
151 #ifdef __LITTLE_ENDIAN
153 union cvmx_ipd_ctl_status ipd_ctl_status
;
155 ipd_ctl_status
.u64
= cvmx_read_csr(CVMX_IPD_CTL_STATUS
);
156 ipd_ctl_status
.s
.pkt_lend
= 1;
157 ipd_ctl_status
.s
.wqe_lend
= 1;
158 cvmx_write_csr(CVMX_IPD_CTL_STATUS
, ipd_ctl_status
.u64
);
162 cvmx_helper_setup_red(num_packet_buffers
/ 4, num_packet_buffers
/ 8);
166 * cvm_oct_free_work- Free a work queue entry
168 * @work_queue_entry: Work queue entry to free
170 * Returns Zero on success, Negative on failure.
172 int cvm_oct_free_work(void *work_queue_entry
)
174 cvmx_wqe_t
*work
= work_queue_entry
;
176 int segments
= work
->word2
.s
.bufs
;
177 union cvmx_buf_ptr segment_ptr
= work
->packet_ptr
;
180 union cvmx_buf_ptr next_ptr
= *(union cvmx_buf_ptr
*)
181 cvmx_phys_to_ptr(segment_ptr
.s
.addr
- 8);
182 if (unlikely(!segment_ptr
.s
.i
))
183 cvmx_fpa_free(cvm_oct_get_buffer_ptr(segment_ptr
),
185 CVMX_FPA_PACKET_POOL_SIZE
/ 128);
186 segment_ptr
= next_ptr
;
188 cvmx_fpa_free(work
, CVMX_FPA_WQE_POOL
, 1);
192 EXPORT_SYMBOL(cvm_oct_free_work
);
195 * cvm_oct_common_get_stats - get the low level ethernet statistics
196 * @dev: Device to get the statistics from
198 * Returns Pointer to the statistics
200 static struct net_device_stats
*cvm_oct_common_get_stats(struct net_device
*dev
)
202 cvmx_pip_port_status_t rx_status
;
203 cvmx_pko_port_status_t tx_status
;
204 struct octeon_ethernet
*priv
= netdev_priv(dev
);
206 if (priv
->port
< CVMX_PIP_NUM_INPUT_PORTS
) {
207 if (octeon_is_simulation()) {
208 /* The simulator doesn't support statistics */
209 memset(&rx_status
, 0, sizeof(rx_status
));
210 memset(&tx_status
, 0, sizeof(tx_status
));
212 cvmx_pip_get_port_status(priv
->port
, 1, &rx_status
);
213 cvmx_pko_get_port_status(priv
->port
, 1, &tx_status
);
216 priv
->stats
.rx_packets
+= rx_status
.inb_packets
;
217 priv
->stats
.tx_packets
+= tx_status
.packets
;
218 priv
->stats
.rx_bytes
+= rx_status
.inb_octets
;
219 priv
->stats
.tx_bytes
+= tx_status
.octets
;
220 priv
->stats
.multicast
+= rx_status
.multicast_packets
;
221 priv
->stats
.rx_crc_errors
+= rx_status
.inb_errors
;
222 priv
->stats
.rx_frame_errors
+= rx_status
.fcs_align_err_packets
;
223 priv
->stats
.rx_dropped
+= rx_status
.dropped_packets
;
230 * cvm_oct_common_change_mtu - change the link MTU
231 * @dev: Device to change
232 * @new_mtu: The new MTU
234 * Returns Zero on success
236 static int cvm_oct_common_change_mtu(struct net_device
*dev
, int new_mtu
)
238 struct octeon_ethernet
*priv
= netdev_priv(dev
);
239 int interface
= INTERFACE(priv
->port
);
240 int index
= INDEX(priv
->port
);
241 #if defined(CONFIG_VLAN_8021Q) || defined(CONFIG_VLAN_8021Q_MODULE)
248 * Limit the MTU to make sure the ethernet packets are between
249 * 64 bytes and 65535 bytes.
251 if ((new_mtu
+ 14 + 4 + vlan_bytes
< 64) ||
252 (new_mtu
+ 14 + 4 + vlan_bytes
> 65392)) {
253 pr_err("MTU must be between %d and %d.\n",
254 64 - 14 - 4 - vlan_bytes
, 65392 - 14 - 4 - vlan_bytes
);
259 if ((interface
< 2) &&
260 (cvmx_helper_interface_get_mode(interface
) !=
261 CVMX_HELPER_INTERFACE_MODE_SPI
)) {
262 /* Add ethernet header and FCS, and VLAN if configured. */
263 int max_packet
= new_mtu
+ 14 + 4 + vlan_bytes
;
265 if (OCTEON_IS_MODEL(OCTEON_CN3XXX
) ||
266 OCTEON_IS_MODEL(OCTEON_CN58XX
)) {
267 /* Signal errors on packets larger than the MTU */
268 cvmx_write_csr(CVMX_GMXX_RXX_FRM_MAX(index
, interface
),
272 * Set the hardware to truncate packets larger
273 * than the MTU and smaller the 64 bytes.
275 union cvmx_pip_frm_len_chkx frm_len_chk
;
278 frm_len_chk
.s
.minlen
= 64;
279 frm_len_chk
.s
.maxlen
= max_packet
;
280 cvmx_write_csr(CVMX_PIP_FRM_LEN_CHKX(interface
),
284 * Set the hardware to truncate packets larger than
285 * the MTU. The jabber register must be set to a
286 * multiple of 8 bytes, so round up.
288 cvmx_write_csr(CVMX_GMXX_RXX_JABBER(index
, interface
),
289 (max_packet
+ 7) & ~7u);
295 * cvm_oct_common_set_multicast_list - set the multicast list
296 * @dev: Device to work on
298 static void cvm_oct_common_set_multicast_list(struct net_device
*dev
)
300 union cvmx_gmxx_prtx_cfg gmx_cfg
;
301 struct octeon_ethernet
*priv
= netdev_priv(dev
);
302 int interface
= INTERFACE(priv
->port
);
303 int index
= INDEX(priv
->port
);
305 if ((interface
< 2) &&
306 (cvmx_helper_interface_get_mode(interface
) !=
307 CVMX_HELPER_INTERFACE_MODE_SPI
)) {
308 union cvmx_gmxx_rxx_adr_ctl control
;
311 control
.s
.bcst
= 1; /* Allow broadcast MAC addresses */
313 if (!netdev_mc_empty(dev
) || (dev
->flags
& IFF_ALLMULTI
) ||
314 (dev
->flags
& IFF_PROMISC
))
315 /* Force accept multicast packets */
318 /* Force reject multicast packets */
321 if (dev
->flags
& IFF_PROMISC
)
323 * Reject matches if promisc. Since CAM is
324 * shut off, should accept everything.
326 control
.s
.cam_mode
= 0;
328 /* Filter packets based on the CAM */
329 control
.s
.cam_mode
= 1;
332 cvmx_read_csr(CVMX_GMXX_PRTX_CFG(index
, interface
));
333 cvmx_write_csr(CVMX_GMXX_PRTX_CFG(index
, interface
),
334 gmx_cfg
.u64
& ~1ull);
336 cvmx_write_csr(CVMX_GMXX_RXX_ADR_CTL(index
, interface
),
338 if (dev
->flags
& IFF_PROMISC
)
339 cvmx_write_csr(CVMX_GMXX_RXX_ADR_CAM_EN
340 (index
, interface
), 0);
342 cvmx_write_csr(CVMX_GMXX_RXX_ADR_CAM_EN
343 (index
, interface
), 1);
345 cvmx_write_csr(CVMX_GMXX_PRTX_CFG(index
, interface
),
350 static int cvm_oct_set_mac_filter(struct net_device
*dev
)
352 struct octeon_ethernet
*priv
= netdev_priv(dev
);
353 union cvmx_gmxx_prtx_cfg gmx_cfg
;
354 int interface
= INTERFACE(priv
->port
);
355 int index
= INDEX(priv
->port
);
357 if ((interface
< 2) &&
358 (cvmx_helper_interface_get_mode(interface
) !=
359 CVMX_HELPER_INTERFACE_MODE_SPI
)) {
361 u8
*ptr
= dev
->dev_addr
;
364 for (i
= 0; i
< 6; i
++)
365 mac
= (mac
<< 8) | (u64
)ptr
[i
];
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_SMACX(index
, interface
), mac
);
373 cvmx_write_csr(CVMX_GMXX_RXX_ADR_CAM0(index
, interface
),
375 cvmx_write_csr(CVMX_GMXX_RXX_ADR_CAM1(index
, interface
),
377 cvmx_write_csr(CVMX_GMXX_RXX_ADR_CAM2(index
, interface
),
379 cvmx_write_csr(CVMX_GMXX_RXX_ADR_CAM3(index
, interface
),
381 cvmx_write_csr(CVMX_GMXX_RXX_ADR_CAM4(index
, interface
),
383 cvmx_write_csr(CVMX_GMXX_RXX_ADR_CAM5(index
, interface
),
385 cvm_oct_common_set_multicast_list(dev
);
386 cvmx_write_csr(CVMX_GMXX_PRTX_CFG(index
, interface
),
393 * cvm_oct_common_set_mac_address - set the hardware MAC address for a device
394 * @dev: The device in question.
395 * @addr: Socket address.
397 * Returns Zero on success
399 static int cvm_oct_common_set_mac_address(struct net_device
*dev
, void *addr
)
401 int r
= eth_mac_addr(dev
, addr
);
405 return cvm_oct_set_mac_filter(dev
);
409 * cvm_oct_common_init - per network device initialization
410 * @dev: Device to initialize
412 * Returns Zero on success
414 int cvm_oct_common_init(struct net_device
*dev
)
416 struct octeon_ethernet
*priv
= netdev_priv(dev
);
417 const u8
*mac
= NULL
;
420 mac
= of_get_mac_address(priv
->of_node
);
423 ether_addr_copy(dev
->dev_addr
, mac
);
425 eth_hw_addr_random(dev
);
428 * Force the interface to use the POW send if always_use_pow
429 * was specified or it is in the pow send list.
431 if ((pow_send_group
!= -1) &&
432 (always_use_pow
|| strstr(pow_send_list
, dev
->name
)))
435 if (priv
->queue
!= -1)
436 dev
->features
|= NETIF_F_SG
| NETIF_F_IP_CSUM
;
438 /* We do our own locking, Linux doesn't need to */
439 dev
->features
|= NETIF_F_LLTX
;
440 dev
->ethtool_ops
= &cvm_oct_ethtool_ops
;
442 cvm_oct_set_mac_filter(dev
);
443 dev
->netdev_ops
->ndo_change_mtu(dev
, dev
->mtu
);
446 * Zero out stats for port so we won't mistakenly show
447 * counters from the bootloader.
449 memset(dev
->netdev_ops
->ndo_get_stats(dev
), 0,
450 sizeof(struct net_device_stats
));
452 if (dev
->netdev_ops
->ndo_stop
)
453 dev
->netdev_ops
->ndo_stop(dev
);
458 void cvm_oct_common_uninit(struct net_device
*dev
)
461 phy_disconnect(dev
->phydev
);
464 int cvm_oct_common_open(struct net_device
*dev
,
465 void (*link_poll
)(struct net_device
*))
467 union cvmx_gmxx_prtx_cfg gmx_cfg
;
468 struct octeon_ethernet
*priv
= netdev_priv(dev
);
469 int interface
= INTERFACE(priv
->port
);
470 int index
= INDEX(priv
->port
);
471 cvmx_helper_link_info_t link_info
;
474 rv
= cvm_oct_phy_setup_device(dev
);
478 gmx_cfg
.u64
= cvmx_read_csr(CVMX_GMXX_PRTX_CFG(index
, interface
));
480 cvmx_write_csr(CVMX_GMXX_PRTX_CFG(index
, interface
), gmx_cfg
.u64
);
482 if (octeon_is_simulation())
486 int r
= phy_read_status(dev
->phydev
);
488 if (r
== 0 && dev
->phydev
->link
== 0)
489 netif_carrier_off(dev
);
490 cvm_oct_adjust_link(dev
);
492 link_info
= cvmx_helper_link_get(priv
->port
);
493 if (!link_info
.s
.link_up
)
494 netif_carrier_off(dev
);
495 priv
->poll
= link_poll
;
502 void cvm_oct_link_poll(struct net_device
*dev
)
504 struct octeon_ethernet
*priv
= netdev_priv(dev
);
505 cvmx_helper_link_info_t link_info
;
507 link_info
= cvmx_helper_link_get(priv
->port
);
508 if (link_info
.u64
== priv
->link_info
)
511 link_info
= cvmx_helper_link_autoconf(priv
->port
);
512 priv
->link_info
= link_info
.u64
;
514 if (link_info
.s
.link_up
) {
515 if (!netif_carrier_ok(dev
))
516 netif_carrier_on(dev
);
517 } else if (netif_carrier_ok(dev
)) {
518 netif_carrier_off(dev
);
520 cvm_oct_note_carrier(priv
, link_info
);
523 static int cvm_oct_xaui_open(struct net_device
*dev
)
525 return cvm_oct_common_open(dev
, cvm_oct_link_poll
);
528 static const struct net_device_ops cvm_oct_npi_netdev_ops
= {
529 .ndo_init
= cvm_oct_common_init
,
530 .ndo_uninit
= cvm_oct_common_uninit
,
531 .ndo_start_xmit
= cvm_oct_xmit
,
532 .ndo_set_rx_mode
= cvm_oct_common_set_multicast_list
,
533 .ndo_set_mac_address
= cvm_oct_common_set_mac_address
,
534 .ndo_do_ioctl
= cvm_oct_ioctl
,
535 .ndo_change_mtu
= cvm_oct_common_change_mtu
,
536 .ndo_get_stats
= cvm_oct_common_get_stats
,
537 #ifdef CONFIG_NET_POLL_CONTROLLER
538 .ndo_poll_controller
= cvm_oct_poll_controller
,
542 static const struct net_device_ops cvm_oct_xaui_netdev_ops
= {
543 .ndo_init
= cvm_oct_common_init
,
544 .ndo_uninit
= cvm_oct_common_uninit
,
545 .ndo_open
= cvm_oct_xaui_open
,
546 .ndo_stop
= cvm_oct_common_stop
,
547 .ndo_start_xmit
= cvm_oct_xmit
,
548 .ndo_set_rx_mode
= cvm_oct_common_set_multicast_list
,
549 .ndo_set_mac_address
= cvm_oct_common_set_mac_address
,
550 .ndo_do_ioctl
= cvm_oct_ioctl
,
551 .ndo_change_mtu
= cvm_oct_common_change_mtu
,
552 .ndo_get_stats
= cvm_oct_common_get_stats
,
553 #ifdef CONFIG_NET_POLL_CONTROLLER
554 .ndo_poll_controller
= cvm_oct_poll_controller
,
558 static const struct net_device_ops cvm_oct_sgmii_netdev_ops
= {
559 .ndo_init
= cvm_oct_sgmii_init
,
560 .ndo_uninit
= cvm_oct_common_uninit
,
561 .ndo_open
= cvm_oct_sgmii_open
,
562 .ndo_stop
= cvm_oct_common_stop
,
563 .ndo_start_xmit
= cvm_oct_xmit
,
564 .ndo_set_rx_mode
= cvm_oct_common_set_multicast_list
,
565 .ndo_set_mac_address
= cvm_oct_common_set_mac_address
,
566 .ndo_do_ioctl
= cvm_oct_ioctl
,
567 .ndo_change_mtu
= cvm_oct_common_change_mtu
,
568 .ndo_get_stats
= cvm_oct_common_get_stats
,
569 #ifdef CONFIG_NET_POLL_CONTROLLER
570 .ndo_poll_controller
= cvm_oct_poll_controller
,
574 static const struct net_device_ops cvm_oct_spi_netdev_ops
= {
575 .ndo_init
= cvm_oct_spi_init
,
576 .ndo_uninit
= cvm_oct_spi_uninit
,
577 .ndo_start_xmit
= cvm_oct_xmit
,
578 .ndo_set_rx_mode
= cvm_oct_common_set_multicast_list
,
579 .ndo_set_mac_address
= cvm_oct_common_set_mac_address
,
580 .ndo_do_ioctl
= cvm_oct_ioctl
,
581 .ndo_change_mtu
= cvm_oct_common_change_mtu
,
582 .ndo_get_stats
= cvm_oct_common_get_stats
,
583 #ifdef CONFIG_NET_POLL_CONTROLLER
584 .ndo_poll_controller
= cvm_oct_poll_controller
,
588 static const struct net_device_ops cvm_oct_rgmii_netdev_ops
= {
589 .ndo_init
= cvm_oct_common_init
,
590 .ndo_uninit
= cvm_oct_common_uninit
,
591 .ndo_open
= cvm_oct_rgmii_open
,
592 .ndo_stop
= cvm_oct_common_stop
,
593 .ndo_start_xmit
= cvm_oct_xmit
,
594 .ndo_set_rx_mode
= cvm_oct_common_set_multicast_list
,
595 .ndo_set_mac_address
= cvm_oct_common_set_mac_address
,
596 .ndo_do_ioctl
= cvm_oct_ioctl
,
597 .ndo_change_mtu
= cvm_oct_common_change_mtu
,
598 .ndo_get_stats
= cvm_oct_common_get_stats
,
599 #ifdef CONFIG_NET_POLL_CONTROLLER
600 .ndo_poll_controller
= cvm_oct_poll_controller
,
604 static const struct net_device_ops cvm_oct_pow_netdev_ops
= {
605 .ndo_init
= cvm_oct_common_init
,
606 .ndo_start_xmit
= cvm_oct_xmit_pow
,
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 struct device_node
*cvm_oct_of_get_child(
618 const struct device_node
*parent
, int reg_val
)
620 struct device_node
*node
= NULL
;
625 node
= of_get_next_child(parent
, node
);
628 addr
= of_get_property(node
, "reg", &size
);
629 if (addr
&& (be32_to_cpu(*addr
) == reg_val
))
635 static struct device_node
*cvm_oct_node_for_port(struct device_node
*pip
,
636 int interface
, int port
)
638 struct device_node
*ni
, *np
;
640 ni
= cvm_oct_of_get_child(pip
, interface
);
644 np
= cvm_oct_of_get_child(ni
, port
);
650 static int cvm_oct_probe(struct platform_device
*pdev
)
654 int fau
= FAU_NUM_PACKET_BUFFERS_TO_FREE
;
656 struct device_node
*pip
;
658 octeon_mdiobus_force_mod_depencency();
660 pip
= pdev
->dev
.of_node
;
662 pr_err("Error: No 'pip' in /aliases\n");
667 cvm_oct_configure_common_hw();
669 cvmx_helper_initialize_packet_io_global();
671 /* Change the input group for all ports before input is enabled */
672 num_interfaces
= cvmx_helper_get_number_of_interfaces();
673 for (interface
= 0; interface
< num_interfaces
; interface
++) {
674 int num_ports
= cvmx_helper_ports_on_interface(interface
);
677 for (port
= cvmx_helper_get_ipd_port(interface
, 0);
678 port
< cvmx_helper_get_ipd_port(interface
, num_ports
);
680 union cvmx_pip_prt_tagx pip_prt_tagx
;
683 cvmx_read_csr(CVMX_PIP_PRT_TAGX(port
));
684 pip_prt_tagx
.s
.grp
= pow_receive_group
;
685 cvmx_write_csr(CVMX_PIP_PRT_TAGX(port
),
690 cvmx_helper_ipd_and_packet_input_enable();
692 memset(cvm_oct_device
, 0, sizeof(cvm_oct_device
));
695 * Initialize the FAU used for counting packet buffers that
698 cvmx_fau_atomic_write32(FAU_NUM_PACKET_BUFFERS_TO_FREE
, 0);
700 /* Initialize the FAU used for counting tx SKBs that need to be freed */
701 cvmx_fau_atomic_write32(FAU_TOTAL_TX_TO_CLEAN
, 0);
703 if ((pow_send_group
!= -1)) {
704 struct net_device
*dev
;
706 pr_info("\tConfiguring device for POW only access\n");
707 dev
= alloc_etherdev(sizeof(struct octeon_ethernet
));
709 /* Initialize the device private structure. */
710 struct octeon_ethernet
*priv
= netdev_priv(dev
);
712 dev
->netdev_ops
= &cvm_oct_pow_netdev_ops
;
713 priv
->imode
= CVMX_HELPER_INTERFACE_MODE_DISABLED
;
714 priv
->port
= CVMX_PIP_NUM_INPUT_PORTS
;
716 strcpy(dev
->name
, "pow%d");
717 for (qos
= 0; qos
< 16; qos
++)
718 skb_queue_head_init(&priv
->tx_free_list
[qos
]);
720 if (register_netdev(dev
) < 0) {
721 pr_err("Failed to register ethernet device for POW\n");
724 cvm_oct_device
[CVMX_PIP_NUM_INPUT_PORTS
] = dev
;
725 pr_info("%s: POW send group %d, receive group %d\n",
726 dev
->name
, pow_send_group
,
730 pr_err("Failed to allocate ethernet device for POW\n");
734 num_interfaces
= cvmx_helper_get_number_of_interfaces();
735 for (interface
= 0; interface
< num_interfaces
; interface
++) {
736 cvmx_helper_interface_mode_t imode
=
737 cvmx_helper_interface_get_mode(interface
);
738 int num_ports
= cvmx_helper_ports_on_interface(interface
);
743 port
= cvmx_helper_get_ipd_port(interface
, 0);
744 port
< cvmx_helper_get_ipd_port(interface
, num_ports
);
745 port_index
++, port
++) {
746 struct octeon_ethernet
*priv
;
747 struct net_device
*dev
=
748 alloc_etherdev(sizeof(struct octeon_ethernet
));
750 pr_err("Failed to allocate ethernet device for port %d\n",
755 /* Initialize the device private structure. */
756 priv
= netdev_priv(dev
);
758 priv
->of_node
= cvm_oct_node_for_port(pip
, interface
,
761 INIT_DELAYED_WORK(&priv
->port_periodic_work
,
762 cvm_oct_periodic_worker
);
765 priv
->queue
= cvmx_pko_get_base_queue(priv
->port
);
766 priv
->fau
= fau
- cvmx_pko_get_num_queues(port
) * 4;
767 for (qos
= 0; qos
< 16; qos
++)
768 skb_queue_head_init(&priv
->tx_free_list
[qos
]);
769 for (qos
= 0; qos
< cvmx_pko_get_num_queues(port
);
771 cvmx_fau_atomic_write32(priv
->fau
+ qos
* 4, 0);
773 switch (priv
->imode
) {
774 /* These types don't support ports to IPD/PKO */
775 case CVMX_HELPER_INTERFACE_MODE_DISABLED
:
776 case CVMX_HELPER_INTERFACE_MODE_PCIE
:
777 case CVMX_HELPER_INTERFACE_MODE_PICMG
:
780 case CVMX_HELPER_INTERFACE_MODE_NPI
:
781 dev
->netdev_ops
= &cvm_oct_npi_netdev_ops
;
782 strcpy(dev
->name
, "npi%d");
785 case CVMX_HELPER_INTERFACE_MODE_XAUI
:
786 dev
->netdev_ops
= &cvm_oct_xaui_netdev_ops
;
787 strcpy(dev
->name
, "xaui%d");
790 case CVMX_HELPER_INTERFACE_MODE_LOOP
:
791 dev
->netdev_ops
= &cvm_oct_npi_netdev_ops
;
792 strcpy(dev
->name
, "loop%d");
795 case CVMX_HELPER_INTERFACE_MODE_SGMII
:
796 dev
->netdev_ops
= &cvm_oct_sgmii_netdev_ops
;
797 strcpy(dev
->name
, "eth%d");
800 case CVMX_HELPER_INTERFACE_MODE_SPI
:
801 dev
->netdev_ops
= &cvm_oct_spi_netdev_ops
;
802 strcpy(dev
->name
, "spi%d");
805 case CVMX_HELPER_INTERFACE_MODE_RGMII
:
806 case CVMX_HELPER_INTERFACE_MODE_GMII
:
807 dev
->netdev_ops
= &cvm_oct_rgmii_netdev_ops
;
808 strcpy(dev
->name
, "eth%d");
812 if (!dev
->netdev_ops
) {
814 } else if (register_netdev(dev
) < 0) {
815 pr_err("Failed to register ethernet device for interface %d, port %d\n",
816 interface
, priv
->port
);
819 cvm_oct_device
[priv
->port
] = dev
;
821 cvmx_pko_get_num_queues(priv
->port
) *
823 schedule_delayed_work(&priv
->port_periodic_work
, HZ
);
828 cvm_oct_tx_initialize();
829 cvm_oct_rx_initialize();
832 * 150 uS: about 10 1500-byte packets at 1GE.
834 cvm_oct_tx_poll_interval
= 150 * (octeon_get_clock_rate() / 1000000);
836 schedule_delayed_work(&cvm_oct_rx_refill_work
, HZ
);
841 static int cvm_oct_remove(struct platform_device
*pdev
)
845 /* Disable POW interrupt */
846 if (OCTEON_IS_MODEL(OCTEON_CN68XX
))
847 cvmx_write_csr(CVMX_SSO_WQ_INT_THRX(pow_receive_group
), 0);
849 cvmx_write_csr(CVMX_POW_WQ_INT_THRX(pow_receive_group
), 0);
853 /* Free the interrupt handler */
854 free_irq(OCTEON_IRQ_WORKQ0
+ pow_receive_group
, cvm_oct_device
);
856 atomic_inc_return(&cvm_oct_poll_queue_stopping
);
857 cancel_delayed_work_sync(&cvm_oct_rx_refill_work
);
859 cvm_oct_rx_shutdown();
860 cvm_oct_tx_shutdown();
864 /* Free the ethernet devices */
865 for (port
= 0; port
< TOTAL_NUMBER_OF_PORTS
; port
++) {
866 if (cvm_oct_device
[port
]) {
867 struct net_device
*dev
= cvm_oct_device
[port
];
868 struct octeon_ethernet
*priv
= netdev_priv(dev
);
870 cancel_delayed_work_sync(&priv
->port_periodic_work
);
872 cvm_oct_tx_shutdown_dev(dev
);
873 unregister_netdev(dev
);
875 cvm_oct_device
[port
] = NULL
;
884 /* Free the HW pools */
885 cvm_oct_mem_empty_fpa(CVMX_FPA_PACKET_POOL
, CVMX_FPA_PACKET_POOL_SIZE
,
887 cvm_oct_mem_empty_fpa(CVMX_FPA_WQE_POOL
, CVMX_FPA_WQE_POOL_SIZE
,
889 if (CVMX_FPA_OUTPUT_BUFFER_POOL
!= CVMX_FPA_PACKET_POOL
)
890 cvm_oct_mem_empty_fpa(CVMX_FPA_OUTPUT_BUFFER_POOL
,
891 CVMX_FPA_OUTPUT_BUFFER_POOL_SIZE
, 128);
895 static const struct of_device_id cvm_oct_match
[] = {
897 .compatible
= "cavium,octeon-3860-pip",
901 MODULE_DEVICE_TABLE(of
, cvm_oct_match
);
903 static struct platform_driver cvm_oct_driver
= {
904 .probe
= cvm_oct_probe
,
905 .remove
= cvm_oct_remove
,
907 .name
= KBUILD_MODNAME
,
908 .of_match_table
= cvm_oct_match
,
912 module_platform_driver(cvm_oct_driver
);
914 MODULE_LICENSE("GPL");
915 MODULE_AUTHOR("Cavium Networks <support@caviumnetworks.com>");
916 MODULE_DESCRIPTION("Cavium Networks Octeon ethernet driver.");