xref: /onnv-gate/usr/src/uts/common/io/fcoe/fcoe_eth.c (revision 9307:7d2e1e823986)

/*
 * 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;

	/*
	 * 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) {
			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);
}