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