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_aen_lsc_pkt *lsc; 54 struct ncsi_channel *nc; 55 struct ncsi_channel_mode *ncm; 56 bool chained; 57 int state; 58 unsigned long old_data, data; 59 unsigned long flags; 60 61 /* Find the NCSI channel */ 62 ncsi_find_package_and_channel(ndp, h->common.channel, NULL, &nc); 63 if (!nc) 64 return -ENODEV; 65 66 /* Update the link status */ 67 lsc = (struct ncsi_aen_lsc_pkt *)h; 68 69 spin_lock_irqsave(&nc->lock, flags); 70 ncm = &nc->modes[NCSI_MODE_LINK]; 71 old_data = ncm->data[2]; 72 data = ntohl(lsc->status); 73 ncm->data[2] = data; 74 ncm->data[4] = ntohl(lsc->oem_status); 75 76 chained = !list_empty(&nc->link); 77 state = nc->state; 78 spin_unlock_irqrestore(&nc->lock, flags); 79 80 if (!((old_data ^ data) & 0x1) || chained) 81 return 0; 82 if (!(state == NCSI_CHANNEL_INACTIVE && (data & 0x1)) && 83 !(state == NCSI_CHANNEL_ACTIVE && !(data & 0x1))) 84 return 0; 85 86 if (!(ndp->flags & NCSI_DEV_HWA) && 87 state == NCSI_CHANNEL_ACTIVE) 88 ndp->flags |= NCSI_DEV_RESHUFFLE; 89 90 ncsi_stop_channel_monitor(nc); 91 spin_lock_irqsave(&ndp->lock, flags); 92 list_add_tail_rcu(&nc->link, &ndp->channel_queue); 93 spin_unlock_irqrestore(&ndp->lock, flags); 94 95 return ncsi_process_next_channel(ndp); 96 } 97 98 static int ncsi_aen_handler_cr(struct ncsi_dev_priv *ndp, 99 struct ncsi_aen_pkt_hdr *h) 100 { 101 struct ncsi_channel *nc; 102 unsigned long flags; 103 104 /* Find the NCSI channel */ 105 ncsi_find_package_and_channel(ndp, h->common.channel, NULL, &nc); 106 if (!nc) 107 return -ENODEV; 108 109 spin_lock_irqsave(&nc->lock, flags); 110 if (!list_empty(&nc->link) || 111 nc->state != NCSI_CHANNEL_ACTIVE) { 112 spin_unlock_irqrestore(&nc->lock, flags); 113 return 0; 114 } 115 spin_unlock_irqrestore(&nc->lock, flags); 116 117 ncsi_stop_channel_monitor(nc); 118 spin_lock_irqsave(&nc->lock, flags); 119 nc->state = NCSI_CHANNEL_INVISIBLE; 120 spin_unlock_irqrestore(&nc->lock, flags); 121 122 spin_lock_irqsave(&ndp->lock, flags); 123 nc->state = NCSI_CHANNEL_INACTIVE; 124 list_add_tail_rcu(&nc->link, &ndp->channel_queue); 125 spin_unlock_irqrestore(&ndp->lock, flags); 126 127 return ncsi_process_next_channel(ndp); 128 } 129 130 static int ncsi_aen_handler_hncdsc(struct ncsi_dev_priv *ndp, 131 struct ncsi_aen_pkt_hdr *h) 132 { 133 struct ncsi_channel *nc; 134 struct ncsi_channel_mode *ncm; 135 struct ncsi_aen_hncdsc_pkt *hncdsc; 136 unsigned long flags; 137 138 /* Find the NCSI channel */ 139 ncsi_find_package_and_channel(ndp, h->common.channel, NULL, &nc); 140 if (!nc) 141 return -ENODEV; 142 143 /* If the channel is active one, we need reconfigure it */ 144 ncm = &nc->modes[NCSI_MODE_LINK]; 145 hncdsc = (struct ncsi_aen_hncdsc_pkt *)h; 146 ncm->data[3] = ntohl(hncdsc->status); 147 if (!list_empty(&nc->link) || 148 nc->state != NCSI_CHANNEL_ACTIVE || 149 (ncm->data[3] & 0x1)) 150 return 0; 151 152 if (ndp->flags & NCSI_DEV_HWA) 153 ndp->flags |= NCSI_DEV_RESHUFFLE; 154 155 /* If this channel is the active one and the link doesn't 156 * work, we have to choose another channel to be active one. 157 * The logic here is exactly similar to what we do when link 158 * is down on the active channel. 159 */ 160 ncsi_stop_channel_monitor(nc); 161 spin_lock_irqsave(&ndp->lock, flags); 162 list_add_tail_rcu(&nc->link, &ndp->channel_queue); 163 spin_unlock_irqrestore(&ndp->lock, flags); 164 165 ncsi_process_next_channel(ndp); 166 167 return 0; 168 } 169 170 static struct ncsi_aen_handler { 171 unsigned char type; 172 int payload; 173 int (*handler)(struct ncsi_dev_priv *ndp, 174 struct ncsi_aen_pkt_hdr *h); 175 } ncsi_aen_handlers[] = { 176 { NCSI_PKT_AEN_LSC, 12, ncsi_aen_handler_lsc }, 177 { NCSI_PKT_AEN_CR, 4, ncsi_aen_handler_cr }, 178 { NCSI_PKT_AEN_HNCDSC, 4, ncsi_aen_handler_hncdsc } 179 }; 180 181 int ncsi_aen_handler(struct ncsi_dev_priv *ndp, struct sk_buff *skb) 182 { 183 struct ncsi_aen_pkt_hdr *h; 184 struct ncsi_aen_handler *nah = NULL; 185 int i, ret; 186 187 /* Find the handler */ 188 h = (struct ncsi_aen_pkt_hdr *)skb_network_header(skb); 189 for (i = 0; i < ARRAY_SIZE(ncsi_aen_handlers); i++) { 190 if (ncsi_aen_handlers[i].type == h->type) { 191 nah = &ncsi_aen_handlers[i]; 192 break; 193 } 194 } 195 196 if (!nah) { 197 netdev_warn(ndp->ndev.dev, "Invalid AEN (0x%x) received\n", 198 h->type); 199 return -ENOENT; 200 } 201 202 ret = ncsi_validate_aen_pkt(h, nah->payload); 203 if (ret) 204 goto out; 205 206 ret = nah->handler(ndp, h); 207 out: 208 consume_skb(skb); 209 return ret; 210 } 211