/* * Copyright (C) 2005 - 2008 ServerEngines * All rights reserved. * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License version 2 * as published by the Free Software Foundation. The full GNU General * Public License is included in this distribution in the file called COPYING. * * Contact Information: * linux-drivers@serverengines.com * * ServerEngines * 209 N. Fair Oaks Ave * Sunnyvale, CA 94085 */ /* * be_netif.c * * This file contains various entry points of drivers seen by tcp/ip stack. */ #include #include #include "benet.h" #include #include /* Strings to print Link properties */ static const char *link_speed[] = { "Invalid link Speed Value", "10 Mbps", "100 Mbps", "1 Gbps", "10 Gbps" }; static const char *link_duplex[] = { "Invalid Duplex Value", "Half Duplex", "Full Duplex" }; static const char *link_state[] = { "", "(active)" }; void be_print_link_info(struct BE_LINK_STATUS *lnk_status) { u16 si, di, ai; /* Port 0 */ if (lnk_status->mac0_speed && lnk_status->mac0_duplex) { /* Port is up and running */ si = (lnk_status->mac0_speed < 5) ? lnk_status->mac0_speed : 0; di = (lnk_status->mac0_duplex < 3) ? lnk_status->mac0_duplex : 0; ai = (lnk_status->active_port == 0) ? 1 : 0; printk(KERN_INFO "PortNo. 0: Speed - %s %s %s\n", link_speed[si], link_duplex[di], link_state[ai]); } else printk(KERN_INFO "PortNo. 0: Down\n"); /* Port 1 */ if (lnk_status->mac1_speed && lnk_status->mac1_duplex) { /* Port is up and running */ si = (lnk_status->mac1_speed < 5) ? lnk_status->mac1_speed : 0; di = (lnk_status->mac1_duplex < 3) ? lnk_status->mac1_duplex : 0; ai = (lnk_status->active_port == 0) ? 1 : 0; printk(KERN_INFO "PortNo. 1: Speed - %s %s %s\n", link_speed[si], link_duplex[di], link_state[ai]); } else printk(KERN_INFO "PortNo. 1: Down\n"); return; } static int be_get_frag_header(struct skb_frag_struct *frag, void **mac_hdr, void **ip_hdr, void **tcpudp_hdr, u64 *hdr_flags, void *priv) { struct ethhdr *eh; struct vlan_ethhdr *veh; struct iphdr *iph; u8 *va = page_address(frag->page) + frag->page_offset; unsigned long ll_hlen; /* find the mac header, abort if not IPv4 */ prefetch(va); eh = (struct ethhdr *)va; *mac_hdr = eh; ll_hlen = ETH_HLEN; if (eh->h_proto != htons(ETH_P_IP)) { if (eh->h_proto == htons(ETH_P_8021Q)) { veh = (struct vlan_ethhdr *)va; if (veh->h_vlan_encapsulated_proto != htons(ETH_P_IP)) return -1; ll_hlen += VLAN_HLEN; } else { return -1; } } *hdr_flags = LRO_IPV4; iph = (struct iphdr *)(va + ll_hlen); *ip_hdr = iph; if (iph->protocol != IPPROTO_TCP) return -1; *hdr_flags |= LRO_TCP; *tcpudp_hdr = (u8 *) (*ip_hdr) + (iph->ihl << 2); return 0; } static int benet_open(struct net_device *netdev) { struct be_net_object *pnob = netdev_priv(netdev); struct be_adapter *adapter = pnob->adapter; struct net_lro_mgr *lro_mgr; if (adapter->dev_state < BE_DEV_STATE_INIT) return -EAGAIN; lro_mgr = &pnob->lro_mgr; lro_mgr->dev = netdev; lro_mgr->features = LRO_F_NAPI; lro_mgr->ip_summed = CHECKSUM_UNNECESSARY; lro_mgr->ip_summed_aggr = CHECKSUM_UNNECESSARY; lro_mgr->max_desc = BE_MAX_LRO_DESCRIPTORS; lro_mgr->lro_arr = pnob->lro_desc; lro_mgr->get_frag_header = be_get_frag_header; lro_mgr->max_aggr = adapter->max_rx_coal; lro_mgr->frag_align_pad = 2; if (lro_mgr->max_aggr > MAX_SKB_FRAGS) lro_mgr->max_aggr = MAX_SKB_FRAGS; adapter->max_rx_coal = BE_LRO_MAX_PKTS; be_update_link_status(adapter); /* * Set carrier on only if Physical Link up * Either of the port link status up signifies this */ if ((adapter->port0_link_sts == BE_PORT_LINK_UP) || (adapter->port1_link_sts == BE_PORT_LINK_UP)) { netif_start_queue(netdev); netif_carrier_on(netdev); } adapter->dev_state = BE_DEV_STATE_OPEN; napi_enable(&pnob->napi); be_enable_intr(pnob); be_enable_eq_intr(pnob); /* * RX completion queue may be in dis-armed state. Arm it. */ be_notify_cmpl(pnob, 0, pnob->rx_cq_id, 1); return 0; } static int benet_close(struct net_device *netdev) { struct be_net_object *pnob = netdev_priv(netdev); struct be_adapter *adapter = pnob->adapter; netif_stop_queue(netdev); synchronize_irq(netdev->irq); be_wait_nic_tx_cmplx_cmpl(pnob); adapter->dev_state = BE_DEV_STATE_INIT; netif_carrier_off(netdev); adapter->port0_link_sts = BE_PORT_LINK_DOWN; adapter->port1_link_sts = BE_PORT_LINK_DOWN; be_disable_intr(pnob); be_disable_eq_intr(pnob); napi_disable(&pnob->napi); return 0; } /* * Setting a Mac Address for BE * Takes netdev and a void pointer as arguments. * The pointer holds the new addres to be used. */ static int benet_set_mac_addr(struct net_device *netdev, void *p) { struct sockaddr *addr = p; struct be_net_object *pnob = netdev_priv(netdev); memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len); be_rxf_mac_address_read_write(&pnob->fn_obj, 0, 0, false, true, false, netdev->dev_addr, NULL, NULL); /* * Since we are doing Active-Passive failover, both * ports should have matching MAC addresses everytime. */ be_rxf_mac_address_read_write(&pnob->fn_obj, 1, 0, false, true, false, netdev->dev_addr, NULL, NULL); return 0; } void be_get_stats_timer_handler(unsigned long context) { struct be_timer_ctxt *ctxt = (struct be_timer_ctxt *)context; if (atomic_read(&ctxt->get_stat_flag)) { atomic_dec(&ctxt->get_stat_flag); up((void *)ctxt->get_stat_sem_addr); } del_timer(&ctxt->get_stats_timer); return; } void be_get_stat_cb(void *context, int status, struct MCC_WRB_AMAP *optional_wrb) { struct be_timer_ctxt *ctxt = (struct be_timer_ctxt *)context; /* * just up the semaphore if the get_stat_flag * reads 1. so that the waiter can continue. * If it is 0, then it was handled by the timer handler. */ del_timer(&ctxt->get_stats_timer); if (atomic_read(&ctxt->get_stat_flag)) { atomic_dec(&ctxt->get_stat_flag); up((void *)ctxt->get_stat_sem_addr); } } struct net_device_stats *benet_get_stats(struct net_device *dev) { struct be_net_object *pnob = netdev_priv(dev); struct be_adapter *adapter = pnob->adapter; u64 pa; struct be_timer_ctxt *ctxt = &adapter->timer_ctxt; if (adapter->dev_state != BE_DEV_STATE_OPEN) { /* Return previously read stats */ return &(adapter->benet_stats); } /* Get Physical Addr */ pa = pci_map_single(adapter->pdev, adapter->eth_statsp, sizeof(struct FWCMD_ETH_GET_STATISTICS), PCI_DMA_FROMDEVICE); ctxt->get_stat_sem_addr = (unsigned long)&adapter->get_eth_stat_sem; atomic_inc(&ctxt->get_stat_flag); be_rxf_query_eth_statistics(&pnob->fn_obj, adapter->eth_statsp, cpu_to_le64(pa), be_get_stat_cb, ctxt, NULL); ctxt->get_stats_timer.data = (unsigned long)ctxt; mod_timer(&ctxt->get_stats_timer, (jiffies + (HZ * 2))); down((void *)ctxt->get_stat_sem_addr); /* callback will unblock us */ /* Adding port0 and port1 stats. */ adapter->benet_stats.rx_packets = adapter->eth_statsp->params.response.p0recvdtotalframes + adapter->eth_statsp->params.response.p1recvdtotalframes; adapter->benet_stats.tx_packets = adapter->eth_statsp->params.response.p0xmitunicastframes + adapter->eth_statsp->params.response.p1xmitunicastframes; adapter->benet_stats.tx_bytes = adapter->eth_statsp->params.response.p0xmitbyteslsd + adapter->eth_statsp->params.response.p1xmitbyteslsd; adapter->benet_stats.rx_errors = adapter->eth_statsp->params.response.p0crcerrors + adapter->eth_statsp->params.response.p1crcerrors; adapter->benet_stats.rx_errors += adapter->eth_statsp->params.response.p0alignmentsymerrs + adapter->eth_statsp->params.response.p1alignmentsymerrs; adapter->benet_stats.rx_errors += adapter->eth_statsp->params.response.p0inrangelenerrors + adapter->eth_statsp->params.response.p1inrangelenerrors; adapter->benet_stats.rx_bytes = adapter->eth_statsp->params.response.p0recvdtotalbytesLSD + adapter->eth_statsp->params.response.p1recvdtotalbytesLSD; adapter->benet_stats.rx_crc_errors = adapter->eth_statsp->params.response.p0crcerrors + adapter->eth_statsp->params.response.p1crcerrors; adapter->benet_stats.tx_packets += adapter->eth_statsp->params.response.p0xmitmulticastframes + adapter->eth_statsp->params.response.p1xmitmulticastframes; adapter->benet_stats.tx_packets += adapter->eth_statsp->params.response.p0xmitbroadcastframes + adapter->eth_statsp->params.response.p1xmitbroadcastframes; adapter->benet_stats.tx_errors = 0; adapter->benet_stats.multicast = adapter->eth_statsp->params.response.p0xmitmulticastframes + adapter->eth_statsp->params.response.p1xmitmulticastframes; adapter->benet_stats.rx_fifo_errors = adapter->eth_statsp->params.response.p0rxfifooverflowdropped + adapter->eth_statsp->params.response.p1rxfifooverflowdropped; adapter->benet_stats.rx_frame_errors = adapter->eth_statsp->params.response.p0alignmentsymerrs + adapter->eth_statsp->params.response.p1alignmentsymerrs; adapter->benet_stats.rx_length_errors = adapter->eth_statsp->params.response.p0inrangelenerrors + adapter->eth_statsp->params.response.p1inrangelenerrors; adapter->benet_stats.rx_length_errors += adapter->eth_statsp->params.response.p0outrangeerrors + adapter->eth_statsp->params.response.p1outrangeerrors; adapter->benet_stats.rx_length_errors += adapter->eth_statsp->params.response.p0frametoolongerrors + adapter->eth_statsp->params.response.p1frametoolongerrors; pci_unmap_single(adapter->pdev, (ulong) adapter->eth_statsp, sizeof(struct FWCMD_ETH_GET_STATISTICS), PCI_DMA_FROMDEVICE); return &(adapter->benet_stats); } static void be_start_tx(struct be_net_object *pnob, u32 nposted) { #define CSR_ETH_MAX_SQPOSTS 255 struct SQ_DB_AMAP sqdb; sqdb.dw[0] = 0; AMAP_SET_BITS_PTR(SQ_DB, cid, &sqdb, pnob->tx_q_id); while (nposted) { if (nposted > CSR_ETH_MAX_SQPOSTS) { AMAP_SET_BITS_PTR(SQ_DB, numPosted, &sqdb, CSR_ETH_MAX_SQPOSTS); nposted -= CSR_ETH_MAX_SQPOSTS; } else { AMAP_SET_BITS_PTR(SQ_DB, numPosted, &sqdb, nposted); nposted = 0; } PD_WRITE(&pnob->fn_obj, etx_sq_db, sqdb.dw[0]); } return; } static void update_tx_rate(struct be_adapter *adapter) { /* update the rate once in two seconds */ if ((jiffies - adapter->eth_tx_jiffies) > 2 * (HZ)) { u32 r; r = adapter->eth_tx_bytes / ((jiffies - adapter->eth_tx_jiffies) / (HZ)); r = (r / 1000000); /* M bytes/s */ adapter->be_stat.bes_eth_tx_rate = (r * 8); /* M bits/s */ adapter->eth_tx_jiffies = jiffies; adapter->eth_tx_bytes = 0; } } static int wrb_cnt_in_skb(struct sk_buff *skb) { int cnt = 0; while (skb) { if (skb->len > skb->data_len) cnt++; cnt += skb_shinfo(skb)->nr_frags; skb = skb_shinfo(skb)->frag_list; } BUG_ON(cnt > BE_MAX_TX_FRAG_COUNT); return cnt; } static void wrb_fill(struct ETH_WRB_AMAP *wrb, u64 addr, int len) { AMAP_SET_BITS_PTR(ETH_WRB, frag_pa_hi, wrb, addr >> 32); AMAP_SET_BITS_PTR(ETH_WRB, frag_pa_lo, wrb, addr & 0xFFFFFFFF); AMAP_SET_BITS_PTR(ETH_WRB, frag_len, wrb, len); } static void wrb_fill_extra(struct ETH_WRB_AMAP *wrb, struct sk_buff *skb, struct be_net_object *pnob) { wrb->dw[2] = 0; wrb->dw[3] = 0; AMAP_SET_BITS_PTR(ETH_WRB, crc, wrb, 1); if (skb_shinfo(skb)->gso_segs > 1 && skb_shinfo(skb)->gso_size) { AMAP_SET_BITS_PTR(ETH_WRB, lso, wrb, 1); AMAP_SET_BITS_PTR(ETH_WRB, lso_mss, wrb, skb_shinfo(skb)->gso_size); } else if (skb->ip_summed == CHECKSUM_PARTIAL) { u8 proto = ((struct iphdr *)ip_hdr(skb))->protocol; if (proto == IPPROTO_TCP) AMAP_SET_BITS_PTR(ETH_WRB, tcpcs, wrb, 1); else if (proto == IPPROTO_UDP) AMAP_SET_BITS_PTR(ETH_WRB, udpcs, wrb, 1); } if (pnob->vlan_grp && vlan_tx_tag_present(skb)) { AMAP_SET_BITS_PTR(ETH_WRB, vlan, wrb, 1); AMAP_SET_BITS_PTR(ETH_WRB, vlan_tag, wrb, vlan_tx_tag_get(skb)); } } static inline void wrb_copy_extra(struct ETH_WRB_AMAP *to, struct ETH_WRB_AMAP *from) { to->dw[2] = from->dw[2]; to->dw[3] = from->dw[3]; } /* Returns the actual count of wrbs used including a possible dummy */ static int copy_skb_to_txq(struct be_net_object *pnob, struct sk_buff *skb, u32 wrb_cnt, u32 *copied) { u64 busaddr; struct ETH_WRB_AMAP *wrb = NULL, *first = NULL; u32 i; bool dummy = true; struct pci_dev *pdev = pnob->adapter->pdev; if (wrb_cnt & 1) wrb_cnt++; else dummy = false; atomic_add(wrb_cnt, &pnob->tx_q_used); while (skb) { if (skb->len > skb->data_len) { int len = skb->len - skb->data_len; busaddr = pci_map_single(pdev, skb->data, len, PCI_DMA_TODEVICE); busaddr = cpu_to_le64(busaddr); wrb = &pnob->tx_q[pnob->tx_q_hd]; if (first == NULL) { wrb_fill_extra(wrb, skb, pnob); first = wrb; } else { wrb_copy_extra(wrb, first); } wrb_fill(wrb, busaddr, len); be_adv_txq_hd(pnob); *copied += len; } for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) { struct skb_frag_struct *frag = &skb_shinfo(skb)->frags[i]; busaddr = pci_map_page(pdev, frag->page, frag->page_offset, frag->size, PCI_DMA_TODEVICE); busaddr = cpu_to_le64(busaddr); wrb = &pnob->tx_q[pnob->tx_q_hd]; if (first == NULL) { wrb_fill_extra(wrb, skb, pnob); first = wrb; } else { wrb_copy_extra(wrb, first); } wrb_fill(wrb, busaddr, frag->size); be_adv_txq_hd(pnob); *copied += frag->size; } skb = skb_shinfo(skb)->frag_list; } if (dummy) { wrb = &pnob->tx_q[pnob->tx_q_hd]; BUG_ON(first == NULL); wrb_copy_extra(wrb, first); wrb_fill(wrb, 0, 0); be_adv_txq_hd(pnob); } AMAP_SET_BITS_PTR(ETH_WRB, complete, wrb, 1); AMAP_SET_BITS_PTR(ETH_WRB, last, wrb, 1); return wrb_cnt; } /* For each skb transmitted, tx_ctxt stores the num of wrbs in the * start index and skb pointer in the end index */ static inline void be_tx_wrb_info_remember(struct be_net_object *pnob, struct sk_buff *skb, int wrb_cnt, u32 start) { *(u32 *) (&pnob->tx_ctxt[start]) = wrb_cnt; index_adv(&start, wrb_cnt - 1, pnob->tx_q_len); pnob->tx_ctxt[start] = skb; } static int benet_xmit(struct sk_buff *skb, struct net_device *netdev) { struct be_net_object *pnob = netdev_priv(netdev); struct be_adapter *adapter = pnob->adapter; u32 wrb_cnt, copied = 0; u32 start = pnob->tx_q_hd; adapter->be_stat.bes_tx_reqs++; wrb_cnt = wrb_cnt_in_skb(skb); spin_lock_bh(&adapter->txq_lock); if ((pnob->tx_q_len - 2 - atomic_read(&pnob->tx_q_used)) <= wrb_cnt) { netif_stop_queue(pnob->netdev); spin_unlock_bh(&adapter->txq_lock); adapter->be_stat.bes_tx_fails++; return NETDEV_TX_BUSY; } spin_unlock_bh(&adapter->txq_lock); wrb_cnt = copy_skb_to_txq(pnob, skb, wrb_cnt, &copied); be_tx_wrb_info_remember(pnob, skb, wrb_cnt, start); be_start_tx(pnob, wrb_cnt); adapter->eth_tx_bytes += copied; adapter->be_stat.bes_tx_wrbs += wrb_cnt; update_tx_rate(adapter); netdev->trans_start = jiffies; return NETDEV_TX_OK; } /* * This is the driver entry point to change the mtu of the device * Returns 0 for success and errno for failure. */ static int benet_change_mtu(struct net_device *netdev, int new_mtu) { /* * BE supports jumbo frame size upto 9000 bytes including the link layer * header. Considering the different variants of frame formats possible * like VLAN, SNAP/LLC, the maximum possible value for MTU is 8974 bytes */ if (new_mtu < (ETH_ZLEN + ETH_FCS_LEN) || (new_mtu > BE_MAX_MTU)) { dev_info(&netdev->dev, "Invalid MTU requested. " "Must be between %d and %d bytes\n", (ETH_ZLEN + ETH_FCS_LEN), BE_MAX_MTU); return -EINVAL; } dev_info(&netdev->dev, "MTU changed from %d to %d\n", netdev->mtu, new_mtu); netdev->mtu = new_mtu; return 0; } /* * This is the driver entry point to register a vlan with the device */ static void benet_vlan_register(struct net_device *netdev, struct vlan_group *grp) { struct be_net_object *pnob = netdev_priv(netdev); be_disable_eq_intr(pnob); pnob->vlan_grp = grp; pnob->num_vlans = 0; be_enable_eq_intr(pnob); } /* * This is the driver entry point to add a vlan vlan_id * with the device netdev */ static void benet_vlan_add_vid(struct net_device *netdev, u16 vlan_id) { struct be_net_object *pnob = netdev_priv(netdev); if (pnob->num_vlans == (BE_NUM_VLAN_SUPPORTED - 1)) { /* no way to return an error */ dev_info(&netdev->dev, "BladeEngine: Cannot configure more than %d Vlans\n", BE_NUM_VLAN_SUPPORTED); return; } /* The new vlan tag will be in the slot indicated by num_vlans. */ pnob->vlan_tag[pnob->num_vlans++] = vlan_id; be_rxf_vlan_config(&pnob->fn_obj, false, pnob->num_vlans, pnob->vlan_tag, NULL, NULL, NULL); } /* * This is the driver entry point to remove a vlan vlan_id * with the device netdev */ static void benet_vlan_rem_vid(struct net_device *netdev, u16 vlan_id) { struct be_net_object *pnob = netdev_priv(netdev); u32 i, value; /* * In Blade Engine, we support 32 vlan tag filters across both ports. * To program a vlan tag, the RXF_RTPR_CSR register is used. * Each 32-bit value of RXF_RTDR_CSR can address 2 vlan tag entries. * The Vlan table is of depth 16. thus we support 32 tags. */ value = vlan_id | VLAN_VALID_BIT; for (i = 0; i < BE_NUM_VLAN_SUPPORTED; i++) { if (pnob->vlan_tag[i] == vlan_id) break; } if (i == BE_NUM_VLAN_SUPPORTED) return; /* Now compact the vlan tag array by removing hole created. */ while ((i + 1) < BE_NUM_VLAN_SUPPORTED) { pnob->vlan_tag[i] = pnob->vlan_tag[i + 1]; i++; } if ((i + 1) == BE_NUM_VLAN_SUPPORTED) pnob->vlan_tag[i] = (u16) 0x0; pnob->num_vlans--; be_rxf_vlan_config(&pnob->fn_obj, false, pnob->num_vlans, pnob->vlan_tag, NULL, NULL, NULL); } /* * This function is called to program multicast * address in the multicast filter of the ASIC. */ static void be_set_multicast_filter(struct net_device *netdev) { struct be_net_object *pnob = netdev_priv(netdev); struct dev_mc_list *mc_ptr; u8 mac_addr[32][ETH_ALEN]; int i; if (netdev->flags & IFF_ALLMULTI) { /* set BE in Multicast promiscuous */ be_rxf_multicast_config(&pnob->fn_obj, true, 0, NULL, NULL, NULL, NULL); return; } for (mc_ptr = netdev->mc_list, i = 0; mc_ptr; mc_ptr = mc_ptr->next, i++) { memcpy(&mac_addr[i][0], mc_ptr->dmi_addr, ETH_ALEN); } /* reset the promiscuous mode also. */ be_rxf_multicast_config(&pnob->fn_obj, false, i, &mac_addr[0][0], NULL, NULL, NULL); } /* * This is the driver entry point to set multicast list * with the device netdev. This function will be used to * set promiscuous mode or multicast promiscuous mode * or multicast mode.... */ static void benet_set_multicast_list(struct net_device *netdev) { struct be_net_object *pnob = netdev_priv(netdev); if (netdev->flags & IFF_PROMISC) { be_rxf_promiscuous(&pnob->fn_obj, 1, 1, NULL, NULL, NULL); } else { be_rxf_promiscuous(&pnob->fn_obj, 0, 0, NULL, NULL, NULL); be_set_multicast_filter(netdev); } } int benet_init(struct net_device *netdev) { struct be_net_object *pnob = netdev_priv(netdev); struct be_adapter *adapter = pnob->adapter; ether_setup(netdev); netdev->open = &benet_open; netdev->stop = &benet_close; netdev->hard_start_xmit = &benet_xmit; netdev->get_stats = &benet_get_stats; netdev->set_multicast_list = &benet_set_multicast_list; netdev->change_mtu = &benet_change_mtu; netdev->set_mac_address = &benet_set_mac_addr; netdev->vlan_rx_register = benet_vlan_register; netdev->vlan_rx_add_vid = benet_vlan_add_vid; netdev->vlan_rx_kill_vid = benet_vlan_rem_vid; netdev->features = NETIF_F_SG | NETIF_F_HIGHDMA | NETIF_F_HW_VLAN_RX | NETIF_F_TSO | NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_FILTER | NETIF_F_IP_CSUM; netdev->flags |= IFF_MULTICAST; /* If device is DAC Capable, set the HIGHDMA flag for netdevice. */ if (adapter->dma_64bit_cap) netdev->features |= NETIF_F_HIGHDMA; SET_ETHTOOL_OPS(netdev, &be_ethtool_ops); return 0; }