/*
 * Copyright (C) 2003-2009 Chelsio Communications.  All rights reserved.
 *
 * Written by Divy Le Ray (divy@chelsio.com)
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the LICENSE file included in this
 * release for licensing terms and conditions.
 */

#include "defs.h"
#include <linux/toedev.h>

#include "tom.h"
#include "cpl_io_state.h"
#include "t3_cpl.h"
#include "cxgb3_ctl_defs.h"
#include "firmware_exports.h"

#include <drivers/net/bonding/bonding.h>

/* Adapted from drivers/net/bonding/bond_3ad.c:__get_bond_by_port() */
static inline struct bonding *toe_bond_get_bond_by_port(struct port *port)
{
	if (port->slave == NULL)
		return NULL;

	return bond_get_bond_by_slave(port->slave);
}

/* Adapted from drivers/net/bonding/bond_3ad.c:__get_first_port() */
static inline struct port *toe_bond_get_first_port(struct bonding *bond)
{
	if (bond->slave_cnt == 0)
		return NULL;

	return &(SLAVE_AD_INFO(bond->first_slave).port);
}

/* Adapted from drivers/net/bonding/bond_3ad.c:__get_next_port() */
static inline struct port *toe_bond_get_next_port(struct port *port)
{
	struct bonding *bond = toe_bond_get_bond_by_port(port);
	struct slave *slave = port->slave;

	/* If there's no bond for this port, or this is the last slave */
	if ((bond == NULL) || (slave->next == bond->first_slave))
		return NULL;

	return &(SLAVE_AD_INFO(slave->next).port);
}

static inline int total_ports(struct toedev *tdev)
{
	struct adap_ports *port_info = TOM_DATA(tdev)->ports;

	return port_info->nports;
}

static inline int lookup_port(struct net_device *slave_dev)
{
	int i, port = -1;
	struct toedev *tdev = TOEDEV(slave_dev);
	struct adap_ports *port_info = TOM_DATA(tdev)->ports;

	for (i = 0; i < port_info->nports; i++) {
		if (slave_dev != port_info->lldevs[i])
			continue;

		port = i;
		break;
	}
	return port;
}

static inline int lld_evt(int event)
{
	return event + FAILOVER_ACTIVE_SLAVE;
}

static void four_ports_failover(struct toedev *tdev,
				struct net_device *bond_dev,
				struct net_device *slave_dev,
				int event)
{
	struct bond_ports bond_ports;
	struct bonding *bond = (struct bonding *)netdev_priv(bond_dev);
	struct slave *slave = NULL;
	int port_idx,  idx = 0, i;
	struct port *port;

	if (!slave_dev) /* bond release all */
		return;

	switch (bond->params.mode) {
	case BOND_MODE_ACTIVEBACKUP:
		/*
		 * Ignore release events.
		 * A new active slave might be picked up
		 * soon after, we just care about this.
		 */
		if (event != TOE_ACTIVE_SLAVE)
			return;

		port_idx = lookup_port(slave_dev);
		bond_ports.port = port_idx;
		bond_ports.nports = 0;

		bond_for_each_slave(bond, slave, i) {
			if (slave->dev != slave_dev) {
				bond_ports.ports[idx++] =
					lookup_port(slave->dev);
				bond_ports.nports++;
			}
		}
		tdev->ctl(tdev, lld_evt(event), &bond_ports);
		break;

	case BOND_MODE_8023AD:
		if (event == TOE_ACTIVE_SLAVE)
			return;

		port_idx = lookup_port(slave_dev);
		bond_ports.port = port_idx;
		bond_ports.nports = 0;

		for (port = toe_bond_get_first_port(bond); port;
		     port = toe_bond_get_next_port(port)) {
			if (port->slave->dev != slave_dev &&
			    port->slave->state == BOND_STATE_ACTIVE) {
				bond_ports.ports[idx++] =
					lookup_port(port->slave->dev);
				bond_ports.nports++;
			}
		}
		tdev->ctl(tdev, lld_evt(event), &bond_ports);
		break;

	case BOND_MODE_XOR:
		port_idx = lookup_port(slave_dev);
		bond_ports.port = port_idx;
		bond_ports.nports = 0;

		bond_for_each_slave(bond, slave, i) {
			if (slave->dev != slave_dev &&
			    slave->state == BOND_STATE_ACTIVE) {
				bond_ports.ports[idx++] =
					lookup_port(slave->dev);
				bond_ports.nports++;
			}
		}
		tdev->ctl(tdev, lld_evt(event), &bond_ports);
		break;
	}
	return;
}

static void failover(struct toedev *tdev,
		     struct net_device *bond_dev,
		     struct net_device *slave_dev,
		     int event)
{
	int failed_port, if_port = 0;

	if (event == TOE_LINK_DOWN) {
		failed_port = lookup_port(slave_dev);
		if_port = !failed_port;
		tdev->ctl(tdev, FAILOVER, &if_port);

	} else if (event == TOE_LINK_UP) {
		if_port = lookup_port(slave_dev);
		tdev->ctl(tdev, FAILOVER, &if_port);
	}

	return;
}

/* Called under bonding locks (bond_mii_monitor) */
int t3_failover(struct toedev *tdev, struct net_device *bond_dev,
		struct net_device *slave_dev, int event, struct net_device *last_dev)
{
	struct bonding *bond = (struct bonding *)netdev_priv(bond_dev);
	int active_ports = 0;
	struct port *port;
	int if_port;

	/* differentiate 4 ports and 2 ports adapters */
	if (tdev->nlldev > 2) {
		four_ports_failover(tdev, bond_dev, slave_dev, event);
		return 0;
	}

	/* Last slave removed. Map the event to a complete release */
	if (event == TOE_RELEASE && bond->slave_cnt == 1)
		event = TOE_RELEASE_ALL;

	switch (bond->params.mode) {
	case BOND_MODE_ACTIVEBACKUP:
		if (event == TOE_ACTIVE_SLAVE) {
			if (!slave_dev || bond->slave_cnt == 1)
				tdev->ctl(tdev, FAILOVER_CLEAR, NULL);
			else {
				if_port = lookup_port(slave_dev);
				tdev->ctl(tdev, FAILOVER, &if_port);
			}
		} else if (event == TOE_RELEASE_ALL)
			tdev->ctl(tdev, FAILOVER_CLEAR, NULL);
		break;
	case BOND_MODE_8023AD:
		if (event == TOE_ACTIVE_SLAVE)
			return 0;

		for (port = toe_bond_get_first_port(bond); port;
		     port = toe_bond_get_next_port(port))
			active_ports +=
				(port->slave->state == BOND_STATE_ACTIVE);

		/* One port enslaved only. Ignore failover events */
		if (bond->slave_cnt == 1)
			return 0;

		/* No more active port */
		if ((event == TOE_LINK_DOWN || event == TOE_RELEASE) &&
		    !active_ports) {
			tdev->ctl(tdev, FAILOVER_CLEAR, NULL);
			return 0;
		}

		/* Dead port back alive in a already active bond device */
		if (event == TOE_LINK_UP && active_ports > 1) {
			if_port = lookup_port(slave_dev);
			tdev->ctl(tdev, FAILOVER_DONE, &if_port);
			return 0;
		}
		/* fall through */
	case BOND_MODE_XOR:
		/* One port enslaved only. Ignore failover events */
		if (bond->slave_cnt == 1)
			return 0;

		failover(tdev, bond_dev, slave_dev, event);
	}
	return 0;
}

void t3_update_master_devs(struct toedev *tdev)
{
	int i;

	for (i = 0; i < tdev->nlldev; i++) {
		struct net_device *dev = tdev->lldev[i];

		if (dev->flags & IFF_SLAVE) {
			struct net_device *bond_dev = dev->master;
			struct bonding *bond = (struct bonding *)netdev_priv(bond_dev);
			struct toedev *slave_tdev = NULL;
			struct slave *slave;
			int i, ofld_cnt = 0;

			if (netdev_is_offload(bond_dev))
				continue;

			read_lock_bh(&bond->lock);
			bond_for_each_slave(bond, slave, i) {
				ofld_cnt += !!netdev_is_offload(slave->dev);

				if (!slave_tdev)
					slave_tdev = TOEDEV(slave->dev);
				else if (slave_tdev != TOEDEV(slave->dev)) {
					slave_tdev = NULL;
					break;
				}
			}
			read_unlock_bh(&bond->lock);

			if (ofld_cnt == bond->slave_cnt && slave_tdev)
				netdev_set_offload(bond_dev);
		}
	}
}