mirror of https://github.com/Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
519 lines
13 KiB
519 lines
13 KiB
// SPDX-License-Identifier: GPL-2.0-only |
|
/* 10G controller driver for Samsung SoCs |
|
* |
|
* Copyright (C) 2013 Samsung Electronics Co., Ltd. |
|
* http://www.samsung.com |
|
* |
|
* Author: Siva Reddy Kallam <[email protected]> |
|
*/ |
|
|
|
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt |
|
|
|
#include <linux/bitops.h> |
|
#include <linux/export.h> |
|
#include <linux/io.h> |
|
#include <linux/netdevice.h> |
|
#include <linux/phy.h> |
|
|
|
#include "sxgbe_common.h" |
|
#include "sxgbe_dma.h" |
|
#include "sxgbe_desc.h" |
|
|
|
/* DMA TX descriptor ring initialization */ |
|
static void sxgbe_init_tx_desc(struct sxgbe_tx_norm_desc *p) |
|
{ |
|
p->tdes23.tx_rd_des23.own_bit = 0; |
|
} |
|
|
|
static void sxgbe_tx_desc_enable_tse(struct sxgbe_tx_norm_desc *p, u8 is_tse, |
|
u32 total_hdr_len, u32 tcp_hdr_len, |
|
u32 tcp_payload_len) |
|
{ |
|
p->tdes23.tx_rd_des23.tse_bit = is_tse; |
|
p->tdes23.tx_rd_des23.buf1_size = total_hdr_len; |
|
p->tdes23.tx_rd_des23.tcp_hdr_len = tcp_hdr_len / 4; |
|
p->tdes23.tx_rd_des23.tx_pkt_len.tcp_payload_len = tcp_payload_len; |
|
} |
|
|
|
/* Assign buffer lengths for descriptor */ |
|
static void sxgbe_prepare_tx_desc(struct sxgbe_tx_norm_desc *p, u8 is_fd, |
|
int buf1_len, int pkt_len, int cksum) |
|
{ |
|
p->tdes23.tx_rd_des23.first_desc = is_fd; |
|
p->tdes23.tx_rd_des23.buf1_size = buf1_len; |
|
|
|
p->tdes23.tx_rd_des23.tx_pkt_len.pkt_len.total_pkt_len = pkt_len; |
|
|
|
if (cksum) |
|
p->tdes23.tx_rd_des23.cksum_ctl = cic_full; |
|
} |
|
|
|
/* Set VLAN control information */ |
|
static void sxgbe_tx_vlanctl_desc(struct sxgbe_tx_norm_desc *p, int vlan_ctl) |
|
{ |
|
p->tdes23.tx_rd_des23.vlan_tag_ctl = vlan_ctl; |
|
} |
|
|
|
/* Set the owner of Normal descriptor */ |
|
static void sxgbe_set_tx_owner(struct sxgbe_tx_norm_desc *p) |
|
{ |
|
p->tdes23.tx_rd_des23.own_bit = 1; |
|
} |
|
|
|
/* Get the owner of Normal descriptor */ |
|
static int sxgbe_get_tx_owner(struct sxgbe_tx_norm_desc *p) |
|
{ |
|
return p->tdes23.tx_rd_des23.own_bit; |
|
} |
|
|
|
/* Invoked by the xmit function to close the tx descriptor */ |
|
static void sxgbe_close_tx_desc(struct sxgbe_tx_norm_desc *p) |
|
{ |
|
p->tdes23.tx_rd_des23.last_desc = 1; |
|
p->tdes23.tx_rd_des23.int_on_com = 1; |
|
} |
|
|
|
/* Clean the tx descriptor as soon as the tx irq is received */ |
|
static void sxgbe_release_tx_desc(struct sxgbe_tx_norm_desc *p) |
|
{ |
|
memset(p, 0, sizeof(*p)); |
|
} |
|
|
|
/* Clear interrupt on tx frame completion. When this bit is |
|
* set an interrupt happens as soon as the frame is transmitted |
|
*/ |
|
static void sxgbe_clear_tx_ic(struct sxgbe_tx_norm_desc *p) |
|
{ |
|
p->tdes23.tx_rd_des23.int_on_com = 0; |
|
} |
|
|
|
/* Last tx segment reports the transmit status */ |
|
static int sxgbe_get_tx_ls(struct sxgbe_tx_norm_desc *p) |
|
{ |
|
return p->tdes23.tx_rd_des23.last_desc; |
|
} |
|
|
|
/* Get the buffer size from the descriptor */ |
|
static int sxgbe_get_tx_len(struct sxgbe_tx_norm_desc *p) |
|
{ |
|
return p->tdes23.tx_rd_des23.buf1_size; |
|
} |
|
|
|
/* Set tx timestamp enable bit */ |
|
static void sxgbe_tx_enable_tstamp(struct sxgbe_tx_norm_desc *p) |
|
{ |
|
p->tdes23.tx_rd_des23.timestmp_enable = 1; |
|
} |
|
|
|
/* get tx timestamp status */ |
|
static int sxgbe_get_tx_timestamp_status(struct sxgbe_tx_norm_desc *p) |
|
{ |
|
return p->tdes23.tx_rd_des23.timestmp_enable; |
|
} |
|
|
|
/* TX Context Descripto Specific */ |
|
static void sxgbe_tx_ctxt_desc_set_ctxt(struct sxgbe_tx_ctxt_desc *p) |
|
{ |
|
p->ctxt_bit = 1; |
|
} |
|
|
|
/* Set the owner of TX context descriptor */ |
|
static void sxgbe_tx_ctxt_desc_set_owner(struct sxgbe_tx_ctxt_desc *p) |
|
{ |
|
p->own_bit = 1; |
|
} |
|
|
|
/* Get the owner of TX context descriptor */ |
|
static int sxgbe_tx_ctxt_desc_get_owner(struct sxgbe_tx_ctxt_desc *p) |
|
{ |
|
return p->own_bit; |
|
} |
|
|
|
/* Set TX mss in TX context Descriptor */ |
|
static void sxgbe_tx_ctxt_desc_set_mss(struct sxgbe_tx_ctxt_desc *p, u16 mss) |
|
{ |
|
p->maxseg_size = mss; |
|
} |
|
|
|
/* Get TX mss from TX context Descriptor */ |
|
static int sxgbe_tx_ctxt_desc_get_mss(struct sxgbe_tx_ctxt_desc *p) |
|
{ |
|
return p->maxseg_size; |
|
} |
|
|
|
/* Set TX tcmssv in TX context Descriptor */ |
|
static void sxgbe_tx_ctxt_desc_set_tcmssv(struct sxgbe_tx_ctxt_desc *p) |
|
{ |
|
p->tcmssv = 1; |
|
} |
|
|
|
/* Reset TX ostc in TX context Descriptor */ |
|
static void sxgbe_tx_ctxt_desc_reset_ostc(struct sxgbe_tx_ctxt_desc *p) |
|
{ |
|
p->ostc = 0; |
|
} |
|
|
|
/* Set IVLAN information */ |
|
static void sxgbe_tx_ctxt_desc_set_ivlantag(struct sxgbe_tx_ctxt_desc *p, |
|
int is_ivlanvalid, int ivlan_tag, |
|
int ivlan_ctl) |
|
{ |
|
if (is_ivlanvalid) { |
|
p->ivlan_tag_valid = is_ivlanvalid; |
|
p->ivlan_tag = ivlan_tag; |
|
p->ivlan_tag_ctl = ivlan_ctl; |
|
} |
|
} |
|
|
|
/* Return IVLAN Tag */ |
|
static int sxgbe_tx_ctxt_desc_get_ivlantag(struct sxgbe_tx_ctxt_desc *p) |
|
{ |
|
return p->ivlan_tag; |
|
} |
|
|
|
/* Set VLAN Tag */ |
|
static void sxgbe_tx_ctxt_desc_set_vlantag(struct sxgbe_tx_ctxt_desc *p, |
|
int is_vlanvalid, int vlan_tag) |
|
{ |
|
if (is_vlanvalid) { |
|
p->vltag_valid = is_vlanvalid; |
|
p->vlan_tag = vlan_tag; |
|
} |
|
} |
|
|
|
/* Return VLAN Tag */ |
|
static int sxgbe_tx_ctxt_desc_get_vlantag(struct sxgbe_tx_ctxt_desc *p) |
|
{ |
|
return p->vlan_tag; |
|
} |
|
|
|
/* Set Time stamp */ |
|
static void sxgbe_tx_ctxt_desc_set_tstamp(struct sxgbe_tx_ctxt_desc *p, |
|
u8 ostc_enable, u64 tstamp) |
|
{ |
|
if (ostc_enable) { |
|
p->ostc = ostc_enable; |
|
p->tstamp_lo = (u32) tstamp; |
|
p->tstamp_hi = (u32) (tstamp>>32); |
|
} |
|
} |
|
/* Close TX context descriptor */ |
|
static void sxgbe_tx_ctxt_desc_close(struct sxgbe_tx_ctxt_desc *p) |
|
{ |
|
p->own_bit = 1; |
|
} |
|
|
|
/* WB status of context descriptor */ |
|
static int sxgbe_tx_ctxt_desc_get_cde(struct sxgbe_tx_ctxt_desc *p) |
|
{ |
|
return p->ctxt_desc_err; |
|
} |
|
|
|
/* DMA RX descriptor ring initialization */ |
|
static void sxgbe_init_rx_desc(struct sxgbe_rx_norm_desc *p, int disable_rx_ic, |
|
int mode, int end) |
|
{ |
|
p->rdes23.rx_rd_des23.own_bit = 1; |
|
if (disable_rx_ic) |
|
p->rdes23.rx_rd_des23.int_on_com = disable_rx_ic; |
|
} |
|
|
|
/* Get RX own bit */ |
|
static int sxgbe_get_rx_owner(struct sxgbe_rx_norm_desc *p) |
|
{ |
|
return p->rdes23.rx_rd_des23.own_bit; |
|
} |
|
|
|
/* Set RX own bit */ |
|
static void sxgbe_set_rx_owner(struct sxgbe_rx_norm_desc *p) |
|
{ |
|
p->rdes23.rx_rd_des23.own_bit = 1; |
|
} |
|
|
|
/* Set Interrupt on completion bit */ |
|
static void sxgbe_set_rx_int_on_com(struct sxgbe_rx_norm_desc *p) |
|
{ |
|
p->rdes23.rx_rd_des23.int_on_com = 1; |
|
} |
|
|
|
/* Get the receive frame size */ |
|
static int sxgbe_get_rx_frame_len(struct sxgbe_rx_norm_desc *p) |
|
{ |
|
return p->rdes23.rx_wb_des23.pkt_len; |
|
} |
|
|
|
/* Return first Descriptor status */ |
|
static int sxgbe_get_rx_fd_status(struct sxgbe_rx_norm_desc *p) |
|
{ |
|
return p->rdes23.rx_wb_des23.first_desc; |
|
} |
|
|
|
/* Return Last Descriptor status */ |
|
static int sxgbe_get_rx_ld_status(struct sxgbe_rx_norm_desc *p) |
|
{ |
|
return p->rdes23.rx_wb_des23.last_desc; |
|
} |
|
|
|
|
|
/* Return the RX status looking at the WB fields */ |
|
static int sxgbe_rx_wbstatus(struct sxgbe_rx_norm_desc *p, |
|
struct sxgbe_extra_stats *x, int *checksum) |
|
{ |
|
int status = 0; |
|
|
|
*checksum = CHECKSUM_UNNECESSARY; |
|
if (p->rdes23.rx_wb_des23.err_summary) { |
|
switch (p->rdes23.rx_wb_des23.err_l2_type) { |
|
case RX_GMII_ERR: |
|
status = -EINVAL; |
|
x->rx_code_gmii_err++; |
|
break; |
|
case RX_WATCHDOG_ERR: |
|
status = -EINVAL; |
|
x->rx_watchdog_err++; |
|
break; |
|
case RX_CRC_ERR: |
|
status = -EINVAL; |
|
x->rx_crc_err++; |
|
break; |
|
case RX_GAINT_ERR: |
|
status = -EINVAL; |
|
x->rx_gaint_pkt_err++; |
|
break; |
|
case RX_IP_HDR_ERR: |
|
*checksum = CHECKSUM_NONE; |
|
x->ip_hdr_err++; |
|
break; |
|
case RX_PAYLOAD_ERR: |
|
*checksum = CHECKSUM_NONE; |
|
x->ip_payload_err++; |
|
break; |
|
case RX_OVERFLOW_ERR: |
|
status = -EINVAL; |
|
x->overflow_error++; |
|
break; |
|
default: |
|
pr_err("Invalid Error type\n"); |
|
break; |
|
} |
|
} else { |
|
switch (p->rdes23.rx_wb_des23.err_l2_type) { |
|
case RX_LEN_PKT: |
|
x->len_pkt++; |
|
break; |
|
case RX_MACCTL_PKT: |
|
x->mac_ctl_pkt++; |
|
break; |
|
case RX_DCBCTL_PKT: |
|
x->dcb_ctl_pkt++; |
|
break; |
|
case RX_ARP_PKT: |
|
x->arp_pkt++; |
|
break; |
|
case RX_OAM_PKT: |
|
x->oam_pkt++; |
|
break; |
|
case RX_UNTAG_PKT: |
|
x->untag_okt++; |
|
break; |
|
case RX_OTHER_PKT: |
|
x->other_pkt++; |
|
break; |
|
case RX_SVLAN_PKT: |
|
x->svlan_tag_pkt++; |
|
break; |
|
case RX_CVLAN_PKT: |
|
x->cvlan_tag_pkt++; |
|
break; |
|
case RX_DVLAN_OCVLAN_ICVLAN_PKT: |
|
x->dvlan_ocvlan_icvlan_pkt++; |
|
break; |
|
case RX_DVLAN_OSVLAN_ISVLAN_PKT: |
|
x->dvlan_osvlan_isvlan_pkt++; |
|
break; |
|
case RX_DVLAN_OSVLAN_ICVLAN_PKT: |
|
x->dvlan_osvlan_icvlan_pkt++; |
|
break; |
|
case RX_DVLAN_OCVLAN_ISVLAN_PKT: |
|
x->dvlan_ocvlan_icvlan_pkt++; |
|
break; |
|
default: |
|
pr_err("Invalid L2 Packet type\n"); |
|
break; |
|
} |
|
} |
|
|
|
/* L3/L4 Pkt type */ |
|
switch (p->rdes23.rx_wb_des23.layer34_pkt_type) { |
|
case RX_NOT_IP_PKT: |
|
x->not_ip_pkt++; |
|
break; |
|
case RX_IPV4_TCP_PKT: |
|
x->ip4_tcp_pkt++; |
|
break; |
|
case RX_IPV4_UDP_PKT: |
|
x->ip4_udp_pkt++; |
|
break; |
|
case RX_IPV4_ICMP_PKT: |
|
x->ip4_icmp_pkt++; |
|
break; |
|
case RX_IPV4_UNKNOWN_PKT: |
|
x->ip4_unknown_pkt++; |
|
break; |
|
case RX_IPV6_TCP_PKT: |
|
x->ip6_tcp_pkt++; |
|
break; |
|
case RX_IPV6_UDP_PKT: |
|
x->ip6_udp_pkt++; |
|
break; |
|
case RX_IPV6_ICMP_PKT: |
|
x->ip6_icmp_pkt++; |
|
break; |
|
case RX_IPV6_UNKNOWN_PKT: |
|
x->ip6_unknown_pkt++; |
|
break; |
|
default: |
|
pr_err("Invalid L3/L4 Packet type\n"); |
|
break; |
|
} |
|
|
|
/* Filter */ |
|
if (p->rdes23.rx_wb_des23.vlan_filter_match) |
|
x->vlan_filter_match++; |
|
|
|
if (p->rdes23.rx_wb_des23.sa_filter_fail) { |
|
status = -EINVAL; |
|
x->sa_filter_fail++; |
|
} |
|
if (p->rdes23.rx_wb_des23.da_filter_fail) { |
|
status = -EINVAL; |
|
x->da_filter_fail++; |
|
} |
|
if (p->rdes23.rx_wb_des23.hash_filter_pass) |
|
x->hash_filter_pass++; |
|
|
|
if (p->rdes23.rx_wb_des23.l3_filter_match) |
|
x->l3_filter_match++; |
|
|
|
if (p->rdes23.rx_wb_des23.l4_filter_match) |
|
x->l4_filter_match++; |
|
|
|
return status; |
|
} |
|
|
|
/* Get own bit of context descriptor */ |
|
static int sxgbe_get_rx_ctxt_owner(struct sxgbe_rx_ctxt_desc *p) |
|
{ |
|
return p->own_bit; |
|
} |
|
|
|
/* Set own bit for context descriptor */ |
|
static void sxgbe_set_ctxt_rx_owner(struct sxgbe_rx_ctxt_desc *p) |
|
{ |
|
p->own_bit = 1; |
|
} |
|
|
|
|
|
/* Return the reception status looking at Context control information */ |
|
static void sxgbe_rx_ctxt_wbstatus(struct sxgbe_rx_ctxt_desc *p, |
|
struct sxgbe_extra_stats *x) |
|
{ |
|
if (p->tstamp_dropped) |
|
x->timestamp_dropped++; |
|
|
|
/* ptp */ |
|
if (p->ptp_msgtype == RX_NO_PTP) |
|
x->rx_msg_type_no_ptp++; |
|
else if (p->ptp_msgtype == RX_PTP_SYNC) |
|
x->rx_ptp_type_sync++; |
|
else if (p->ptp_msgtype == RX_PTP_FOLLOW_UP) |
|
x->rx_ptp_type_follow_up++; |
|
else if (p->ptp_msgtype == RX_PTP_DELAY_REQ) |
|
x->rx_ptp_type_delay_req++; |
|
else if (p->ptp_msgtype == RX_PTP_DELAY_RESP) |
|
x->rx_ptp_type_delay_resp++; |
|
else if (p->ptp_msgtype == RX_PTP_PDELAY_REQ) |
|
x->rx_ptp_type_pdelay_req++; |
|
else if (p->ptp_msgtype == RX_PTP_PDELAY_RESP) |
|
x->rx_ptp_type_pdelay_resp++; |
|
else if (p->ptp_msgtype == RX_PTP_PDELAY_FOLLOW_UP) |
|
x->rx_ptp_type_pdelay_follow_up++; |
|
else if (p->ptp_msgtype == RX_PTP_ANNOUNCE) |
|
x->rx_ptp_announce++; |
|
else if (p->ptp_msgtype == RX_PTP_MGMT) |
|
x->rx_ptp_mgmt++; |
|
else if (p->ptp_msgtype == RX_PTP_SIGNAL) |
|
x->rx_ptp_signal++; |
|
else if (p->ptp_msgtype == RX_PTP_RESV_MSG) |
|
x->rx_ptp_resv_msg_type++; |
|
} |
|
|
|
/* Get rx timestamp status */ |
|
static int sxgbe_get_rx_ctxt_tstamp_status(struct sxgbe_rx_ctxt_desc *p) |
|
{ |
|
if ((p->tstamp_hi == 0xffffffff) && (p->tstamp_lo == 0xffffffff)) { |
|
pr_err("Time stamp corrupted\n"); |
|
return 0; |
|
} |
|
|
|
return p->tstamp_available; |
|
} |
|
|
|
|
|
static u64 sxgbe_get_rx_timestamp(struct sxgbe_rx_ctxt_desc *p) |
|
{ |
|
u64 ns; |
|
|
|
ns = p->tstamp_lo; |
|
ns |= ((u64)p->tstamp_hi) << 32; |
|
|
|
return ns; |
|
} |
|
|
|
static const struct sxgbe_desc_ops desc_ops = { |
|
.init_tx_desc = sxgbe_init_tx_desc, |
|
.tx_desc_enable_tse = sxgbe_tx_desc_enable_tse, |
|
.prepare_tx_desc = sxgbe_prepare_tx_desc, |
|
.tx_vlanctl_desc = sxgbe_tx_vlanctl_desc, |
|
.set_tx_owner = sxgbe_set_tx_owner, |
|
.get_tx_owner = sxgbe_get_tx_owner, |
|
.close_tx_desc = sxgbe_close_tx_desc, |
|
.release_tx_desc = sxgbe_release_tx_desc, |
|
.clear_tx_ic = sxgbe_clear_tx_ic, |
|
.get_tx_ls = sxgbe_get_tx_ls, |
|
.get_tx_len = sxgbe_get_tx_len, |
|
.tx_enable_tstamp = sxgbe_tx_enable_tstamp, |
|
.get_tx_timestamp_status = sxgbe_get_tx_timestamp_status, |
|
.tx_ctxt_desc_set_ctxt = sxgbe_tx_ctxt_desc_set_ctxt, |
|
.tx_ctxt_desc_set_owner = sxgbe_tx_ctxt_desc_set_owner, |
|
.get_tx_ctxt_owner = sxgbe_tx_ctxt_desc_get_owner, |
|
.tx_ctxt_desc_set_mss = sxgbe_tx_ctxt_desc_set_mss, |
|
.tx_ctxt_desc_get_mss = sxgbe_tx_ctxt_desc_get_mss, |
|
.tx_ctxt_desc_set_tcmssv = sxgbe_tx_ctxt_desc_set_tcmssv, |
|
.tx_ctxt_desc_reset_ostc = sxgbe_tx_ctxt_desc_reset_ostc, |
|
.tx_ctxt_desc_set_ivlantag = sxgbe_tx_ctxt_desc_set_ivlantag, |
|
.tx_ctxt_desc_get_ivlantag = sxgbe_tx_ctxt_desc_get_ivlantag, |
|
.tx_ctxt_desc_set_vlantag = sxgbe_tx_ctxt_desc_set_vlantag, |
|
.tx_ctxt_desc_get_vlantag = sxgbe_tx_ctxt_desc_get_vlantag, |
|
.tx_ctxt_set_tstamp = sxgbe_tx_ctxt_desc_set_tstamp, |
|
.close_tx_ctxt_desc = sxgbe_tx_ctxt_desc_close, |
|
.get_tx_ctxt_cde = sxgbe_tx_ctxt_desc_get_cde, |
|
.init_rx_desc = sxgbe_init_rx_desc, |
|
.get_rx_owner = sxgbe_get_rx_owner, |
|
.set_rx_owner = sxgbe_set_rx_owner, |
|
.set_rx_int_on_com = sxgbe_set_rx_int_on_com, |
|
.get_rx_frame_len = sxgbe_get_rx_frame_len, |
|
.get_rx_fd_status = sxgbe_get_rx_fd_status, |
|
.get_rx_ld_status = sxgbe_get_rx_ld_status, |
|
.rx_wbstatus = sxgbe_rx_wbstatus, |
|
.get_rx_ctxt_owner = sxgbe_get_rx_ctxt_owner, |
|
.set_rx_ctxt_owner = sxgbe_set_ctxt_rx_owner, |
|
.rx_ctxt_wbstatus = sxgbe_rx_ctxt_wbstatus, |
|
.get_rx_ctxt_tstamp_status = sxgbe_get_rx_ctxt_tstamp_status, |
|
.get_timestamp = sxgbe_get_rx_timestamp, |
|
}; |
|
|
|
const struct sxgbe_desc_ops *sxgbe_get_desc_ops(void) |
|
{ |
|
return &desc_ops; |
|
}
|
|
|