// SPDX-License-Identifier: GPL-2.0-or-later

  /*
   * Copyright Gavin Shan, IBM Corporation 2016.

   */
  
  #include <linux/module.h>
  #include <linux/kernel.h>
  #include <linux/init.h>
  #include <linux/netdevice.h>
  #include <linux/skbuff.h>
  
  #include <net/ncsi.h>
  #include <net/net_namespace.h>
  #include <net/sock.h>
  
  #include "internal.h"
  #include "ncsi-pkt.h"
  
  static int ncsi_validate_aen_pkt(struct ncsi_aen_pkt_hdr *h,
  				 const unsigned short payload)
  {
  	u32 checksum;
  	__be32 *pchecksum;
  
  	if (h->common.revision != NCSI_PKT_REVISION)
  		return -EINVAL;
  	if (ntohs(h->common.length) != payload)
  		return -EINVAL;
  
  	/* Validate checksum, which might be zeroes if the
  	 * sender doesn't support checksum according to NCSI
  	 * specification.
  	 */
  	pchecksum = (__be32 *)((void *)(h + 1) + payload - 4);
  	if (ntohl(*pchecksum) == 0)
  		return 0;
  
  	checksum = ncsi_calculate_checksum((unsigned char *)h,
  					   sizeof(*h) + payload - 4);
  	if (*pchecksum != htonl(checksum))
  		return -EINVAL;
  
  	return 0;
  }
  
  static int ncsi_aen_handler_lsc(struct ncsi_dev_priv *ndp,
  				struct ncsi_aen_pkt_hdr *h)
  {

  	struct ncsi_channel *nc, *tmp;

  	struct ncsi_channel_mode *ncm;

  	unsigned long old_data, data;

  	struct ncsi_aen_lsc_pkt *lsc;
  	struct ncsi_package *np;

  	bool had_link, has_link;

  	unsigned long flags;
  	bool chained;
  	int state;

  
  	/* Find the NCSI channel */
  	ncsi_find_package_and_channel(ndp, h->common.channel, NULL, &nc);
  	if (!nc)
  		return -ENODEV;
  
  	/* Update the link status */

  	lsc = (struct ncsi_aen_lsc_pkt *)h;

  
  	spin_lock_irqsave(&nc->lock, flags);
  	ncm = &nc->modes[NCSI_MODE_LINK];

  	old_data = ncm->data[2];

  	data = ntohl(lsc->status);
  	ncm->data[2] = data;

  	ncm->data[4] = ntohl(lsc->oem_status);

  	had_link = !!(old_data & 0x1);
  	has_link = !!(data & 0x1);

  	netdev_dbg(ndp->ndev.dev, "NCSI: LSC AEN - channel %u state %s
  ",
  		   nc->id, data & 0x1 ? "up" : "down");

  	chained = !list_empty(&nc->link);
  	state = nc->state;
  	spin_unlock_irqrestore(&nc->lock, flags);

  	if (state == NCSI_CHANNEL_INACTIVE)
  		netdev_warn(ndp->ndev.dev,
  			    "NCSI: Inactive channel %u received AEN!
  ",
  			    nc->id);
  
  	if ((had_link == has_link) || chained)

  		return 0;

  	if (!ndp->multi_package && !nc->package->multi_channel) {
  		if (had_link) {
  			ndp->flags |= NCSI_DEV_RESHUFFLE;
  			ncsi_stop_channel_monitor(nc);
  			spin_lock_irqsave(&ndp->lock, flags);
  			list_add_tail_rcu(&nc->link, &ndp->channel_queue);
  			spin_unlock_irqrestore(&ndp->lock, flags);
  			return ncsi_process_next_channel(ndp);
  		}
  		/* Configured channel came up */
  		return 0;
  	}

  	if (had_link) {
  		ncm = &nc->modes[NCSI_MODE_TX_ENABLE];
  		if (ncsi_channel_is_last(ndp, nc)) {
  			/* No channels left, reconfigure */
  			return ncsi_reset_dev(&ndp->ndev);
  		} else if (ncm->enable) {
  			/* Need to failover Tx channel */
  			ncsi_update_tx_channel(ndp, nc->package, nc, NULL);
  		}
  	} else if (has_link && nc->package->preferred_channel == nc) {
  		/* Return Tx to preferred channel */
  		ncsi_update_tx_channel(ndp, nc->package, NULL, nc);
  	} else if (has_link) {
  		NCSI_FOR_EACH_PACKAGE(ndp, np) {
  			NCSI_FOR_EACH_CHANNEL(np, tmp) {
  				/* Enable Tx on this channel if the current Tx
  				 * channel is down.
  				 */
  				ncm = &tmp->modes[NCSI_MODE_TX_ENABLE];
  				if (ncm->enable &&
  				    !ncsi_channel_has_link(tmp)) {
  					ncsi_update_tx_channel(ndp, nc->package,
  							       tmp, nc);
  					break;
  				}
  			}
  		}
  	}
  
  	/* Leave configured channels active in a multi-channel scenario so
  	 * AEN events are still received.
  	 */
  	return 0;

  }
  
  static int ncsi_aen_handler_cr(struct ncsi_dev_priv *ndp,
  			       struct ncsi_aen_pkt_hdr *h)
  {
  	struct ncsi_channel *nc;
  	unsigned long flags;
  
  	/* Find the NCSI channel */
  	ncsi_find_package_and_channel(ndp, h->common.channel, NULL, &nc);
  	if (!nc)
  		return -ENODEV;

  	spin_lock_irqsave(&nc->lock, flags);

  	if (!list_empty(&nc->link) ||

  	    nc->state != NCSI_CHANNEL_ACTIVE) {
  		spin_unlock_irqrestore(&nc->lock, flags);

  		return 0;

  	}
  	spin_unlock_irqrestore(&nc->lock, flags);

  
  	ncsi_stop_channel_monitor(nc);

  	spin_lock_irqsave(&nc->lock, flags);
  	nc->state = NCSI_CHANNEL_INVISIBLE;
  	spin_unlock_irqrestore(&nc->lock, flags);

  	spin_lock_irqsave(&ndp->lock, flags);

  	nc->state = NCSI_CHANNEL_INACTIVE;

  	list_add_tail_rcu(&nc->link, &ndp->channel_queue);
  	spin_unlock_irqrestore(&ndp->lock, flags);
  
  	return ncsi_process_next_channel(ndp);
  }
  
  static int ncsi_aen_handler_hncdsc(struct ncsi_dev_priv *ndp,
  				   struct ncsi_aen_pkt_hdr *h)
  {
  	struct ncsi_channel *nc;
  	struct ncsi_channel_mode *ncm;
  	struct ncsi_aen_hncdsc_pkt *hncdsc;
  	unsigned long flags;
  
  	/* Find the NCSI channel */
  	ncsi_find_package_and_channel(ndp, h->common.channel, NULL, &nc);
  	if (!nc)
  		return -ENODEV;

  	spin_lock_irqsave(&nc->lock, flags);

  	ncm = &nc->modes[NCSI_MODE_LINK];
  	hncdsc = (struct ncsi_aen_hncdsc_pkt *)h;
  	ncm->data[3] = ntohl(hncdsc->status);

  	spin_unlock_irqrestore(&nc->lock, flags);

  	netdev_dbg(ndp->ndev.dev,
  		   "NCSI: host driver %srunning on channel %u
  ",
  		   ncm->data[3] & 0x1 ? "" : "not ", nc->id);

  
  	return 0;
  }
  
  static struct ncsi_aen_handler {
  	unsigned char type;
  	int           payload;
  	int           (*handler)(struct ncsi_dev_priv *ndp,
  				 struct ncsi_aen_pkt_hdr *h);
  } ncsi_aen_handlers[] = {
  	{ NCSI_PKT_AEN_LSC,    12, ncsi_aen_handler_lsc    },
  	{ NCSI_PKT_AEN_CR,      4, ncsi_aen_handler_cr     },

  	{ NCSI_PKT_AEN_HNCDSC,  8, ncsi_aen_handler_hncdsc }

  };
  
  int ncsi_aen_handler(struct ncsi_dev_priv *ndp, struct sk_buff *skb)
  {
  	struct ncsi_aen_pkt_hdr *h;
  	struct ncsi_aen_handler *nah = NULL;
  	int i, ret;
  
  	/* Find the handler */
  	h = (struct ncsi_aen_pkt_hdr *)skb_network_header(skb);
  	for (i = 0; i < ARRAY_SIZE(ncsi_aen_handlers); i++) {
  		if (ncsi_aen_handlers[i].type == h->type) {
  			nah = &ncsi_aen_handlers[i];
  			break;
  		}
  	}
  
  	if (!nah) {
  		netdev_warn(ndp->ndev.dev, "Invalid AEN (0x%x) received
  ",
  			    h->type);
  		return -ENOENT;
  	}
  
  	ret = ncsi_validate_aen_pkt(h, nah->payload);

  	if (ret) {
  		netdev_warn(ndp->ndev.dev,
  			    "NCSI: 'bad' packet ignored for AEN type 0x%x
  ",
  			    h->type);

  		goto out;

  	}

  
  	ret = nah->handler(ndp, h);

  	if (ret)
  		netdev_err(ndp->ndev.dev,
  			   "NCSI: Handler for AEN type 0x%x returned %d
  ",
  			   h->type, ret);

  out:
  	consume_skb(skb);
  	return ret;
  }