/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2009 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#include <sys/stat.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/inttypes.h>
#include <sys/strsun.h>
#include <sys/mac_client.h>
/*
* FCoE header files
*/
#include <sys/fcoe/fcoeio.h>
#include <sys/fcoe/fcoe_common.h>
/*
* Driver's own header files
*/
#include <fcoe.h>
#include <fcoe_eth.h>
#include <fcoe_fc.h>
static void fcoe_rx(void *arg, mac_resource_handle_t mrh,
mblk_t *mp, boolean_t loopback);
static void fcoe_mac_notify(void *arg, mac_notify_type_t type);
/*
* Global variable definitions
*/
/*
* Internal tunable, used to enable p2p mode
*/
volatile uint32_t fcoe_enable_p2pmode = 0;
int
fcoe_open_mac(fcoe_mac_t *mac, int force_promisc, fcoeio_stat_t *err_detail)
{
int ret;
int fcoe_ret;
char cli_name[MAXNAMELEN];
mac_diag_t diag;
uint16_t fm_open_flag = 0;
*err_detail = 0;
/*
* Open MAC interface
*/
ret = mac_open_by_linkid(mac->fm_linkid, &mac->fm_handle);
if (ret != 0) {
FCOE_LOG("fcoe", "mac_open_by_linkname %d failed %x",
mac->fm_linkid, ret);
return (FCOE_FAILURE);
}
(void) sprintf(cli_name, "%s-%d", "fcoe", mac->fm_linkid);
ret = mac_client_open(mac->fm_handle,
&mac->fm_cli_handle, cli_name, fm_open_flag);
if (ret != 0) {
(void) fcoe_close_mac(mac);
return (FCOE_FAILURE);
}
/*
* Cache the pointer of the immutable MAC inforamtion and
* the current and primary MAC address
*/
mac_unicast_primary_get(mac->fm_handle, mac->fm_primary_addr);
bcopy(mac->fm_primary_addr, mac->fm_current_addr,
ETHERADDRL);
if (mac_unicast_add(mac->fm_cli_handle, NULL, MAC_UNICAST_PRIMARY,
&mac->fm_unicst_handle, 0, &diag)) {
(void) fcoe_close_mac(mac);
return (FCOE_FAILURE);
}
if (force_promisc) {
mac->fm_force_promisc = B_TRUE;
}
/* Get mtu */
mac_sdu_get(mac->fm_handle, NULL, &mac->fm_eport.eport_mtu);
if (mac->fm_eport.eport_mtu < FCOE_MIN_MTU_SIZE) {
if (!fcoe_enable_p2pmode || mac->fm_eport.eport_mtu < 1500) {
/*
* Fail open if fail to get mtu, or we are not
* using p2p, or we are using p2p, but
* the mtu is too small
*/
(void) fcoe_close_mac(mac);
*err_detail = FCOEIOE_NEED_JUMBO_FRAME;
return (FCOE_FAILURE);
}
}
mac->fm_eport.eport_link_speed =
mac_client_stat_get(mac->fm_cli_handle, MAC_STAT_IFSPEED);
cv_init(&mac->fm_tx_cv, NULL, CV_DRIVER, NULL);
mutex_init(&mac->fm_mutex, NULL, MUTEX_DRIVER, NULL);
mac->fm_running = B_TRUE;
fcoe_ret = FCOE_SUCCESS;
return (fcoe_ret);
}
int
fcoe_close_mac(fcoe_mac_t *mac)
{
int ret;
if (mac->fm_handle == NULL) {
return (FCOE_SUCCESS);
}
if (mac->fm_running) {
cv_destroy(&mac->fm_tx_cv);
mutex_destroy(&mac->fm_mutex);
mac->fm_running = B_FALSE;
}
if (mac->fm_promisc_handle != NULL) {
mac_promisc_remove(mac->fm_promisc_handle);
mac->fm_promisc_handle = NULL;
} else {
mac_rx_clear(mac->fm_cli_handle);
}
if (mac->fm_notify_handle != NULL) {
ret = mac_notify_remove(mac->fm_notify_handle, B_TRUE);
ASSERT(ret == 0);
mac->fm_notify_handle = NULL;
}
if (mac->fm_unicst_handle != NULL) {
(void) mac_unicast_remove(mac->fm_cli_handle,
mac->fm_unicst_handle);
mac->fm_unicst_handle = NULL;
}
mac_client_close(mac->fm_cli_handle, 0);
mac->fm_cli_handle = NULL;
(void) mac_close(mac->fm_handle);
mac->fm_handle = NULL;
return (FCOE_SUCCESS);
}
int
fcoe_enable_callback(fcoe_mac_t *mac)
{
int ret;
/*
* Set message callback
*/
if (mac->fm_force_promisc) {
ret = mac_promisc_add(mac->fm_cli_handle,
MAC_CLIENT_PROMISC_FILTERED, fcoe_rx, mac,
&mac->fm_promisc_handle,
MAC_PROMISC_FLAGS_NO_TX_LOOP);
if (ret != 0) {
FCOE_LOG("foce", "mac_promisc_add on %d failed %x",
mac->fm_linkid, ret);
return (FCOE_FAILURE);
}
} else {
mac_rx_set(mac->fm_cli_handle, fcoe_rx, mac);
}
/* Get the link state, if it's up, we will need to notify client */
mac->fm_link_state =
mac_stat_get(mac->fm_handle, MAC_STAT_LINK_UP)?
FCOE_MAC_LINK_STATE_UP:FCOE_MAC_LINK_STATE_DOWN;
mac->fm_eport.eport_link_speed =
mac_client_stat_get(mac->fm_cli_handle, MAC_STAT_IFSPEED);
/*
* Add a notify function so that we get updates from MAC
*/
mac->fm_notify_handle = mac_notify_add(mac->fm_handle,
fcoe_mac_notify, (void *)mac);
return (FCOE_SUCCESS);
}
int
fcoe_disable_callback(fcoe_mac_t *mac)
{
int ret;
if (mac->fm_promisc_handle) {
mac_promisc_remove(mac->fm_promisc_handle);
mac->fm_promisc_handle = NULL;
} else {
mac_rx_clear(mac->fm_cli_handle);
}
if (mac->fm_notify_handle) {
ret = mac_notify_remove(mac->fm_notify_handle, B_TRUE);
ASSERT(ret == 0);
mac->fm_notify_handle = NULL;
}
ret = fcoe_mac_set_address(&mac->fm_eport,
mac->fm_primary_addr, B_FALSE);
FCOE_SET_DEFAULT_FPORT_ADDR(mac->fm_eport.eport_efh_dst);
return (ret);
}
/* ARGSUSED */
static void
fcoe_rx(void *arg, mac_resource_handle_t mrh, mblk_t *mp, boolean_t loopback)
{
fcoe_mac_t *mac = (fcoe_mac_t *)arg;
mblk_t *next;
fcoe_frame_t *frm;
uint32_t raw_frame_size, frame_size;
uint16_t frm_type;
while (mp != NULL) {
next = mp->b_next;
mp->b_next = NULL;
frm_type = ntohs(*(uint16_t *)((uintptr_t)mp->b_rptr + 12));
if (frm_type != ETHERTYPE_FCOE) {
/*
* This mp is not allocated in FCoE, but we must free it
*/
freeb(mp);
mp = next;
continue;
}
raw_frame_size = MBLKL(mp);
frame_size = raw_frame_size - PADDING_SIZE;
frm = fcoe_allocate_frame(&mac->fm_eport, frame_size, mp);
if (frm != NULL) {
frm->frm_clock = CURRENT_CLOCK;
fcoe_post_frame(frm);
}
mp = next;
}
}
static void
fcoe_mac_notify(void *arg, mac_notify_type_t type)
{
fcoe_mac_t *mac = (fcoe_mac_t *)arg;
/*
* We assume that the calls to this notification callback are serialized
* by MAC layer
*/
switch (type) {
case MAC_NOTE_LINK:
/*
* This notification is sent every time the MAC driver
* updates the link state.
*/
if (mac_stat_get(mac->fm_handle, MAC_STAT_LINK_UP) != 0) {
if (mac->fm_link_state == FCOE_MAC_LINK_STATE_UP) {
break;
}
/* Get speed */
mac->fm_eport.eport_link_speed =
mac_client_stat_get(mac->fm_cli_handle,
MAC_STAT_IFSPEED);
(void) fcoe_mac_set_address(&mac->fm_eport,
mac->fm_primary_addr, B_FALSE);
FCOE_SET_DEFAULT_FPORT_ADDR(
mac->fm_eport.eport_efh_dst);
mac->fm_link_state = FCOE_MAC_LINK_STATE_UP;
FCOE_LOG(NULL,
"fcoe_mac_notify: link/%d arg/%p LINK up",
mac->fm_linkid, arg, type);
fcoe_mac_notify_link_up(mac);
} else {
if (mac->fm_link_state == FCOE_MAC_LINK_STATE_DOWN) {
break;
}
mac->fm_link_state = FCOE_MAC_LINK_STATE_DOWN;
FCOE_LOG(NULL,
"fcoe_mac_notify: link/%d arg/%p LINK down",
mac->fm_linkid, arg, type);
fcoe_mac_notify_link_down(mac);
}
break;
case MAC_NOTE_TX:
/*
* MAC is not so busy now, then wake up fcoe_tx_frame to try
*/
mutex_enter(&mac->fm_mutex);
cv_broadcast(&mac->fm_tx_cv);
mutex_exit(&mac->fm_mutex);
FCOE_LOG("fcoe_mac_notify", "wake up");
break;
default:
FCOE_LOG("fcoe_mac_notify", "not supported arg/%p, type/%d",
arg, type);
break;
}
}
int
fcoe_mac_set_address(fcoe_port_t *eport, uint8_t *addr, boolean_t fc_assigned)
{
fcoe_mac_t *mac = EPORT2MAC(eport);
int ret;
if (bcmp(addr, mac->fm_current_addr, 6) == 0) {
return (FCOE_SUCCESS);
}
mutex_enter(&mac->fm_mutex);
if (mac->fm_promisc_handle == NULL) {
ret = mac_unicast_primary_set(mac->fm_handle, addr);
if (ret != 0) {
mutex_exit(&mac->fm_mutex);
FCOE_LOG("fcoe", "mac_unicast_primary_set on %d "
"failed %x", mac->fm_linkid, ret);
return (FCOE_FAILURE);
}
}
if (fc_assigned) {
bcopy(addr, mac->fm_current_addr, ETHERADDRL);
} else {
bcopy(mac->fm_primary_addr,
mac->fm_current_addr, ETHERADDRL);
}
mutex_exit(&mac->fm_mutex);
return (FCOE_SUCCESS);
}