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/etherdevice.h>
11#include <linux/skbuff.h>
12
13#include <net/ncsi.h>
14#include <net/net_namespace.h>
15#include <net/sock.h>
16#include <net/genetlink.h>
17
18#include "internal.h"
19#include "ncsi-pkt.h"
20#include "ncsi-netlink.h"
21
22/* Nibbles within [0xA, 0xF] add zero "0" to the returned value.
23 * Optional fields (encoded as 0xFF) will default to zero.
24 */
25static u8 decode_bcd_u8(u8 x)
26{
27 int lo = x & 0xF;
28 int hi = x >> 4;
29
30 lo = lo < 0xA ? lo : 0;
31 hi = hi < 0xA ? hi : 0;
32 return lo + hi * 10;
33}
34
35static int ncsi_validate_rsp_pkt(struct ncsi_request *nr,
36 unsigned short payload)
37{
38 struct ncsi_rsp_pkt_hdr *h;
39 u32 checksum;
40 __be32 *pchecksum;
41
42 /* Check NCSI packet header. We don't need validate
43 * the packet type, which should have been checked
44 * before calling this function.
45 */
46 h = (struct ncsi_rsp_pkt_hdr *)skb_network_header(skb: nr->rsp);
47
48 if (h->common.revision != NCSI_PKT_REVISION) {
49 netdev_dbg(nr->ndp->ndev.dev,
50 "NCSI: unsupported header revision\n");
51 return -EINVAL;
52 }
53 if (ntohs(h->common.length) != payload) {
54 netdev_dbg(nr->ndp->ndev.dev,
55 "NCSI: payload length mismatched\n");
56 return -EINVAL;
57 }
58
59 /* Check on code and reason */
60 if (ntohs(h->code) != NCSI_PKT_RSP_C_COMPLETED ||
61 ntohs(h->reason) != NCSI_PKT_RSP_R_NO_ERROR) {
62 netdev_dbg(nr->ndp->ndev.dev,
63 "NCSI: non zero response/reason code %04xh, %04xh\n",
64 ntohs(h->code), ntohs(h->reason));
65 return -EPERM;
66 }
67
68 /* Validate checksum, which might be zeroes if the
69 * sender doesn't support checksum according to NCSI
70 * specification.
71 */
72 pchecksum = (__be32 *)((void *)(h + 1) + ALIGN(payload, 4) - 4);
73 if (ntohl(*pchecksum) == 0)
74 return 0;
75
76 checksum = ncsi_calculate_checksum(data: (unsigned char *)h,
77 len: sizeof(*h) + payload - 4);
78
79 if (*pchecksum != htonl(checksum)) {
80 netdev_dbg(nr->ndp->ndev.dev,
81 "NCSI: checksum mismatched; recd: %08x calc: %08x\n",
82 *pchecksum, htonl(checksum));
83 return -EINVAL;
84 }
85
86 return 0;
87}
88
89static int ncsi_rsp_handler_cis(struct ncsi_request *nr)
90{
91 struct ncsi_rsp_pkt *rsp;
92 struct ncsi_dev_priv *ndp = nr->ndp;
93 struct ncsi_package *np;
94 struct ncsi_channel *nc;
95 unsigned char id;
96
97 rsp = (struct ncsi_rsp_pkt *)skb_network_header(skb: nr->rsp);
98 ncsi_find_package_and_channel(ndp, id: rsp->rsp.common.channel, np: &np, nc: &nc);
99 if (!nc) {
100 if (ndp->flags & NCSI_DEV_PROBED)
101 return -ENXIO;
102
103 id = NCSI_CHANNEL_INDEX(rsp->rsp.common.channel);
104 nc = ncsi_add_channel(np, id);
105 }
106
107 return nc ? 0 : -ENODEV;
108}
109
110static int ncsi_rsp_handler_sp(struct ncsi_request *nr)
111{
112 struct ncsi_rsp_pkt *rsp;
113 struct ncsi_dev_priv *ndp = nr->ndp;
114 struct ncsi_package *np;
115 unsigned char id;
116
117 /* Add the package if it's not existing. Otherwise,
118 * to change the state of its child channels.
119 */
120 rsp = (struct ncsi_rsp_pkt *)skb_network_header(skb: nr->rsp);
121 ncsi_find_package_and_channel(ndp, id: rsp->rsp.common.channel,
122 np: &np, NULL);
123 if (!np) {
124 if (ndp->flags & NCSI_DEV_PROBED)
125 return -ENXIO;
126
127 id = NCSI_PACKAGE_INDEX(rsp->rsp.common.channel);
128 np = ncsi_add_package(ndp, id);
129 if (!np)
130 return -ENODEV;
131 }
132
133 return 0;
134}
135
136static int ncsi_rsp_handler_dp(struct ncsi_request *nr)
137{
138 struct ncsi_rsp_pkt *rsp;
139 struct ncsi_dev_priv *ndp = nr->ndp;
140 struct ncsi_package *np;
141 struct ncsi_channel *nc;
142 unsigned long flags;
143
144 /* Find the package */
145 rsp = (struct ncsi_rsp_pkt *)skb_network_header(skb: nr->rsp);
146 ncsi_find_package_and_channel(ndp, id: rsp->rsp.common.channel,
147 np: &np, NULL);
148 if (!np)
149 return -ENODEV;
150
151 /* Change state of all channels attached to the package */
152 NCSI_FOR_EACH_CHANNEL(np, nc) {
153 spin_lock_irqsave(&nc->lock, flags);
154 nc->state = NCSI_CHANNEL_INACTIVE;
155 spin_unlock_irqrestore(lock: &nc->lock, flags);
156 }
157
158 return 0;
159}
160
161static int ncsi_rsp_handler_ec(struct ncsi_request *nr)
162{
163 struct ncsi_rsp_pkt *rsp;
164 struct ncsi_dev_priv *ndp = nr->ndp;
165 struct ncsi_channel *nc;
166 struct ncsi_channel_mode *ncm;
167
168 /* Find the package and channel */
169 rsp = (struct ncsi_rsp_pkt *)skb_network_header(skb: nr->rsp);
170 ncsi_find_package_and_channel(ndp, id: rsp->rsp.common.channel,
171 NULL, nc: &nc);
172 if (!nc)
173 return -ENODEV;
174
175 ncm = &nc->modes[NCSI_MODE_ENABLE];
176 if (ncm->enable)
177 return 0;
178
179 ncm->enable = 1;
180 return 0;
181}
182
183static int ncsi_rsp_handler_dc(struct ncsi_request *nr)
184{
185 struct ncsi_rsp_pkt *rsp;
186 struct ncsi_dev_priv *ndp = nr->ndp;
187 struct ncsi_channel *nc;
188 struct ncsi_channel_mode *ncm;
189 int ret;
190
191 ret = ncsi_validate_rsp_pkt(nr, payload: 4);
192 if (ret)
193 return ret;
194
195 /* Find the package and channel */
196 rsp = (struct ncsi_rsp_pkt *)skb_network_header(skb: nr->rsp);
197 ncsi_find_package_and_channel(ndp, id: rsp->rsp.common.channel,
198 NULL, nc: &nc);
199 if (!nc)
200 return -ENODEV;
201
202 ncm = &nc->modes[NCSI_MODE_ENABLE];
203 if (!ncm->enable)
204 return 0;
205
206 ncm->enable = 0;
207 return 0;
208}
209
210static int ncsi_rsp_handler_rc(struct ncsi_request *nr)
211{
212 struct ncsi_rsp_pkt *rsp;
213 struct ncsi_dev_priv *ndp = nr->ndp;
214 struct ncsi_channel *nc;
215 unsigned long flags;
216
217 /* Find the package and channel */
218 rsp = (struct ncsi_rsp_pkt *)skb_network_header(skb: nr->rsp);
219 ncsi_find_package_and_channel(ndp, id: rsp->rsp.common.channel,
220 NULL, nc: &nc);
221 if (!nc)
222 return -ENODEV;
223
224 /* Update state for the specified channel */
225 spin_lock_irqsave(&nc->lock, flags);
226 nc->state = NCSI_CHANNEL_INACTIVE;
227 spin_unlock_irqrestore(lock: &nc->lock, flags);
228
229 return 0;
230}
231
232static int ncsi_rsp_handler_ecnt(struct ncsi_request *nr)
233{
234 struct ncsi_rsp_pkt *rsp;
235 struct ncsi_dev_priv *ndp = nr->ndp;
236 struct ncsi_channel *nc;
237 struct ncsi_channel_mode *ncm;
238
239 /* Find the package and channel */
240 rsp = (struct ncsi_rsp_pkt *)skb_network_header(skb: nr->rsp);
241 ncsi_find_package_and_channel(ndp, id: rsp->rsp.common.channel,
242 NULL, nc: &nc);
243 if (!nc)
244 return -ENODEV;
245
246 ncm = &nc->modes[NCSI_MODE_TX_ENABLE];
247 if (ncm->enable)
248 return 0;
249
250 ncm->enable = 1;
251 return 0;
252}
253
254static int ncsi_rsp_handler_dcnt(struct ncsi_request *nr)
255{
256 struct ncsi_rsp_pkt *rsp;
257 struct ncsi_dev_priv *ndp = nr->ndp;
258 struct ncsi_channel *nc;
259 struct ncsi_channel_mode *ncm;
260
261 /* Find the package and channel */
262 rsp = (struct ncsi_rsp_pkt *)skb_network_header(skb: nr->rsp);
263 ncsi_find_package_and_channel(ndp, id: rsp->rsp.common.channel,
264 NULL, nc: &nc);
265 if (!nc)
266 return -ENODEV;
267
268 ncm = &nc->modes[NCSI_MODE_TX_ENABLE];
269 if (!ncm->enable)
270 return 0;
271
272 ncm->enable = 0;
273 return 0;
274}
275
276static int ncsi_rsp_handler_ae(struct ncsi_request *nr)
277{
278 struct ncsi_cmd_ae_pkt *cmd;
279 struct ncsi_rsp_pkt *rsp;
280 struct ncsi_dev_priv *ndp = nr->ndp;
281 struct ncsi_channel *nc;
282 struct ncsi_channel_mode *ncm;
283
284 /* Find the package and channel */
285 rsp = (struct ncsi_rsp_pkt *)skb_network_header(skb: nr->rsp);
286 ncsi_find_package_and_channel(ndp, id: rsp->rsp.common.channel,
287 NULL, nc: &nc);
288 if (!nc)
289 return -ENODEV;
290
291 /* Check if the AEN has been enabled */
292 ncm = &nc->modes[NCSI_MODE_AEN];
293 if (ncm->enable)
294 return 0;
295
296 /* Update to AEN configuration */
297 cmd = (struct ncsi_cmd_ae_pkt *)skb_network_header(skb: nr->cmd);
298 ncm->enable = 1;
299 ncm->data[0] = cmd->mc_id;
300 ncm->data[1] = ntohl(cmd->mode);
301
302 return 0;
303}
304
305static int ncsi_rsp_handler_sl(struct ncsi_request *nr)
306{
307 struct ncsi_cmd_sl_pkt *cmd;
308 struct ncsi_rsp_pkt *rsp;
309 struct ncsi_dev_priv *ndp = nr->ndp;
310 struct ncsi_channel *nc;
311 struct ncsi_channel_mode *ncm;
312
313 /* Find the package and channel */
314 rsp = (struct ncsi_rsp_pkt *)skb_network_header(skb: nr->rsp);
315 ncsi_find_package_and_channel(ndp, id: rsp->rsp.common.channel,
316 NULL, nc: &nc);
317 if (!nc)
318 return -ENODEV;
319
320 cmd = (struct ncsi_cmd_sl_pkt *)skb_network_header(skb: nr->cmd);
321 ncm = &nc->modes[NCSI_MODE_LINK];
322 ncm->data[0] = ntohl(cmd->mode);
323 ncm->data[1] = ntohl(cmd->oem_mode);
324
325 return 0;
326}
327
328static int ncsi_rsp_handler_gls(struct ncsi_request *nr)
329{
330 struct ncsi_rsp_gls_pkt *rsp;
331 struct ncsi_dev_priv *ndp = nr->ndp;
332 struct ncsi_channel *nc;
333 struct ncsi_channel_mode *ncm;
334 unsigned long flags;
335
336 /* Find the package and channel */
337 rsp = (struct ncsi_rsp_gls_pkt *)skb_network_header(skb: nr->rsp);
338 ncsi_find_package_and_channel(ndp, id: rsp->rsp.common.channel,
339 NULL, nc: &nc);
340 if (!nc)
341 return -ENODEV;
342
343 ncm = &nc->modes[NCSI_MODE_LINK];
344 ncm->data[2] = ntohl(rsp->status);
345 ncm->data[3] = ntohl(rsp->other);
346 ncm->data[4] = ntohl(rsp->oem_status);
347
348 if (nr->flags & NCSI_REQ_FLAG_EVENT_DRIVEN)
349 return 0;
350
351 /* Reset the channel monitor if it has been enabled */
352 spin_lock_irqsave(&nc->lock, flags);
353 nc->monitor.state = NCSI_CHANNEL_MONITOR_START;
354 spin_unlock_irqrestore(lock: &nc->lock, flags);
355
356 return 0;
357}
358
359static int ncsi_rsp_handler_svf(struct ncsi_request *nr)
360{
361 struct ncsi_cmd_svf_pkt *cmd;
362 struct ncsi_rsp_pkt *rsp;
363 struct ncsi_dev_priv *ndp = nr->ndp;
364 struct ncsi_channel *nc;
365 struct ncsi_channel_vlan_filter *ncf;
366 unsigned long flags;
367 void *bitmap;
368
369 /* Find the package and channel */
370 rsp = (struct ncsi_rsp_pkt *)skb_network_header(skb: nr->rsp);
371 ncsi_find_package_and_channel(ndp, id: rsp->rsp.common.channel,
372 NULL, nc: &nc);
373 if (!nc)
374 return -ENODEV;
375
376 cmd = (struct ncsi_cmd_svf_pkt *)skb_network_header(skb: nr->cmd);
377 ncf = &nc->vlan_filter;
378 if (cmd->index == 0 || cmd->index > ncf->n_vids)
379 return -ERANGE;
380
381 /* Add or remove the VLAN filter. Remember HW indexes from 1 */
382 spin_lock_irqsave(&nc->lock, flags);
383 bitmap = &ncf->bitmap;
384 if (!(cmd->enable & 0x1)) {
385 if (test_and_clear_bit(nr: cmd->index - 1, addr: bitmap))
386 ncf->vids[cmd->index - 1] = 0;
387 } else {
388 set_bit(nr: cmd->index - 1, addr: bitmap);
389 ncf->vids[cmd->index - 1] = ntohs(cmd->vlan);
390 }
391 spin_unlock_irqrestore(lock: &nc->lock, flags);
392
393 return 0;
394}
395
396static int ncsi_rsp_handler_ev(struct ncsi_request *nr)
397{
398 struct ncsi_cmd_ev_pkt *cmd;
399 struct ncsi_rsp_pkt *rsp;
400 struct ncsi_dev_priv *ndp = nr->ndp;
401 struct ncsi_channel *nc;
402 struct ncsi_channel_mode *ncm;
403
404 /* Find the package and channel */
405 rsp = (struct ncsi_rsp_pkt *)skb_network_header(skb: nr->rsp);
406 ncsi_find_package_and_channel(ndp, id: rsp->rsp.common.channel,
407 NULL, nc: &nc);
408 if (!nc)
409 return -ENODEV;
410
411 /* Check if VLAN mode has been enabled */
412 ncm = &nc->modes[NCSI_MODE_VLAN];
413 if (ncm->enable)
414 return 0;
415
416 /* Update to VLAN mode */
417 cmd = (struct ncsi_cmd_ev_pkt *)skb_network_header(skb: nr->cmd);
418 ncm->enable = 1;
419 ncm->data[0] = ntohl((__force __be32)cmd->mode);
420
421 return 0;
422}
423
424static int ncsi_rsp_handler_dv(struct ncsi_request *nr)
425{
426 struct ncsi_rsp_pkt *rsp;
427 struct ncsi_dev_priv *ndp = nr->ndp;
428 struct ncsi_channel *nc;
429 struct ncsi_channel_mode *ncm;
430
431 /* Find the package and channel */
432 rsp = (struct ncsi_rsp_pkt *)skb_network_header(skb: nr->rsp);
433 ncsi_find_package_and_channel(ndp, id: rsp->rsp.common.channel,
434 NULL, nc: &nc);
435 if (!nc)
436 return -ENODEV;
437
438 /* Check if VLAN mode has been enabled */
439 ncm = &nc->modes[NCSI_MODE_VLAN];
440 if (!ncm->enable)
441 return 0;
442
443 /* Update to VLAN mode */
444 ncm->enable = 0;
445 return 0;
446}
447
448static int ncsi_rsp_handler_sma(struct ncsi_request *nr)
449{
450 struct ncsi_cmd_sma_pkt *cmd;
451 struct ncsi_rsp_pkt *rsp;
452 struct ncsi_dev_priv *ndp = nr->ndp;
453 struct ncsi_channel *nc;
454 struct ncsi_channel_mac_filter *ncf;
455 unsigned long flags;
456 void *bitmap;
457 bool enabled;
458 int index;
459
460
461 /* Find the package and channel */
462 rsp = (struct ncsi_rsp_pkt *)skb_network_header(skb: nr->rsp);
463 ncsi_find_package_and_channel(ndp, id: rsp->rsp.common.channel,
464 NULL, nc: &nc);
465 if (!nc)
466 return -ENODEV;
467
468 /* According to NCSI spec 1.01, the mixed filter table
469 * isn't supported yet.
470 */
471 cmd = (struct ncsi_cmd_sma_pkt *)skb_network_header(skb: nr->cmd);
472 enabled = cmd->at_e & 0x1;
473 ncf = &nc->mac_filter;
474 bitmap = &ncf->bitmap;
475
476 if (cmd->index == 0 ||
477 cmd->index > ncf->n_uc + ncf->n_mc + ncf->n_mixed)
478 return -ERANGE;
479
480 index = (cmd->index - 1) * ETH_ALEN;
481 spin_lock_irqsave(&nc->lock, flags);
482 if (enabled) {
483 set_bit(nr: cmd->index - 1, addr: bitmap);
484 memcpy(&ncf->addrs[index], cmd->mac, ETH_ALEN);
485 } else {
486 clear_bit(nr: cmd->index - 1, addr: bitmap);
487 eth_zero_addr(addr: &ncf->addrs[index]);
488 }
489 spin_unlock_irqrestore(lock: &nc->lock, flags);
490
491 return 0;
492}
493
494static int ncsi_rsp_handler_ebf(struct ncsi_request *nr)
495{
496 struct ncsi_cmd_ebf_pkt *cmd;
497 struct ncsi_rsp_pkt *rsp;
498 struct ncsi_dev_priv *ndp = nr->ndp;
499 struct ncsi_channel *nc;
500 struct ncsi_channel_mode *ncm;
501
502 /* Find the package and channel */
503 rsp = (struct ncsi_rsp_pkt *)skb_network_header(skb: nr->rsp);
504 ncsi_find_package_and_channel(ndp, id: rsp->rsp.common.channel, NULL, nc: &nc);
505 if (!nc)
506 return -ENODEV;
507
508 /* Check if broadcast filter has been enabled */
509 ncm = &nc->modes[NCSI_MODE_BC];
510 if (ncm->enable)
511 return 0;
512
513 /* Update to broadcast filter mode */
514 cmd = (struct ncsi_cmd_ebf_pkt *)skb_network_header(skb: nr->cmd);
515 ncm->enable = 1;
516 ncm->data[0] = ntohl(cmd->mode);
517
518 return 0;
519}
520
521static int ncsi_rsp_handler_dbf(struct ncsi_request *nr)
522{
523 struct ncsi_rsp_pkt *rsp;
524 struct ncsi_dev_priv *ndp = nr->ndp;
525 struct ncsi_channel *nc;
526 struct ncsi_channel_mode *ncm;
527
528 rsp = (struct ncsi_rsp_pkt *)skb_network_header(skb: nr->rsp);
529 ncsi_find_package_and_channel(ndp, id: rsp->rsp.common.channel,
530 NULL, nc: &nc);
531 if (!nc)
532 return -ENODEV;
533
534 /* Check if broadcast filter isn't enabled */
535 ncm = &nc->modes[NCSI_MODE_BC];
536 if (!ncm->enable)
537 return 0;
538
539 /* Update to broadcast filter mode */
540 ncm->enable = 0;
541 ncm->data[0] = 0;
542
543 return 0;
544}
545
546static int ncsi_rsp_handler_egmf(struct ncsi_request *nr)
547{
548 struct ncsi_cmd_egmf_pkt *cmd;
549 struct ncsi_rsp_pkt *rsp;
550 struct ncsi_dev_priv *ndp = nr->ndp;
551 struct ncsi_channel *nc;
552 struct ncsi_channel_mode *ncm;
553
554 /* Find the channel */
555 rsp = (struct ncsi_rsp_pkt *)skb_network_header(skb: nr->rsp);
556 ncsi_find_package_and_channel(ndp, id: rsp->rsp.common.channel,
557 NULL, nc: &nc);
558 if (!nc)
559 return -ENODEV;
560
561 /* Check if multicast filter has been enabled */
562 ncm = &nc->modes[NCSI_MODE_MC];
563 if (ncm->enable)
564 return 0;
565
566 /* Update to multicast filter mode */
567 cmd = (struct ncsi_cmd_egmf_pkt *)skb_network_header(skb: nr->cmd);
568 ncm->enable = 1;
569 ncm->data[0] = ntohl(cmd->mode);
570
571 return 0;
572}
573
574static int ncsi_rsp_handler_dgmf(struct ncsi_request *nr)
575{
576 struct ncsi_rsp_pkt *rsp;
577 struct ncsi_dev_priv *ndp = nr->ndp;
578 struct ncsi_channel *nc;
579 struct ncsi_channel_mode *ncm;
580
581 rsp = (struct ncsi_rsp_pkt *)skb_network_header(skb: nr->rsp);
582 ncsi_find_package_and_channel(ndp, id: rsp->rsp.common.channel,
583 NULL, nc: &nc);
584 if (!nc)
585 return -ENODEV;
586
587 /* Check if multicast filter has been enabled */
588 ncm = &nc->modes[NCSI_MODE_MC];
589 if (!ncm->enable)
590 return 0;
591
592 /* Update to multicast filter mode */
593 ncm->enable = 0;
594 ncm->data[0] = 0;
595
596 return 0;
597}
598
599static int ncsi_rsp_handler_snfc(struct ncsi_request *nr)
600{
601 struct ncsi_cmd_snfc_pkt *cmd;
602 struct ncsi_rsp_pkt *rsp;
603 struct ncsi_dev_priv *ndp = nr->ndp;
604 struct ncsi_channel *nc;
605 struct ncsi_channel_mode *ncm;
606
607 /* Find the channel */
608 rsp = (struct ncsi_rsp_pkt *)skb_network_header(skb: nr->rsp);
609 ncsi_find_package_and_channel(ndp, id: rsp->rsp.common.channel,
610 NULL, nc: &nc);
611 if (!nc)
612 return -ENODEV;
613
614 /* Check if flow control has been enabled */
615 ncm = &nc->modes[NCSI_MODE_FC];
616 if (ncm->enable)
617 return 0;
618
619 /* Update to flow control mode */
620 cmd = (struct ncsi_cmd_snfc_pkt *)skb_network_header(skb: nr->cmd);
621 ncm->enable = 1;
622 ncm->data[0] = cmd->mode;
623
624 return 0;
625}
626
627/* Response handler for Get Mac Address command */
628static int ncsi_rsp_handler_oem_gma(struct ncsi_request *nr, int mfr_id)
629{
630 struct ncsi_dev_priv *ndp = nr->ndp;
631 struct net_device *ndev = ndp->ndev.dev;
632 struct ncsi_rsp_oem_pkt *rsp;
633 struct sockaddr saddr;
634 u32 mac_addr_off = 0;
635 int ret = 0;
636
637 /* Get the response header */
638 rsp = (struct ncsi_rsp_oem_pkt *)skb_network_header(skb: nr->rsp);
639
640 saddr.sa_family = ndev->type;
641 ndev->priv_flags |= IFF_LIVE_ADDR_CHANGE;
642 if (mfr_id == NCSI_OEM_MFR_BCM_ID)
643 mac_addr_off = BCM_MAC_ADDR_OFFSET;
644 else if (mfr_id == NCSI_OEM_MFR_MLX_ID)
645 mac_addr_off = MLX_MAC_ADDR_OFFSET;
646 else if (mfr_id == NCSI_OEM_MFR_INTEL_ID)
647 mac_addr_off = INTEL_MAC_ADDR_OFFSET;
648
649 memcpy(saddr.sa_data, &rsp->data[mac_addr_off], ETH_ALEN);
650 if (mfr_id == NCSI_OEM_MFR_BCM_ID || mfr_id == NCSI_OEM_MFR_INTEL_ID)
651 eth_addr_inc(addr: (u8 *)saddr.sa_data);
652 if (!is_valid_ether_addr(addr: (const u8 *)saddr.sa_data))
653 return -ENXIO;
654
655 /* Set the flag for GMA command which should only be called once */
656 ndp->gma_flag = 1;
657
658 rtnl_lock();
659 ret = dev_set_mac_address(dev: ndev, sa: &saddr, NULL);
660 rtnl_unlock();
661 if (ret < 0)
662 netdev_warn(dev: ndev, format: "NCSI: 'Writing mac address to device failed\n");
663
664 return ret;
665}
666
667/* Response handler for Mellanox card */
668static int ncsi_rsp_handler_oem_mlx(struct ncsi_request *nr)
669{
670 struct ncsi_rsp_oem_mlx_pkt *mlx;
671 struct ncsi_rsp_oem_pkt *rsp;
672
673 /* Get the response header */
674 rsp = (struct ncsi_rsp_oem_pkt *)skb_network_header(skb: nr->rsp);
675 mlx = (struct ncsi_rsp_oem_mlx_pkt *)(rsp->data);
676
677 if (mlx->cmd == NCSI_OEM_MLX_CMD_GMA &&
678 mlx->param == NCSI_OEM_MLX_CMD_GMA_PARAM)
679 return ncsi_rsp_handler_oem_gma(nr, NCSI_OEM_MFR_MLX_ID);
680 return 0;
681}
682
683/* Response handler for Broadcom card */
684static int ncsi_rsp_handler_oem_bcm(struct ncsi_request *nr)
685{
686 struct ncsi_rsp_oem_bcm_pkt *bcm;
687 struct ncsi_rsp_oem_pkt *rsp;
688
689 /* Get the response header */
690 rsp = (struct ncsi_rsp_oem_pkt *)skb_network_header(skb: nr->rsp);
691 bcm = (struct ncsi_rsp_oem_bcm_pkt *)(rsp->data);
692
693 if (bcm->type == NCSI_OEM_BCM_CMD_GMA)
694 return ncsi_rsp_handler_oem_gma(nr, NCSI_OEM_MFR_BCM_ID);
695 return 0;
696}
697
698/* Response handler for Intel card */
699static int ncsi_rsp_handler_oem_intel(struct ncsi_request *nr)
700{
701 struct ncsi_rsp_oem_intel_pkt *intel;
702 struct ncsi_rsp_oem_pkt *rsp;
703
704 /* Get the response header */
705 rsp = (struct ncsi_rsp_oem_pkt *)skb_network_header(skb: nr->rsp);
706 intel = (struct ncsi_rsp_oem_intel_pkt *)(rsp->data);
707
708 if (intel->cmd == NCSI_OEM_INTEL_CMD_GMA)
709 return ncsi_rsp_handler_oem_gma(nr, NCSI_OEM_MFR_INTEL_ID);
710
711 return 0;
712}
713
714static struct ncsi_rsp_oem_handler {
715 unsigned int mfr_id;
716 int (*handler)(struct ncsi_request *nr);
717} ncsi_rsp_oem_handlers[] = {
718 { NCSI_OEM_MFR_MLX_ID, ncsi_rsp_handler_oem_mlx },
719 { NCSI_OEM_MFR_BCM_ID, ncsi_rsp_handler_oem_bcm },
720 { NCSI_OEM_MFR_INTEL_ID, ncsi_rsp_handler_oem_intel }
721};
722
723/* Response handler for OEM command */
724static int ncsi_rsp_handler_oem(struct ncsi_request *nr)
725{
726 struct ncsi_rsp_oem_handler *nrh = NULL;
727 struct ncsi_rsp_oem_pkt *rsp;
728 unsigned int mfr_id, i;
729
730 /* Get the response header */
731 rsp = (struct ncsi_rsp_oem_pkt *)skb_network_header(skb: nr->rsp);
732 mfr_id = ntohl(rsp->mfr_id);
733
734 /* Check for manufacturer id and Find the handler */
735 for (i = 0; i < ARRAY_SIZE(ncsi_rsp_oem_handlers); i++) {
736 if (ncsi_rsp_oem_handlers[i].mfr_id == mfr_id) {
737 if (ncsi_rsp_oem_handlers[i].handler)
738 nrh = &ncsi_rsp_oem_handlers[i];
739 else
740 nrh = NULL;
741
742 break;
743 }
744 }
745
746 if (!nrh) {
747 netdev_err(dev: nr->ndp->ndev.dev, format: "Received unrecognized OEM packet with MFR-ID (0x%x)\n",
748 mfr_id);
749 return -ENOENT;
750 }
751
752 /* Process the packet */
753 return nrh->handler(nr);
754}
755
756static int ncsi_rsp_handler_gvi(struct ncsi_request *nr)
757{
758 struct ncsi_rsp_gvi_pkt *rsp;
759 struct ncsi_dev_priv *ndp = nr->ndp;
760 struct ncsi_channel *nc;
761 struct ncsi_channel_version *ncv;
762 int i;
763
764 /* Find the channel */
765 rsp = (struct ncsi_rsp_gvi_pkt *)skb_network_header(skb: nr->rsp);
766 ncsi_find_package_and_channel(ndp, id: rsp->rsp.common.channel,
767 NULL, nc: &nc);
768 if (!nc)
769 return -ENODEV;
770
771 /* Update channel's version info
772 *
773 * Major, minor, and update fields are supposed to be
774 * unsigned integers encoded as packed BCD.
775 *
776 * Alpha1 and alpha2 are ISO/IEC 8859-1 characters.
777 */
778 ncv = &nc->version;
779 ncv->major = decode_bcd_u8(x: rsp->major);
780 ncv->minor = decode_bcd_u8(x: rsp->minor);
781 ncv->update = decode_bcd_u8(x: rsp->update);
782 ncv->alpha1 = rsp->alpha1;
783 ncv->alpha2 = rsp->alpha2;
784 memcpy(ncv->fw_name, rsp->fw_name, 12);
785 ncv->fw_version = ntohl(rsp->fw_version);
786 for (i = 0; i < ARRAY_SIZE(ncv->pci_ids); i++)
787 ncv->pci_ids[i] = ntohs(rsp->pci_ids[i]);
788 ncv->mf_id = ntohl(rsp->mf_id);
789
790 return 0;
791}
792
793static int ncsi_rsp_handler_gc(struct ncsi_request *nr)
794{
795 struct ncsi_rsp_gc_pkt *rsp;
796 struct ncsi_dev_priv *ndp = nr->ndp;
797 struct ncsi_channel *nc;
798 size_t size;
799
800 /* Find the channel */
801 rsp = (struct ncsi_rsp_gc_pkt *)skb_network_header(skb: nr->rsp);
802 ncsi_find_package_and_channel(ndp, id: rsp->rsp.common.channel,
803 NULL, nc: &nc);
804 if (!nc)
805 return -ENODEV;
806
807 /* Update channel's capabilities */
808 nc->caps[NCSI_CAP_GENERIC].cap = ntohl(rsp->cap) &
809 NCSI_CAP_GENERIC_MASK;
810 nc->caps[NCSI_CAP_BC].cap = ntohl(rsp->bc_cap) &
811 NCSI_CAP_BC_MASK;
812 nc->caps[NCSI_CAP_MC].cap = ntohl(rsp->mc_cap) &
813 NCSI_CAP_MC_MASK;
814 nc->caps[NCSI_CAP_BUFFER].cap = ntohl(rsp->buf_cap);
815 nc->caps[NCSI_CAP_AEN].cap = ntohl(rsp->aen_cap) &
816 NCSI_CAP_AEN_MASK;
817 nc->caps[NCSI_CAP_VLAN].cap = rsp->vlan_mode &
818 NCSI_CAP_VLAN_MASK;
819
820 size = (rsp->uc_cnt + rsp->mc_cnt + rsp->mixed_cnt) * ETH_ALEN;
821 nc->mac_filter.addrs = kzalloc(size, GFP_ATOMIC);
822 if (!nc->mac_filter.addrs)
823 return -ENOMEM;
824 nc->mac_filter.n_uc = rsp->uc_cnt;
825 nc->mac_filter.n_mc = rsp->mc_cnt;
826 nc->mac_filter.n_mixed = rsp->mixed_cnt;
827
828 nc->vlan_filter.vids = kcalloc(n: rsp->vlan_cnt,
829 size: sizeof(*nc->vlan_filter.vids),
830 GFP_ATOMIC);
831 if (!nc->vlan_filter.vids)
832 return -ENOMEM;
833 /* Set VLAN filters active so they are cleared in the first
834 * configuration state
835 */
836 nc->vlan_filter.bitmap = U64_MAX;
837 nc->vlan_filter.n_vids = rsp->vlan_cnt;
838
839 return 0;
840}
841
842static int ncsi_rsp_handler_gp(struct ncsi_request *nr)
843{
844 struct ncsi_channel_vlan_filter *ncvf;
845 struct ncsi_channel_mac_filter *ncmf;
846 struct ncsi_dev_priv *ndp = nr->ndp;
847 struct ncsi_rsp_gp_pkt *rsp;
848 struct ncsi_channel *nc;
849 unsigned short enable;
850 unsigned char *pdata;
851 unsigned long flags;
852 void *bitmap;
853 int i;
854
855 /* Find the channel */
856 rsp = (struct ncsi_rsp_gp_pkt *)skb_network_header(skb: nr->rsp);
857 ncsi_find_package_and_channel(ndp, id: rsp->rsp.common.channel,
858 NULL, nc: &nc);
859 if (!nc)
860 return -ENODEV;
861
862 /* Modes with explicit enabled indications */
863 if (ntohl(rsp->valid_modes) & 0x1) { /* BC filter mode */
864 nc->modes[NCSI_MODE_BC].enable = 1;
865 nc->modes[NCSI_MODE_BC].data[0] = ntohl(rsp->bc_mode);
866 }
867 if (ntohl(rsp->valid_modes) & 0x2) /* Channel enabled */
868 nc->modes[NCSI_MODE_ENABLE].enable = 1;
869 if (ntohl(rsp->valid_modes) & 0x4) /* Channel Tx enabled */
870 nc->modes[NCSI_MODE_TX_ENABLE].enable = 1;
871 if (ntohl(rsp->valid_modes) & 0x8) /* MC filter mode */
872 nc->modes[NCSI_MODE_MC].enable = 1;
873
874 /* Modes without explicit enabled indications */
875 nc->modes[NCSI_MODE_LINK].enable = 1;
876 nc->modes[NCSI_MODE_LINK].data[0] = ntohl(rsp->link_mode);
877 nc->modes[NCSI_MODE_VLAN].enable = 1;
878 nc->modes[NCSI_MODE_VLAN].data[0] = rsp->vlan_mode;
879 nc->modes[NCSI_MODE_FC].enable = 1;
880 nc->modes[NCSI_MODE_FC].data[0] = rsp->fc_mode;
881 nc->modes[NCSI_MODE_AEN].enable = 1;
882 nc->modes[NCSI_MODE_AEN].data[0] = ntohl(rsp->aen_mode);
883
884 /* MAC addresses filter table */
885 pdata = (unsigned char *)rsp + 48;
886 enable = rsp->mac_enable;
887 ncmf = &nc->mac_filter;
888 spin_lock_irqsave(&nc->lock, flags);
889 bitmap = &ncmf->bitmap;
890 for (i = 0; i < rsp->mac_cnt; i++, pdata += 6) {
891 if (!(enable & (0x1 << i)))
892 clear_bit(nr: i, addr: bitmap);
893 else
894 set_bit(nr: i, addr: bitmap);
895
896 memcpy(&ncmf->addrs[i * ETH_ALEN], pdata, ETH_ALEN);
897 }
898 spin_unlock_irqrestore(lock: &nc->lock, flags);
899
900 /* VLAN filter table */
901 enable = ntohs(rsp->vlan_enable);
902 ncvf = &nc->vlan_filter;
903 bitmap = &ncvf->bitmap;
904 spin_lock_irqsave(&nc->lock, flags);
905 for (i = 0; i < rsp->vlan_cnt; i++, pdata += 2) {
906 if (!(enable & (0x1 << i)))
907 clear_bit(nr: i, addr: bitmap);
908 else
909 set_bit(nr: i, addr: bitmap);
910
911 ncvf->vids[i] = ntohs(*(__be16 *)pdata);
912 }
913 spin_unlock_irqrestore(lock: &nc->lock, flags);
914
915 return 0;
916}
917
918static int ncsi_rsp_handler_gcps(struct ncsi_request *nr)
919{
920 struct ncsi_rsp_gcps_pkt *rsp;
921 struct ncsi_dev_priv *ndp = nr->ndp;
922 struct ncsi_channel *nc;
923 struct ncsi_channel_stats *ncs;
924
925 /* Find the channel */
926 rsp = (struct ncsi_rsp_gcps_pkt *)skb_network_header(skb: nr->rsp);
927 ncsi_find_package_and_channel(ndp, id: rsp->rsp.common.channel,
928 NULL, nc: &nc);
929 if (!nc)
930 return -ENODEV;
931
932 /* Update HNC's statistics */
933 ncs = &nc->stats;
934 ncs->hnc_cnt_hi = ntohl(rsp->cnt_hi);
935 ncs->hnc_cnt_lo = ntohl(rsp->cnt_lo);
936 ncs->hnc_rx_bytes = ntohl(rsp->rx_bytes);
937 ncs->hnc_tx_bytes = ntohl(rsp->tx_bytes);
938 ncs->hnc_rx_uc_pkts = ntohl(rsp->rx_uc_pkts);
939 ncs->hnc_rx_mc_pkts = ntohl(rsp->rx_mc_pkts);
940 ncs->hnc_rx_bc_pkts = ntohl(rsp->rx_bc_pkts);
941 ncs->hnc_tx_uc_pkts = ntohl(rsp->tx_uc_pkts);
942 ncs->hnc_tx_mc_pkts = ntohl(rsp->tx_mc_pkts);
943 ncs->hnc_tx_bc_pkts = ntohl(rsp->tx_bc_pkts);
944 ncs->hnc_fcs_err = ntohl(rsp->fcs_err);
945 ncs->hnc_align_err = ntohl(rsp->align_err);
946 ncs->hnc_false_carrier = ntohl(rsp->false_carrier);
947 ncs->hnc_runt_pkts = ntohl(rsp->runt_pkts);
948 ncs->hnc_jabber_pkts = ntohl(rsp->jabber_pkts);
949 ncs->hnc_rx_pause_xon = ntohl(rsp->rx_pause_xon);
950 ncs->hnc_rx_pause_xoff = ntohl(rsp->rx_pause_xoff);
951 ncs->hnc_tx_pause_xon = ntohl(rsp->tx_pause_xon);
952 ncs->hnc_tx_pause_xoff = ntohl(rsp->tx_pause_xoff);
953 ncs->hnc_tx_s_collision = ntohl(rsp->tx_s_collision);
954 ncs->hnc_tx_m_collision = ntohl(rsp->tx_m_collision);
955 ncs->hnc_l_collision = ntohl(rsp->l_collision);
956 ncs->hnc_e_collision = ntohl(rsp->e_collision);
957 ncs->hnc_rx_ctl_frames = ntohl(rsp->rx_ctl_frames);
958 ncs->hnc_rx_64_frames = ntohl(rsp->rx_64_frames);
959 ncs->hnc_rx_127_frames = ntohl(rsp->rx_127_frames);
960 ncs->hnc_rx_255_frames = ntohl(rsp->rx_255_frames);
961 ncs->hnc_rx_511_frames = ntohl(rsp->rx_511_frames);
962 ncs->hnc_rx_1023_frames = ntohl(rsp->rx_1023_frames);
963 ncs->hnc_rx_1522_frames = ntohl(rsp->rx_1522_frames);
964 ncs->hnc_rx_9022_frames = ntohl(rsp->rx_9022_frames);
965 ncs->hnc_tx_64_frames = ntohl(rsp->tx_64_frames);
966 ncs->hnc_tx_127_frames = ntohl(rsp->tx_127_frames);
967 ncs->hnc_tx_255_frames = ntohl(rsp->tx_255_frames);
968 ncs->hnc_tx_511_frames = ntohl(rsp->tx_511_frames);
969 ncs->hnc_tx_1023_frames = ntohl(rsp->tx_1023_frames);
970 ncs->hnc_tx_1522_frames = ntohl(rsp->tx_1522_frames);
971 ncs->hnc_tx_9022_frames = ntohl(rsp->tx_9022_frames);
972 ncs->hnc_rx_valid_bytes = ntohl(rsp->rx_valid_bytes);
973 ncs->hnc_rx_runt_pkts = ntohl(rsp->rx_runt_pkts);
974 ncs->hnc_rx_jabber_pkts = ntohl(rsp->rx_jabber_pkts);
975
976 return 0;
977}
978
979static int ncsi_rsp_handler_gns(struct ncsi_request *nr)
980{
981 struct ncsi_rsp_gns_pkt *rsp;
982 struct ncsi_dev_priv *ndp = nr->ndp;
983 struct ncsi_channel *nc;
984 struct ncsi_channel_stats *ncs;
985
986 /* Find the channel */
987 rsp = (struct ncsi_rsp_gns_pkt *)skb_network_header(skb: nr->rsp);
988 ncsi_find_package_and_channel(ndp, id: rsp->rsp.common.channel,
989 NULL, nc: &nc);
990 if (!nc)
991 return -ENODEV;
992
993 /* Update HNC's statistics */
994 ncs = &nc->stats;
995 ncs->ncsi_rx_cmds = ntohl(rsp->rx_cmds);
996 ncs->ncsi_dropped_cmds = ntohl(rsp->dropped_cmds);
997 ncs->ncsi_cmd_type_errs = ntohl(rsp->cmd_type_errs);
998 ncs->ncsi_cmd_csum_errs = ntohl(rsp->cmd_csum_errs);
999 ncs->ncsi_rx_pkts = ntohl(rsp->rx_pkts);
1000 ncs->ncsi_tx_pkts = ntohl(rsp->tx_pkts);
1001 ncs->ncsi_tx_aen_pkts = ntohl(rsp->tx_aen_pkts);
1002
1003 return 0;
1004}
1005
1006static int ncsi_rsp_handler_gnpts(struct ncsi_request *nr)
1007{
1008 struct ncsi_rsp_gnpts_pkt *rsp;
1009 struct ncsi_dev_priv *ndp = nr->ndp;
1010 struct ncsi_channel *nc;
1011 struct ncsi_channel_stats *ncs;
1012
1013 /* Find the channel */
1014 rsp = (struct ncsi_rsp_gnpts_pkt *)skb_network_header(skb: nr->rsp);
1015 ncsi_find_package_and_channel(ndp, id: rsp->rsp.common.channel,
1016 NULL, nc: &nc);
1017 if (!nc)
1018 return -ENODEV;
1019
1020 /* Update HNC's statistics */
1021 ncs = &nc->stats;
1022 ncs->pt_tx_pkts = ntohl(rsp->tx_pkts);
1023 ncs->pt_tx_dropped = ntohl(rsp->tx_dropped);
1024 ncs->pt_tx_channel_err = ntohl(rsp->tx_channel_err);
1025 ncs->pt_tx_us_err = ntohl(rsp->tx_us_err);
1026 ncs->pt_rx_pkts = ntohl(rsp->rx_pkts);
1027 ncs->pt_rx_dropped = ntohl(rsp->rx_dropped);
1028 ncs->pt_rx_channel_err = ntohl(rsp->rx_channel_err);
1029 ncs->pt_rx_us_err = ntohl(rsp->rx_us_err);
1030 ncs->pt_rx_os_err = ntohl(rsp->rx_os_err);
1031
1032 return 0;
1033}
1034
1035static int ncsi_rsp_handler_gps(struct ncsi_request *nr)
1036{
1037 struct ncsi_rsp_gps_pkt *rsp;
1038 struct ncsi_dev_priv *ndp = nr->ndp;
1039 struct ncsi_package *np;
1040
1041 /* Find the package */
1042 rsp = (struct ncsi_rsp_gps_pkt *)skb_network_header(skb: nr->rsp);
1043 ncsi_find_package_and_channel(ndp, id: rsp->rsp.common.channel,
1044 np: &np, NULL);
1045 if (!np)
1046 return -ENODEV;
1047
1048 return 0;
1049}
1050
1051static int ncsi_rsp_handler_gpuuid(struct ncsi_request *nr)
1052{
1053 struct ncsi_rsp_gpuuid_pkt *rsp;
1054 struct ncsi_dev_priv *ndp = nr->ndp;
1055 struct ncsi_package *np;
1056
1057 /* Find the package */
1058 rsp = (struct ncsi_rsp_gpuuid_pkt *)skb_network_header(skb: nr->rsp);
1059 ncsi_find_package_and_channel(ndp, id: rsp->rsp.common.channel,
1060 np: &np, NULL);
1061 if (!np)
1062 return -ENODEV;
1063
1064 memcpy(np->uuid, rsp->uuid, sizeof(rsp->uuid));
1065
1066 return 0;
1067}
1068
1069static int ncsi_rsp_handler_pldm(struct ncsi_request *nr)
1070{
1071 return 0;
1072}
1073
1074static int ncsi_rsp_handler_netlink(struct ncsi_request *nr)
1075{
1076 struct ncsi_dev_priv *ndp = nr->ndp;
1077 struct ncsi_rsp_pkt *rsp;
1078 struct ncsi_package *np;
1079 struct ncsi_channel *nc;
1080 int ret;
1081
1082 /* Find the package */
1083 rsp = (struct ncsi_rsp_pkt *)skb_network_header(skb: nr->rsp);
1084 ncsi_find_package_and_channel(ndp, id: rsp->rsp.common.channel,
1085 np: &np, nc: &nc);
1086 if (!np)
1087 return -ENODEV;
1088
1089 ret = ncsi_send_netlink_rsp(nr, np, nc);
1090
1091 return ret;
1092}
1093
1094static int ncsi_rsp_handler_gmcma(struct ncsi_request *nr)
1095{
1096 struct ncsi_dev_priv *ndp = nr->ndp;
1097 struct net_device *ndev = ndp->ndev.dev;
1098 struct ncsi_rsp_gmcma_pkt *rsp;
1099 struct sockaddr saddr;
1100 int ret = -1;
1101 int i;
1102
1103 rsp = (struct ncsi_rsp_gmcma_pkt *)skb_network_header(skb: nr->rsp);
1104 saddr.sa_family = ndev->type;
1105 ndev->priv_flags |= IFF_LIVE_ADDR_CHANGE;
1106
1107 netdev_info(dev: ndev, format: "NCSI: Received %d provisioned MAC addresses\n",
1108 rsp->address_count);
1109 for (i = 0; i < rsp->address_count; i++) {
1110 netdev_info(dev: ndev, format: "NCSI: MAC address %d: %02x:%02x:%02x:%02x:%02x:%02x\n",
1111 i, rsp->addresses[i][0], rsp->addresses[i][1],
1112 rsp->addresses[i][2], rsp->addresses[i][3],
1113 rsp->addresses[i][4], rsp->addresses[i][5]);
1114 }
1115
1116 for (i = 0; i < rsp->address_count; i++) {
1117 memcpy(saddr.sa_data, &rsp->addresses[i], ETH_ALEN);
1118 ret = ndev->netdev_ops->ndo_set_mac_address(ndev, &saddr);
1119 if (ret < 0) {
1120 netdev_warn(dev: ndev, format: "NCSI: Unable to assign %pM to device\n",
1121 saddr.sa_data);
1122 continue;
1123 }
1124 netdev_warn(dev: ndev, format: "NCSI: Set MAC address to %pM\n", saddr.sa_data);
1125 break;
1126 }
1127
1128 ndp->gma_flag = ret == 0;
1129 return ret;
1130}
1131
1132static struct ncsi_rsp_handler {
1133 unsigned char type;
1134 int payload;
1135 int (*handler)(struct ncsi_request *nr);
1136} ncsi_rsp_handlers[] = {
1137 { NCSI_PKT_RSP_CIS, 4, ncsi_rsp_handler_cis },
1138 { NCSI_PKT_RSP_SP, 4, ncsi_rsp_handler_sp },
1139 { NCSI_PKT_RSP_DP, 4, ncsi_rsp_handler_dp },
1140 { NCSI_PKT_RSP_EC, 4, ncsi_rsp_handler_ec },
1141 { NCSI_PKT_RSP_DC, 4, ncsi_rsp_handler_dc },
1142 { NCSI_PKT_RSP_RC, 4, ncsi_rsp_handler_rc },
1143 { NCSI_PKT_RSP_ECNT, 4, ncsi_rsp_handler_ecnt },
1144 { NCSI_PKT_RSP_DCNT, 4, ncsi_rsp_handler_dcnt },
1145 { NCSI_PKT_RSP_AE, 4, ncsi_rsp_handler_ae },
1146 { NCSI_PKT_RSP_SL, 4, ncsi_rsp_handler_sl },
1147 { NCSI_PKT_RSP_GLS, 16, ncsi_rsp_handler_gls },
1148 { NCSI_PKT_RSP_SVF, 4, ncsi_rsp_handler_svf },
1149 { NCSI_PKT_RSP_EV, 4, ncsi_rsp_handler_ev },
1150 { NCSI_PKT_RSP_DV, 4, ncsi_rsp_handler_dv },
1151 { NCSI_PKT_RSP_SMA, 4, ncsi_rsp_handler_sma },
1152 { NCSI_PKT_RSP_EBF, 4, ncsi_rsp_handler_ebf },
1153 { NCSI_PKT_RSP_DBF, 4, ncsi_rsp_handler_dbf },
1154 { NCSI_PKT_RSP_EGMF, 4, ncsi_rsp_handler_egmf },
1155 { NCSI_PKT_RSP_DGMF, 4, ncsi_rsp_handler_dgmf },
1156 { NCSI_PKT_RSP_SNFC, 4, ncsi_rsp_handler_snfc },
1157 { NCSI_PKT_RSP_GVI, 40, ncsi_rsp_handler_gvi },
1158 { NCSI_PKT_RSP_GC, 32, ncsi_rsp_handler_gc },
1159 { NCSI_PKT_RSP_GP, -1, ncsi_rsp_handler_gp },
1160 { NCSI_PKT_RSP_GCPS, 204, ncsi_rsp_handler_gcps },
1161 { NCSI_PKT_RSP_GNS, 32, ncsi_rsp_handler_gns },
1162 { NCSI_PKT_RSP_GNPTS, 48, ncsi_rsp_handler_gnpts },
1163 { NCSI_PKT_RSP_GPS, 8, ncsi_rsp_handler_gps },
1164 { NCSI_PKT_RSP_OEM, -1, ncsi_rsp_handler_oem },
1165 { NCSI_PKT_RSP_PLDM, -1, ncsi_rsp_handler_pldm },
1166 { NCSI_PKT_RSP_GPUUID, 20, ncsi_rsp_handler_gpuuid },
1167 { NCSI_PKT_RSP_QPNPR, -1, ncsi_rsp_handler_pldm },
1168 { NCSI_PKT_RSP_SNPR, -1, ncsi_rsp_handler_pldm },
1169 { NCSI_PKT_RSP_GMCMA, -1, ncsi_rsp_handler_gmcma },
1170};
1171
1172int ncsi_rcv_rsp(struct sk_buff *skb, struct net_device *dev,
1173 struct packet_type *pt, struct net_device *orig_dev)
1174{
1175 struct ncsi_rsp_handler *nrh = NULL;
1176 struct ncsi_dev *nd;
1177 struct ncsi_dev_priv *ndp;
1178 struct ncsi_request *nr;
1179 struct ncsi_pkt_hdr *hdr;
1180 unsigned long flags;
1181 int payload, i, ret;
1182
1183 /* Find the NCSI device */
1184 nd = ncsi_find_dev(dev: orig_dev);
1185 ndp = nd ? TO_NCSI_DEV_PRIV(nd) : NULL;
1186 if (!ndp)
1187 return -ENODEV;
1188
1189 /* Check if it is AEN packet */
1190 hdr = (struct ncsi_pkt_hdr *)skb_network_header(skb);
1191 if (hdr->type == NCSI_PKT_AEN)
1192 return ncsi_aen_handler(ndp, skb);
1193
1194 /* Find the handler */
1195 for (i = 0; i < ARRAY_SIZE(ncsi_rsp_handlers); i++) {
1196 if (ncsi_rsp_handlers[i].type == hdr->type) {
1197 if (ncsi_rsp_handlers[i].handler)
1198 nrh = &ncsi_rsp_handlers[i];
1199 else
1200 nrh = NULL;
1201
1202 break;
1203 }
1204 }
1205
1206 if (!nrh) {
1207 netdev_err(dev: nd->dev, format: "Received unrecognized packet (0x%x)\n",
1208 hdr->type);
1209 return -ENOENT;
1210 }
1211
1212 /* Associate with the request */
1213 spin_lock_irqsave(&ndp->lock, flags);
1214 nr = &ndp->requests[hdr->id];
1215 if (!nr->used) {
1216 spin_unlock_irqrestore(lock: &ndp->lock, flags);
1217 return -ENODEV;
1218 }
1219
1220 nr->rsp = skb;
1221 if (!nr->enabled) {
1222 spin_unlock_irqrestore(lock: &ndp->lock, flags);
1223 ret = -ENOENT;
1224 goto out;
1225 }
1226
1227 /* Validate the packet */
1228 spin_unlock_irqrestore(lock: &ndp->lock, flags);
1229 payload = nrh->payload;
1230 if (payload < 0)
1231 payload = ntohs(hdr->length);
1232 ret = ncsi_validate_rsp_pkt(nr, payload);
1233 if (ret) {
1234 netdev_warn(dev: ndp->ndev.dev,
1235 format: "NCSI: 'bad' packet ignored for type 0x%x\n",
1236 hdr->type);
1237
1238 if (nr->flags == NCSI_REQ_FLAG_NETLINK_DRIVEN) {
1239 if (ret == -EPERM)
1240 goto out_netlink;
1241 else
1242 ncsi_send_netlink_err(dev: ndp->ndev.dev,
1243 snd_seq: nr->snd_seq,
1244 snd_portid: nr->snd_portid,
1245 nlhdr: &nr->nlhdr,
1246 err: ret);
1247 }
1248 goto out;
1249 }
1250
1251 /* Process the packet */
1252 ret = nrh->handler(nr);
1253 if (ret)
1254 netdev_err(dev: ndp->ndev.dev,
1255 format: "NCSI: Handler for packet type 0x%x returned %d\n",
1256 hdr->type, ret);
1257
1258out_netlink:
1259 if (nr->flags == NCSI_REQ_FLAG_NETLINK_DRIVEN) {
1260 ret = ncsi_rsp_handler_netlink(nr);
1261 if (ret) {
1262 netdev_err(dev: ndp->ndev.dev,
1263 format: "NCSI: Netlink handler for packet type 0x%x returned %d\n",
1264 hdr->type, ret);
1265 }
1266 }
1267
1268out:
1269 ncsi_free_request(nr);
1270 return ret;
1271}
1272

source code of linux/net/ncsi/ncsi-rsp.c