net/ncsi/ncsi-aen.c

   1 /*
   2  * Copyright Gavin Shan, IBM Corporation 2016.
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  */
   9
  10 #include <linux/module.h>
  11 #include <linux/kernel.h>
  12 #include <linux/init.h>
  13 #include <linux/netdevice.h>
  14 #include <linux/skbuff.h>
  15
  16 #include <net/ncsi.h>
  17 #include <net/net_namespace.h>
  18 #include <net/sock.h>
  19
  20 #include "internal.h"
  21 #include "ncsi-pkt.h"
  22
  23 static int ncsi_validate_aen_pkt(struct ncsi_aen_pkt_hdr *h,
  24                                  const unsigned short payload)
  25 {
  26         u32 checksum;
  27         __be32 *pchecksum;
  28
  29         if (h->common.revision != NCSI_PKT_REVISION)
  30                 return -EINVAL;
  31         if (ntohs(h->common.length) != payload)
  32                 return -EINVAL;
  33
  34         /* Validate checksum, which might be zeroes if the
  35          * sender doesn't support checksum according to NCSI
  36          * specification.
  37          */
  38         pchecksum = (__be32 *)((void *)(h + 1) + payload - 4);
  39         if (ntohl(*pchecksum) == 0)
  40                 return 0;
  41
  42         checksum = ncsi_calculate_checksum((unsigned char *)h,
  43                                            sizeof(*h) + payload - 4);
  44         if (*pchecksum != htonl(checksum))
  45                 return -EINVAL;
  46
  47         return 0;
  48 }
  49
  50 static int ncsi_aen_handler_lsc(struct ncsi_dev_priv *ndp,
  51                                 struct ncsi_aen_pkt_hdr *h)
  52 {
  53         struct ncsi_channel *nc, *tmp;
  54         struct ncsi_channel_mode *ncm;
  55         unsigned long old_data, data;
  56         struct ncsi_aen_lsc_pkt *lsc;
  57         struct ncsi_package *np;
  58         bool had_link, has_link;
  59         unsigned long flags;
  60         bool chained;
  61         int state;
  62
  63         /* Find the NCSI channel */
  64         ncsi_find_package_and_channel(ndp, h->common.channel, NULL, &nc);
  65         if (!nc)
  66                 return -ENODEV;
  67
  68         /* Update the link status */
  69         lsc = (struct ncsi_aen_lsc_pkt *)h;
  70
  71         spin_lock_irqsave(&nc->lock, flags);
  72         ncm = &nc->modes[NCSI_MODE_LINK];
  73         old_data = ncm->data[2];
  74         data = ntohl(lsc->status);
  75         ncm->data[2] = data;
  76         ncm->data[4] = ntohl(lsc->oem_status);
  77
  78         had_link = !!(old_data & 0x1);
  79         has_link = !!(data & 0x1);
  80
  81         netdev_dbg(ndp->ndev.dev, "NCSI: LSC AEN - channel %u state %s\n",
  82                    nc->id, data & 0x1 ? "up" : "down");
  83
  84         chained = !list_empty(&nc->link);
  85         state = nc->state;
  86         spin_unlock_irqrestore(&nc->lock, flags);
  87
  88         if (state == NCSI_CHANNEL_INACTIVE)
  89                 netdev_warn(ndp->ndev.dev,
  90                             "NCSI: Inactive channel %u received AEN!\n",
  91                             nc->id);
  92
  93         if ((had_link == has_link) || chained)
  94                 return 0;
  95
  96         if (!ndp->multi_package && !nc->package->multi_channel) {
  97                 if (had_link) {
  98                         ndp->flags |= NCSI_DEV_RESHUFFLE;
  99                         ncsi_stop_channel_monitor(nc);
 100                         spin_lock_irqsave(&ndp->lock, flags);
 101                         list_add_tail_rcu(&nc->link, &ndp->channel_queue);
 102                         spin_unlock_irqrestore(&ndp->lock, flags);
 103                         return ncsi_process_next_channel(ndp);
 104                 }
 105                 /* Configured channel came up */
 106                 return 0;
 107         }
 108
 109         if (had_link) {
 110                 ncm = &nc->modes[NCSI_MODE_TX_ENABLE];
 111                 if (ncsi_channel_is_last(ndp, nc)) {
 112                         /* No channels left, reconfigure */
 113                         return ncsi_reset_dev(&ndp->ndev);
 114                 } else if (ncm->enable) {
 115                         /* Need to failover Tx channel */
 116                         ncsi_update_tx_channel(ndp, nc->package, nc, NULL);
 117                 }
 118         } else if (has_link && nc->package->preferred_channel == nc) {
 119                 /* Return Tx to preferred channel */
 120                 ncsi_update_tx_channel(ndp, nc->package, NULL, nc);
 121         } else if (has_link) {
 122                 NCSI_FOR_EACH_PACKAGE(ndp, np) {
 123                         NCSI_FOR_EACH_CHANNEL(np, tmp) {
 124                                 /* Enable Tx on this channel if the current Tx
 125                                  * channel is down.
 126                                  */
 127                                 ncm = &tmp->modes[NCSI_MODE_TX_ENABLE];
 128                                 if (ncm->enable &&
 129                                     !ncsi_channel_has_link(tmp)) {
 130                                         ncsi_update_tx_channel(ndp, nc->package,
 131                                                                tmp, nc);
 132                                         break;
 133                                 }
 134                         }
 135                 }
 136         }
 137
 138         /* Leave configured channels active in a multi-channel scenario so
 139          * AEN events are still received.
 140          */
 141         return 0;
 142 }
 143
 144 static int ncsi_aen_handler_cr(struct ncsi_dev_priv *ndp,
 145                                struct ncsi_aen_pkt_hdr *h)
 146 {
 147         struct ncsi_channel *nc;
 148         unsigned long flags;
 149
 150         /* Find the NCSI channel */
 151         ncsi_find_package_and_channel(ndp, h->common.channel, NULL, &nc);
 152         if (!nc)
 153                 return -ENODEV;
 154
 155         spin_lock_irqsave(&nc->lock, flags);
 156         if (!list_empty(&nc->link) ||
 157             nc->state != NCSI_CHANNEL_ACTIVE) {
 158                 spin_unlock_irqrestore(&nc->lock, flags);
 159                 return 0;
 160         }
 161         spin_unlock_irqrestore(&nc->lock, flags);
 162
 163         ncsi_stop_channel_monitor(nc);
 164         spin_lock_irqsave(&nc->lock, flags);
 165         nc->state = NCSI_CHANNEL_INVISIBLE;
 166         spin_unlock_irqrestore(&nc->lock, flags);
 167
 168         spin_lock_irqsave(&ndp->lock, flags);
 169         nc->state = NCSI_CHANNEL_INACTIVE;
 170         list_add_tail_rcu(&nc->link, &ndp->channel_queue);
 171         spin_unlock_irqrestore(&ndp->lock, flags);
 172
 173         return ncsi_process_next_channel(ndp);
 174 }
 175
 176 static int ncsi_aen_handler_hncdsc(struct ncsi_dev_priv *ndp,
 177                                    struct ncsi_aen_pkt_hdr *h)
 178 {
 179         struct ncsi_channel *nc;
 180         struct ncsi_channel_mode *ncm;
 181         struct ncsi_aen_hncdsc_pkt *hncdsc;
 182         unsigned long flags;
 183
 184         /* Find the NCSI channel */
 185         ncsi_find_package_and_channel(ndp, h->common.channel, NULL, &nc);
 186         if (!nc)
 187                 return -ENODEV;
 188
 189         spin_lock_irqsave(&nc->lock, flags);
 190         ncm = &nc->modes[NCSI_MODE_LINK];
 191         hncdsc = (struct ncsi_aen_hncdsc_pkt *)h;
 192         ncm->data[3] = ntohl(hncdsc->status);
 193         spin_unlock_irqrestore(&nc->lock, flags);
 194         netdev_dbg(ndp->ndev.dev,
 195                    "NCSI: host driver %srunning on channel %u\n",
 196                    ncm->data[3] & 0x1 ? "" : "not ", nc->id);
 197
 198         return 0;
 199 }
 200
 201 static struct ncsi_aen_handler {
 202         unsigned char type;
 203         int           payload;
 204         int           (*handler)(struct ncsi_dev_priv *ndp,
 205                                  struct ncsi_aen_pkt_hdr *h);
 206 } ncsi_aen_handlers[] = {
 207         { NCSI_PKT_AEN_LSC,    12, ncsi_aen_handler_lsc    },
 208         { NCSI_PKT_AEN_CR,      4, ncsi_aen_handler_cr     },
 209         { NCSI_PKT_AEN_HNCDSC,  8, ncsi_aen_handler_hncdsc }
 210 };
 211
 212 int ncsi_aen_handler(struct ncsi_dev_priv *ndp, struct sk_buff *skb)
 213 {
 214         struct ncsi_aen_pkt_hdr *h;
 215         struct ncsi_aen_handler *nah = NULL;
 216         int i, ret;
 217
 218         /* Find the handler */
 219         h = (struct ncsi_aen_pkt_hdr *)skb_network_header(skb);
 220         for (i = 0; i < ARRAY_SIZE(ncsi_aen_handlers); i++) {
 221                 if (ncsi_aen_handlers[i].type == h->type) {
 222                         nah = &ncsi_aen_handlers[i];
 223                         break;
 224                 }
 225         }
 226
 227         if (!nah) {
 228                 netdev_warn(ndp->ndev.dev, "Invalid AEN (0x%x) received\n",
 229                             h->type);
 230                 return -ENOENT;
 231         }
 232
 233         ret = ncsi_validate_aen_pkt(h, nah->payload);
 234         if (ret) {
 235                 netdev_warn(ndp->ndev.dev,
 236                             "NCSI: 'bad' packet ignored for AEN type 0x%x\n",
 237                             h->type);
 238                 goto out;
 239         }
 240
 241         ret = nah->handler(ndp, h);
 242         if (ret)
 243                 netdev_err(ndp->ndev.dev,
 244                            "NCSI: Handler for AEN type 0x%x returned %d\n",
 245                            h->type, ret);
 246 out:
 247         consume_skb(skb);
 248         return ret;
 249 }