2 * Copyright Gavin Shan, IBM Corporation 2016.
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.
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>
17 #include <net/net_namespace.h>
19 #include <net/genetlink.h>
23 #include "ncsi-netlink.h"
25 static int ncsi_validate_rsp_pkt(struct ncsi_request *nr,
26 unsigned short payload)
28 struct ncsi_rsp_pkt_hdr *h;
32 /* Check NCSI packet header. We don't need validate
33 * the packet type, which should have been checked
34 * before calling this function.
36 h = (struct ncsi_rsp_pkt_hdr *)skb_network_header(nr->rsp);
38 if (h->common.revision != NCSI_PKT_REVISION) {
39 netdev_dbg(nr->ndp->ndev.dev,
40 "NCSI: unsupported header revision\n");
43 if (ntohs(h->common.length) != payload) {
44 netdev_dbg(nr->ndp->ndev.dev,
45 "NCSI: payload length mismatched\n");
49 /* Check on code and reason */
50 if (ntohs(h->code) != NCSI_PKT_RSP_C_COMPLETED ||
51 ntohs(h->reason) != NCSI_PKT_RSP_R_NO_ERROR) {
52 netdev_dbg(nr->ndp->ndev.dev,
53 "NCSI: non zero response/reason code\n");
57 /* Validate checksum, which might be zeroes if the
58 * sender doesn't support checksum according to NCSI
61 pchecksum = (__be32 *)((void *)(h + 1) + payload - 4);
62 if (ntohl(*pchecksum) == 0)
65 checksum = ncsi_calculate_checksum((unsigned char *)h,
66 sizeof(*h) + payload - 4);
68 if (*pchecksum != htonl(checksum)) {
69 netdev_dbg(nr->ndp->ndev.dev, "NCSI: checksum mismatched\n");
76 static int ncsi_rsp_handler_cis(struct ncsi_request *nr)
78 struct ncsi_rsp_pkt *rsp;
79 struct ncsi_dev_priv *ndp = nr->ndp;
80 struct ncsi_package *np;
81 struct ncsi_channel *nc;
84 rsp = (struct ncsi_rsp_pkt *)skb_network_header(nr->rsp);
85 ncsi_find_package_and_channel(ndp, rsp->rsp.common.channel, &np, &nc);
87 if (ndp->flags & NCSI_DEV_PROBED)
90 id = NCSI_CHANNEL_INDEX(rsp->rsp.common.channel);
91 nc = ncsi_add_channel(np, id);
94 return nc ? 0 : -ENODEV;
97 static int ncsi_rsp_handler_sp(struct ncsi_request *nr)
99 struct ncsi_rsp_pkt *rsp;
100 struct ncsi_dev_priv *ndp = nr->ndp;
101 struct ncsi_package *np;
104 /* Add the package if it's not existing. Otherwise,
105 * to change the state of its child channels.
107 rsp = (struct ncsi_rsp_pkt *)skb_network_header(nr->rsp);
108 ncsi_find_package_and_channel(ndp, rsp->rsp.common.channel,
111 if (ndp->flags & NCSI_DEV_PROBED)
114 id = NCSI_PACKAGE_INDEX(rsp->rsp.common.channel);
115 np = ncsi_add_package(ndp, id);
123 static int ncsi_rsp_handler_dp(struct ncsi_request *nr)
125 struct ncsi_rsp_pkt *rsp;
126 struct ncsi_dev_priv *ndp = nr->ndp;
127 struct ncsi_package *np;
128 struct ncsi_channel *nc;
131 /* Find the package */
132 rsp = (struct ncsi_rsp_pkt *)skb_network_header(nr->rsp);
133 ncsi_find_package_and_channel(ndp, rsp->rsp.common.channel,
138 /* Change state of all channels attached to the package */
139 NCSI_FOR_EACH_CHANNEL(np, nc) {
140 spin_lock_irqsave(&nc->lock, flags);
141 nc->state = NCSI_CHANNEL_INACTIVE;
142 spin_unlock_irqrestore(&nc->lock, flags);
148 static int ncsi_rsp_handler_ec(struct ncsi_request *nr)
150 struct ncsi_rsp_pkt *rsp;
151 struct ncsi_dev_priv *ndp = nr->ndp;
152 struct ncsi_channel *nc;
153 struct ncsi_channel_mode *ncm;
155 /* Find the package and channel */
156 rsp = (struct ncsi_rsp_pkt *)skb_network_header(nr->rsp);
157 ncsi_find_package_and_channel(ndp, rsp->rsp.common.channel,
162 ncm = &nc->modes[NCSI_MODE_ENABLE];
170 static int ncsi_rsp_handler_dc(struct ncsi_request *nr)
172 struct ncsi_rsp_pkt *rsp;
173 struct ncsi_dev_priv *ndp = nr->ndp;
174 struct ncsi_channel *nc;
175 struct ncsi_channel_mode *ncm;
178 ret = ncsi_validate_rsp_pkt(nr, 4);
182 /* Find the package and channel */
183 rsp = (struct ncsi_rsp_pkt *)skb_network_header(nr->rsp);
184 ncsi_find_package_and_channel(ndp, rsp->rsp.common.channel,
189 ncm = &nc->modes[NCSI_MODE_ENABLE];
197 static int ncsi_rsp_handler_rc(struct ncsi_request *nr)
199 struct ncsi_rsp_pkt *rsp;
200 struct ncsi_dev_priv *ndp = nr->ndp;
201 struct ncsi_channel *nc;
204 /* Find the package and channel */
205 rsp = (struct ncsi_rsp_pkt *)skb_network_header(nr->rsp);
206 ncsi_find_package_and_channel(ndp, rsp->rsp.common.channel,
211 /* Update state for the specified channel */
212 spin_lock_irqsave(&nc->lock, flags);
213 nc->state = NCSI_CHANNEL_INACTIVE;
214 spin_unlock_irqrestore(&nc->lock, flags);
219 static int ncsi_rsp_handler_ecnt(struct ncsi_request *nr)
221 struct ncsi_rsp_pkt *rsp;
222 struct ncsi_dev_priv *ndp = nr->ndp;
223 struct ncsi_channel *nc;
224 struct ncsi_channel_mode *ncm;
226 /* Find the package and channel */
227 rsp = (struct ncsi_rsp_pkt *)skb_network_header(nr->rsp);
228 ncsi_find_package_and_channel(ndp, rsp->rsp.common.channel,
233 ncm = &nc->modes[NCSI_MODE_TX_ENABLE];
241 static int ncsi_rsp_handler_dcnt(struct ncsi_request *nr)
243 struct ncsi_rsp_pkt *rsp;
244 struct ncsi_dev_priv *ndp = nr->ndp;
245 struct ncsi_channel *nc;
246 struct ncsi_channel_mode *ncm;
248 /* Find the package and channel */
249 rsp = (struct ncsi_rsp_pkt *)skb_network_header(nr->rsp);
250 ncsi_find_package_and_channel(ndp, rsp->rsp.common.channel,
255 ncm = &nc->modes[NCSI_MODE_TX_ENABLE];
263 static int ncsi_rsp_handler_ae(struct ncsi_request *nr)
265 struct ncsi_cmd_ae_pkt *cmd;
266 struct ncsi_rsp_pkt *rsp;
267 struct ncsi_dev_priv *ndp = nr->ndp;
268 struct ncsi_channel *nc;
269 struct ncsi_channel_mode *ncm;
271 /* Find the package and channel */
272 rsp = (struct ncsi_rsp_pkt *)skb_network_header(nr->rsp);
273 ncsi_find_package_and_channel(ndp, rsp->rsp.common.channel,
278 /* Check if the AEN has been enabled */
279 ncm = &nc->modes[NCSI_MODE_AEN];
283 /* Update to AEN configuration */
284 cmd = (struct ncsi_cmd_ae_pkt *)skb_network_header(nr->cmd);
286 ncm->data[0] = cmd->mc_id;
287 ncm->data[1] = ntohl(cmd->mode);
292 static int ncsi_rsp_handler_sl(struct ncsi_request *nr)
294 struct ncsi_cmd_sl_pkt *cmd;
295 struct ncsi_rsp_pkt *rsp;
296 struct ncsi_dev_priv *ndp = nr->ndp;
297 struct ncsi_channel *nc;
298 struct ncsi_channel_mode *ncm;
300 /* Find the package and channel */
301 rsp = (struct ncsi_rsp_pkt *)skb_network_header(nr->rsp);
302 ncsi_find_package_and_channel(ndp, rsp->rsp.common.channel,
307 cmd = (struct ncsi_cmd_sl_pkt *)skb_network_header(nr->cmd);
308 ncm = &nc->modes[NCSI_MODE_LINK];
309 ncm->data[0] = ntohl(cmd->mode);
310 ncm->data[1] = ntohl(cmd->oem_mode);
315 static int ncsi_rsp_handler_gls(struct ncsi_request *nr)
317 struct ncsi_rsp_gls_pkt *rsp;
318 struct ncsi_dev_priv *ndp = nr->ndp;
319 struct ncsi_channel *nc;
320 struct ncsi_channel_mode *ncm;
323 /* Find the package and channel */
324 rsp = (struct ncsi_rsp_gls_pkt *)skb_network_header(nr->rsp);
325 ncsi_find_package_and_channel(ndp, rsp->rsp.common.channel,
330 ncm = &nc->modes[NCSI_MODE_LINK];
331 ncm->data[2] = ntohl(rsp->status);
332 ncm->data[3] = ntohl(rsp->other);
333 ncm->data[4] = ntohl(rsp->oem_status);
335 if (nr->flags & NCSI_REQ_FLAG_EVENT_DRIVEN)
338 /* Reset the channel monitor if it has been enabled */
339 spin_lock_irqsave(&nc->lock, flags);
340 nc->monitor.state = NCSI_CHANNEL_MONITOR_START;
341 spin_unlock_irqrestore(&nc->lock, flags);
346 static int ncsi_rsp_handler_svf(struct ncsi_request *nr)
348 struct ncsi_cmd_svf_pkt *cmd;
349 struct ncsi_rsp_pkt *rsp;
350 struct ncsi_dev_priv *ndp = nr->ndp;
351 struct ncsi_channel *nc;
352 struct ncsi_channel_vlan_filter *ncf;
356 /* Find the package and channel */
357 rsp = (struct ncsi_rsp_pkt *)skb_network_header(nr->rsp);
358 ncsi_find_package_and_channel(ndp, rsp->rsp.common.channel,
363 cmd = (struct ncsi_cmd_svf_pkt *)skb_network_header(nr->cmd);
364 ncf = &nc->vlan_filter;
365 if (cmd->index == 0 || cmd->index > ncf->n_vids)
368 /* Add or remove the VLAN filter. Remember HW indexes from 1 */
369 spin_lock_irqsave(&nc->lock, flags);
370 bitmap = &ncf->bitmap;
371 if (!(cmd->enable & 0x1)) {
372 if (test_and_clear_bit(cmd->index - 1, bitmap))
373 ncf->vids[cmd->index - 1] = 0;
375 set_bit(cmd->index - 1, bitmap);
376 ncf->vids[cmd->index - 1] = ntohs(cmd->vlan);
378 spin_unlock_irqrestore(&nc->lock, flags);
383 static int ncsi_rsp_handler_ev(struct ncsi_request *nr)
385 struct ncsi_cmd_ev_pkt *cmd;
386 struct ncsi_rsp_pkt *rsp;
387 struct ncsi_dev_priv *ndp = nr->ndp;
388 struct ncsi_channel *nc;
389 struct ncsi_channel_mode *ncm;
391 /* Find the package and channel */
392 rsp = (struct ncsi_rsp_pkt *)skb_network_header(nr->rsp);
393 ncsi_find_package_and_channel(ndp, rsp->rsp.common.channel,
398 /* Check if VLAN mode has been enabled */
399 ncm = &nc->modes[NCSI_MODE_VLAN];
403 /* Update to VLAN mode */
404 cmd = (struct ncsi_cmd_ev_pkt *)skb_network_header(nr->cmd);
406 ncm->data[0] = ntohl(cmd->mode);
411 static int ncsi_rsp_handler_dv(struct ncsi_request *nr)
413 struct ncsi_rsp_pkt *rsp;
414 struct ncsi_dev_priv *ndp = nr->ndp;
415 struct ncsi_channel *nc;
416 struct ncsi_channel_mode *ncm;
418 /* Find the package and channel */
419 rsp = (struct ncsi_rsp_pkt *)skb_network_header(nr->rsp);
420 ncsi_find_package_and_channel(ndp, rsp->rsp.common.channel,
425 /* Check if VLAN mode has been enabled */
426 ncm = &nc->modes[NCSI_MODE_VLAN];
430 /* Update to VLAN mode */
435 static int ncsi_rsp_handler_sma(struct ncsi_request *nr)
437 struct ncsi_cmd_sma_pkt *cmd;
438 struct ncsi_rsp_pkt *rsp;
439 struct ncsi_dev_priv *ndp = nr->ndp;
440 struct ncsi_channel *nc;
441 struct ncsi_channel_mac_filter *ncf;
448 /* Find the package and channel */
449 rsp = (struct ncsi_rsp_pkt *)skb_network_header(nr->rsp);
450 ncsi_find_package_and_channel(ndp, rsp->rsp.common.channel,
455 /* According to NCSI spec 1.01, the mixed filter table
456 * isn't supported yet.
458 cmd = (struct ncsi_cmd_sma_pkt *)skb_network_header(nr->cmd);
459 enabled = cmd->at_e & 0x1;
460 ncf = &nc->mac_filter;
461 bitmap = &ncf->bitmap;
463 if (cmd->index == 0 ||
464 cmd->index > ncf->n_uc + ncf->n_mc + ncf->n_mixed)
467 index = (cmd->index - 1) * ETH_ALEN;
468 spin_lock_irqsave(&nc->lock, flags);
470 set_bit(cmd->index - 1, bitmap);
471 memcpy(&ncf->addrs[index], cmd->mac, ETH_ALEN);
473 clear_bit(cmd->index - 1, bitmap);
474 memset(&ncf->addrs[index], 0, ETH_ALEN);
476 spin_unlock_irqrestore(&nc->lock, flags);
481 static int ncsi_rsp_handler_ebf(struct ncsi_request *nr)
483 struct ncsi_cmd_ebf_pkt *cmd;
484 struct ncsi_rsp_pkt *rsp;
485 struct ncsi_dev_priv *ndp = nr->ndp;
486 struct ncsi_channel *nc;
487 struct ncsi_channel_mode *ncm;
489 /* Find the package and channel */
490 rsp = (struct ncsi_rsp_pkt *)skb_network_header(nr->rsp);
491 ncsi_find_package_and_channel(ndp, rsp->rsp.common.channel, NULL, &nc);
495 /* Check if broadcast filter has been enabled */
496 ncm = &nc->modes[NCSI_MODE_BC];
500 /* Update to broadcast filter mode */
501 cmd = (struct ncsi_cmd_ebf_pkt *)skb_network_header(nr->cmd);
503 ncm->data[0] = ntohl(cmd->mode);
508 static int ncsi_rsp_handler_dbf(struct ncsi_request *nr)
510 struct ncsi_rsp_pkt *rsp;
511 struct ncsi_dev_priv *ndp = nr->ndp;
512 struct ncsi_channel *nc;
513 struct ncsi_channel_mode *ncm;
515 rsp = (struct ncsi_rsp_pkt *)skb_network_header(nr->rsp);
516 ncsi_find_package_and_channel(ndp, rsp->rsp.common.channel,
521 /* Check if broadcast filter isn't enabled */
522 ncm = &nc->modes[NCSI_MODE_BC];
526 /* Update to broadcast filter mode */
533 static int ncsi_rsp_handler_egmf(struct ncsi_request *nr)
535 struct ncsi_cmd_egmf_pkt *cmd;
536 struct ncsi_rsp_pkt *rsp;
537 struct ncsi_dev_priv *ndp = nr->ndp;
538 struct ncsi_channel *nc;
539 struct ncsi_channel_mode *ncm;
541 /* Find the channel */
542 rsp = (struct ncsi_rsp_pkt *)skb_network_header(nr->rsp);
543 ncsi_find_package_and_channel(ndp, rsp->rsp.common.channel,
548 /* Check if multicast filter has been enabled */
549 ncm = &nc->modes[NCSI_MODE_MC];
553 /* Update to multicast filter mode */
554 cmd = (struct ncsi_cmd_egmf_pkt *)skb_network_header(nr->cmd);
556 ncm->data[0] = ntohl(cmd->mode);
561 static int ncsi_rsp_handler_dgmf(struct ncsi_request *nr)
563 struct ncsi_rsp_pkt *rsp;
564 struct ncsi_dev_priv *ndp = nr->ndp;
565 struct ncsi_channel *nc;
566 struct ncsi_channel_mode *ncm;
568 rsp = (struct ncsi_rsp_pkt *)skb_network_header(nr->rsp);
569 ncsi_find_package_and_channel(ndp, rsp->rsp.common.channel,
574 /* Check if multicast filter has been enabled */
575 ncm = &nc->modes[NCSI_MODE_MC];
579 /* Update to multicast filter mode */
586 static int ncsi_rsp_handler_snfc(struct ncsi_request *nr)
588 struct ncsi_cmd_snfc_pkt *cmd;
589 struct ncsi_rsp_pkt *rsp;
590 struct ncsi_dev_priv *ndp = nr->ndp;
591 struct ncsi_channel *nc;
592 struct ncsi_channel_mode *ncm;
594 /* Find the channel */
595 rsp = (struct ncsi_rsp_pkt *)skb_network_header(nr->rsp);
596 ncsi_find_package_and_channel(ndp, rsp->rsp.common.channel,
601 /* Check if flow control has been enabled */
602 ncm = &nc->modes[NCSI_MODE_FC];
606 /* Update to flow control mode */
607 cmd = (struct ncsi_cmd_snfc_pkt *)skb_network_header(nr->cmd);
609 ncm->data[0] = cmd->mode;
614 /* Response handler for Broadcom command Get Mac Address */
615 static int ncsi_rsp_handler_oem_bcm_gma(struct ncsi_request *nr)
617 struct ncsi_dev_priv *ndp = nr->ndp;
618 struct net_device *ndev = ndp->ndev.dev;
619 const struct net_device_ops *ops = ndev->netdev_ops;
620 struct ncsi_rsp_oem_pkt *rsp;
621 struct sockaddr saddr;
624 /* Get the response header */
625 rsp = (struct ncsi_rsp_oem_pkt *)skb_network_header(nr->rsp);
627 saddr.sa_family = ndev->type;
628 ndev->priv_flags |= IFF_LIVE_ADDR_CHANGE;
629 memcpy(saddr.sa_data, &rsp->data[BCM_MAC_ADDR_OFFSET], ETH_ALEN);
630 /* Increase mac address by 1 for BMC's address */
631 saddr.sa_data[ETH_ALEN - 1]++;
632 ret = ops->ndo_set_mac_address(ndev, &saddr);
634 netdev_warn(ndev, "NCSI: 'Writing mac address to device failed\n");
639 /* Response handler for Broadcom card */
640 static int ncsi_rsp_handler_oem_bcm(struct ncsi_request *nr)
642 struct ncsi_rsp_oem_bcm_pkt *bcm;
643 struct ncsi_rsp_oem_pkt *rsp;
645 /* Get the response header */
646 rsp = (struct ncsi_rsp_oem_pkt *)skb_network_header(nr->rsp);
647 bcm = (struct ncsi_rsp_oem_bcm_pkt *)(rsp->data);
649 if (bcm->type == NCSI_OEM_BCM_CMD_GMA)
650 return ncsi_rsp_handler_oem_bcm_gma(nr);
654 static struct ncsi_rsp_oem_handler {
656 int (*handler)(struct ncsi_request *nr);
657 } ncsi_rsp_oem_handlers[] = {
658 { NCSI_OEM_MFR_MLX_ID, NULL },
659 { NCSI_OEM_MFR_BCM_ID, ncsi_rsp_handler_oem_bcm }
662 /* Response handler for OEM command */
663 static int ncsi_rsp_handler_oem(struct ncsi_request *nr)
665 struct ncsi_rsp_oem_handler *nrh = NULL;
666 struct ncsi_rsp_oem_pkt *rsp;
667 unsigned int mfr_id, i;
669 /* Get the response header */
670 rsp = (struct ncsi_rsp_oem_pkt *)skb_network_header(nr->rsp);
671 mfr_id = ntohl(rsp->mfr_id);
673 /* Check for manufacturer id and Find the handler */
674 for (i = 0; i < ARRAY_SIZE(ncsi_rsp_oem_handlers); i++) {
675 if (ncsi_rsp_oem_handlers[i].mfr_id == mfr_id) {
676 if (ncsi_rsp_oem_handlers[i].handler)
677 nrh = &ncsi_rsp_oem_handlers[i];
686 netdev_err(nr->ndp->ndev.dev, "Received unrecognized OEM packet with MFR-ID (0x%x)\n",
691 /* Process the packet */
692 return nrh->handler(nr);
695 static int ncsi_rsp_handler_gvi(struct ncsi_request *nr)
697 struct ncsi_rsp_gvi_pkt *rsp;
698 struct ncsi_dev_priv *ndp = nr->ndp;
699 struct ncsi_channel *nc;
700 struct ncsi_channel_version *ncv;
703 /* Find the channel */
704 rsp = (struct ncsi_rsp_gvi_pkt *)skb_network_header(nr->rsp);
705 ncsi_find_package_and_channel(ndp, rsp->rsp.common.channel,
710 /* Update to channel's version info */
712 ncv->version = ntohl(rsp->ncsi_version);
713 ncv->alpha2 = rsp->alpha2;
714 memcpy(ncv->fw_name, rsp->fw_name, 12);
715 ncv->fw_version = ntohl(rsp->fw_version);
716 for (i = 0; i < ARRAY_SIZE(ncv->pci_ids); i++)
717 ncv->pci_ids[i] = ntohs(rsp->pci_ids[i]);
718 ncv->mf_id = ntohl(rsp->mf_id);
723 static int ncsi_rsp_handler_gc(struct ncsi_request *nr)
725 struct ncsi_rsp_gc_pkt *rsp;
726 struct ncsi_dev_priv *ndp = nr->ndp;
727 struct ncsi_channel *nc;
730 /* Find the channel */
731 rsp = (struct ncsi_rsp_gc_pkt *)skb_network_header(nr->rsp);
732 ncsi_find_package_and_channel(ndp, rsp->rsp.common.channel,
737 /* Update channel's capabilities */
738 nc->caps[NCSI_CAP_GENERIC].cap = ntohl(rsp->cap) &
739 NCSI_CAP_GENERIC_MASK;
740 nc->caps[NCSI_CAP_BC].cap = ntohl(rsp->bc_cap) &
742 nc->caps[NCSI_CAP_MC].cap = ntohl(rsp->mc_cap) &
744 nc->caps[NCSI_CAP_BUFFER].cap = ntohl(rsp->buf_cap);
745 nc->caps[NCSI_CAP_AEN].cap = ntohl(rsp->aen_cap) &
747 nc->caps[NCSI_CAP_VLAN].cap = rsp->vlan_mode &
750 size = (rsp->uc_cnt + rsp->mc_cnt + rsp->mixed_cnt) * ETH_ALEN;
751 nc->mac_filter.addrs = kzalloc(size, GFP_ATOMIC);
752 if (!nc->mac_filter.addrs)
754 nc->mac_filter.n_uc = rsp->uc_cnt;
755 nc->mac_filter.n_mc = rsp->mc_cnt;
756 nc->mac_filter.n_mixed = rsp->mixed_cnt;
758 nc->vlan_filter.vids = kcalloc(rsp->vlan_cnt,
759 sizeof(*nc->vlan_filter.vids),
761 if (!nc->vlan_filter.vids)
763 /* Set VLAN filters active so they are cleared in the first
764 * configuration state
766 nc->vlan_filter.bitmap = U64_MAX;
767 nc->vlan_filter.n_vids = rsp->vlan_cnt;
772 static int ncsi_rsp_handler_gp(struct ncsi_request *nr)
774 struct ncsi_channel_vlan_filter *ncvf;
775 struct ncsi_channel_mac_filter *ncmf;
776 struct ncsi_dev_priv *ndp = nr->ndp;
777 struct ncsi_rsp_gp_pkt *rsp;
778 struct ncsi_channel *nc;
779 unsigned short enable;
780 unsigned char *pdata;
785 /* Find the channel */
786 rsp = (struct ncsi_rsp_gp_pkt *)skb_network_header(nr->rsp);
787 ncsi_find_package_and_channel(ndp, rsp->rsp.common.channel,
792 /* Modes with explicit enabled indications */
793 if (ntohl(rsp->valid_modes) & 0x1) { /* BC filter mode */
794 nc->modes[NCSI_MODE_BC].enable = 1;
795 nc->modes[NCSI_MODE_BC].data[0] = ntohl(rsp->bc_mode);
797 if (ntohl(rsp->valid_modes) & 0x2) /* Channel enabled */
798 nc->modes[NCSI_MODE_ENABLE].enable = 1;
799 if (ntohl(rsp->valid_modes) & 0x4) /* Channel Tx enabled */
800 nc->modes[NCSI_MODE_TX_ENABLE].enable = 1;
801 if (ntohl(rsp->valid_modes) & 0x8) /* MC filter mode */
802 nc->modes[NCSI_MODE_MC].enable = 1;
804 /* Modes without explicit enabled indications */
805 nc->modes[NCSI_MODE_LINK].enable = 1;
806 nc->modes[NCSI_MODE_LINK].data[0] = ntohl(rsp->link_mode);
807 nc->modes[NCSI_MODE_VLAN].enable = 1;
808 nc->modes[NCSI_MODE_VLAN].data[0] = rsp->vlan_mode;
809 nc->modes[NCSI_MODE_FC].enable = 1;
810 nc->modes[NCSI_MODE_FC].data[0] = rsp->fc_mode;
811 nc->modes[NCSI_MODE_AEN].enable = 1;
812 nc->modes[NCSI_MODE_AEN].data[0] = ntohl(rsp->aen_mode);
814 /* MAC addresses filter table */
815 pdata = (unsigned char *)rsp + 48;
816 enable = rsp->mac_enable;
817 ncmf = &nc->mac_filter;
818 spin_lock_irqsave(&nc->lock, flags);
819 bitmap = &ncmf->bitmap;
820 for (i = 0; i < rsp->mac_cnt; i++, pdata += 6) {
821 if (!(enable & (0x1 << i)))
822 clear_bit(i, bitmap);
826 memcpy(&ncmf->addrs[i * ETH_ALEN], pdata, ETH_ALEN);
828 spin_unlock_irqrestore(&nc->lock, flags);
830 /* VLAN filter table */
831 enable = ntohs(rsp->vlan_enable);
832 ncvf = &nc->vlan_filter;
833 bitmap = &ncvf->bitmap;
834 spin_lock_irqsave(&nc->lock, flags);
835 for (i = 0; i < rsp->vlan_cnt; i++, pdata += 2) {
836 if (!(enable & (0x1 << i)))
837 clear_bit(i, bitmap);
841 ncvf->vids[i] = ntohs(*(__be16 *)pdata);
843 spin_unlock_irqrestore(&nc->lock, flags);
848 static int ncsi_rsp_handler_gcps(struct ncsi_request *nr)
850 struct ncsi_rsp_gcps_pkt *rsp;
851 struct ncsi_dev_priv *ndp = nr->ndp;
852 struct ncsi_channel *nc;
853 struct ncsi_channel_stats *ncs;
855 /* Find the channel */
856 rsp = (struct ncsi_rsp_gcps_pkt *)skb_network_header(nr->rsp);
857 ncsi_find_package_and_channel(ndp, rsp->rsp.common.channel,
862 /* Update HNC's statistics */
864 ncs->hnc_cnt_hi = ntohl(rsp->cnt_hi);
865 ncs->hnc_cnt_lo = ntohl(rsp->cnt_lo);
866 ncs->hnc_rx_bytes = ntohl(rsp->rx_bytes);
867 ncs->hnc_tx_bytes = ntohl(rsp->tx_bytes);
868 ncs->hnc_rx_uc_pkts = ntohl(rsp->rx_uc_pkts);
869 ncs->hnc_rx_mc_pkts = ntohl(rsp->rx_mc_pkts);
870 ncs->hnc_rx_bc_pkts = ntohl(rsp->rx_bc_pkts);
871 ncs->hnc_tx_uc_pkts = ntohl(rsp->tx_uc_pkts);
872 ncs->hnc_tx_mc_pkts = ntohl(rsp->tx_mc_pkts);
873 ncs->hnc_tx_bc_pkts = ntohl(rsp->tx_bc_pkts);
874 ncs->hnc_fcs_err = ntohl(rsp->fcs_err);
875 ncs->hnc_align_err = ntohl(rsp->align_err);
876 ncs->hnc_false_carrier = ntohl(rsp->false_carrier);
877 ncs->hnc_runt_pkts = ntohl(rsp->runt_pkts);
878 ncs->hnc_jabber_pkts = ntohl(rsp->jabber_pkts);
879 ncs->hnc_rx_pause_xon = ntohl(rsp->rx_pause_xon);
880 ncs->hnc_rx_pause_xoff = ntohl(rsp->rx_pause_xoff);
881 ncs->hnc_tx_pause_xon = ntohl(rsp->tx_pause_xon);
882 ncs->hnc_tx_pause_xoff = ntohl(rsp->tx_pause_xoff);
883 ncs->hnc_tx_s_collision = ntohl(rsp->tx_s_collision);
884 ncs->hnc_tx_m_collision = ntohl(rsp->tx_m_collision);
885 ncs->hnc_l_collision = ntohl(rsp->l_collision);
886 ncs->hnc_e_collision = ntohl(rsp->e_collision);
887 ncs->hnc_rx_ctl_frames = ntohl(rsp->rx_ctl_frames);
888 ncs->hnc_rx_64_frames = ntohl(rsp->rx_64_frames);
889 ncs->hnc_rx_127_frames = ntohl(rsp->rx_127_frames);
890 ncs->hnc_rx_255_frames = ntohl(rsp->rx_255_frames);
891 ncs->hnc_rx_511_frames = ntohl(rsp->rx_511_frames);
892 ncs->hnc_rx_1023_frames = ntohl(rsp->rx_1023_frames);
893 ncs->hnc_rx_1522_frames = ntohl(rsp->rx_1522_frames);
894 ncs->hnc_rx_9022_frames = ntohl(rsp->rx_9022_frames);
895 ncs->hnc_tx_64_frames = ntohl(rsp->tx_64_frames);
896 ncs->hnc_tx_127_frames = ntohl(rsp->tx_127_frames);
897 ncs->hnc_tx_255_frames = ntohl(rsp->tx_255_frames);
898 ncs->hnc_tx_511_frames = ntohl(rsp->tx_511_frames);
899 ncs->hnc_tx_1023_frames = ntohl(rsp->tx_1023_frames);
900 ncs->hnc_tx_1522_frames = ntohl(rsp->tx_1522_frames);
901 ncs->hnc_tx_9022_frames = ntohl(rsp->tx_9022_frames);
902 ncs->hnc_rx_valid_bytes = ntohl(rsp->rx_valid_bytes);
903 ncs->hnc_rx_runt_pkts = ntohl(rsp->rx_runt_pkts);
904 ncs->hnc_rx_jabber_pkts = ntohl(rsp->rx_jabber_pkts);
909 static int ncsi_rsp_handler_gns(struct ncsi_request *nr)
911 struct ncsi_rsp_gns_pkt *rsp;
912 struct ncsi_dev_priv *ndp = nr->ndp;
913 struct ncsi_channel *nc;
914 struct ncsi_channel_stats *ncs;
916 /* Find the channel */
917 rsp = (struct ncsi_rsp_gns_pkt *)skb_network_header(nr->rsp);
918 ncsi_find_package_and_channel(ndp, rsp->rsp.common.channel,
923 /* Update HNC's statistics */
925 ncs->ncsi_rx_cmds = ntohl(rsp->rx_cmds);
926 ncs->ncsi_dropped_cmds = ntohl(rsp->dropped_cmds);
927 ncs->ncsi_cmd_type_errs = ntohl(rsp->cmd_type_errs);
928 ncs->ncsi_cmd_csum_errs = ntohl(rsp->cmd_csum_errs);
929 ncs->ncsi_rx_pkts = ntohl(rsp->rx_pkts);
930 ncs->ncsi_tx_pkts = ntohl(rsp->tx_pkts);
931 ncs->ncsi_tx_aen_pkts = ntohl(rsp->tx_aen_pkts);
936 static int ncsi_rsp_handler_gnpts(struct ncsi_request *nr)
938 struct ncsi_rsp_gnpts_pkt *rsp;
939 struct ncsi_dev_priv *ndp = nr->ndp;
940 struct ncsi_channel *nc;
941 struct ncsi_channel_stats *ncs;
943 /* Find the channel */
944 rsp = (struct ncsi_rsp_gnpts_pkt *)skb_network_header(nr->rsp);
945 ncsi_find_package_and_channel(ndp, rsp->rsp.common.channel,
950 /* Update HNC's statistics */
952 ncs->pt_tx_pkts = ntohl(rsp->tx_pkts);
953 ncs->pt_tx_dropped = ntohl(rsp->tx_dropped);
954 ncs->pt_tx_channel_err = ntohl(rsp->tx_channel_err);
955 ncs->pt_tx_us_err = ntohl(rsp->tx_us_err);
956 ncs->pt_rx_pkts = ntohl(rsp->rx_pkts);
957 ncs->pt_rx_dropped = ntohl(rsp->rx_dropped);
958 ncs->pt_rx_channel_err = ntohl(rsp->rx_channel_err);
959 ncs->pt_rx_us_err = ntohl(rsp->rx_us_err);
960 ncs->pt_rx_os_err = ntohl(rsp->rx_os_err);
965 static int ncsi_rsp_handler_gps(struct ncsi_request *nr)
967 struct ncsi_rsp_gps_pkt *rsp;
968 struct ncsi_dev_priv *ndp = nr->ndp;
969 struct ncsi_package *np;
971 /* Find the package */
972 rsp = (struct ncsi_rsp_gps_pkt *)skb_network_header(nr->rsp);
973 ncsi_find_package_and_channel(ndp, rsp->rsp.common.channel,
981 static int ncsi_rsp_handler_gpuuid(struct ncsi_request *nr)
983 struct ncsi_rsp_gpuuid_pkt *rsp;
984 struct ncsi_dev_priv *ndp = nr->ndp;
985 struct ncsi_package *np;
987 /* Find the package */
988 rsp = (struct ncsi_rsp_gpuuid_pkt *)skb_network_header(nr->rsp);
989 ncsi_find_package_and_channel(ndp, rsp->rsp.common.channel,
994 memcpy(np->uuid, rsp->uuid, sizeof(rsp->uuid));
999 static int ncsi_rsp_handler_netlink(struct ncsi_request *nr)
1001 struct ncsi_dev_priv *ndp = nr->ndp;
1002 struct ncsi_rsp_pkt *rsp;
1003 struct ncsi_package *np;
1004 struct ncsi_channel *nc;
1007 /* Find the package */
1008 rsp = (struct ncsi_rsp_pkt *)skb_network_header(nr->rsp);
1009 ncsi_find_package_and_channel(ndp, rsp->rsp.common.channel,
1014 ret = ncsi_send_netlink_rsp(nr, np, nc);
1019 static struct ncsi_rsp_handler {
1022 int (*handler)(struct ncsi_request *nr);
1023 } ncsi_rsp_handlers[] = {
1024 { NCSI_PKT_RSP_CIS, 4, ncsi_rsp_handler_cis },
1025 { NCSI_PKT_RSP_SP, 4, ncsi_rsp_handler_sp },
1026 { NCSI_PKT_RSP_DP, 4, ncsi_rsp_handler_dp },
1027 { NCSI_PKT_RSP_EC, 4, ncsi_rsp_handler_ec },
1028 { NCSI_PKT_RSP_DC, 4, ncsi_rsp_handler_dc },
1029 { NCSI_PKT_RSP_RC, 4, ncsi_rsp_handler_rc },
1030 { NCSI_PKT_RSP_ECNT, 4, ncsi_rsp_handler_ecnt },
1031 { NCSI_PKT_RSP_DCNT, 4, ncsi_rsp_handler_dcnt },
1032 { NCSI_PKT_RSP_AE, 4, ncsi_rsp_handler_ae },
1033 { NCSI_PKT_RSP_SL, 4, ncsi_rsp_handler_sl },
1034 { NCSI_PKT_RSP_GLS, 16, ncsi_rsp_handler_gls },
1035 { NCSI_PKT_RSP_SVF, 4, ncsi_rsp_handler_svf },
1036 { NCSI_PKT_RSP_EV, 4, ncsi_rsp_handler_ev },
1037 { NCSI_PKT_RSP_DV, 4, ncsi_rsp_handler_dv },
1038 { NCSI_PKT_RSP_SMA, 4, ncsi_rsp_handler_sma },
1039 { NCSI_PKT_RSP_EBF, 4, ncsi_rsp_handler_ebf },
1040 { NCSI_PKT_RSP_DBF, 4, ncsi_rsp_handler_dbf },
1041 { NCSI_PKT_RSP_EGMF, 4, ncsi_rsp_handler_egmf },
1042 { NCSI_PKT_RSP_DGMF, 4, ncsi_rsp_handler_dgmf },
1043 { NCSI_PKT_RSP_SNFC, 4, ncsi_rsp_handler_snfc },
1044 { NCSI_PKT_RSP_GVI, 40, ncsi_rsp_handler_gvi },
1045 { NCSI_PKT_RSP_GC, 32, ncsi_rsp_handler_gc },
1046 { NCSI_PKT_RSP_GP, -1, ncsi_rsp_handler_gp },
1047 { NCSI_PKT_RSP_GCPS, 172, ncsi_rsp_handler_gcps },
1048 { NCSI_PKT_RSP_GNS, 172, ncsi_rsp_handler_gns },
1049 { NCSI_PKT_RSP_GNPTS, 172, ncsi_rsp_handler_gnpts },
1050 { NCSI_PKT_RSP_GPS, 8, ncsi_rsp_handler_gps },
1051 { NCSI_PKT_RSP_OEM, -1, ncsi_rsp_handler_oem },
1052 { NCSI_PKT_RSP_PLDM, 0, NULL },
1053 { NCSI_PKT_RSP_GPUUID, 20, ncsi_rsp_handler_gpuuid }
1056 int ncsi_rcv_rsp(struct sk_buff *skb, struct net_device *dev,
1057 struct packet_type *pt, struct net_device *orig_dev)
1059 struct ncsi_rsp_handler *nrh = NULL;
1060 struct ncsi_dev *nd;
1061 struct ncsi_dev_priv *ndp;
1062 struct ncsi_request *nr;
1063 struct ncsi_pkt_hdr *hdr;
1064 unsigned long flags;
1065 int payload, i, ret;
1067 /* Find the NCSI device */
1068 nd = ncsi_find_dev(dev);
1069 ndp = nd ? TO_NCSI_DEV_PRIV(nd) : NULL;
1073 /* Check if it is AEN packet */
1074 hdr = (struct ncsi_pkt_hdr *)skb_network_header(skb);
1075 if (hdr->type == NCSI_PKT_AEN)
1076 return ncsi_aen_handler(ndp, skb);
1078 /* Find the handler */
1079 for (i = 0; i < ARRAY_SIZE(ncsi_rsp_handlers); i++) {
1080 if (ncsi_rsp_handlers[i].type == hdr->type) {
1081 if (ncsi_rsp_handlers[i].handler)
1082 nrh = &ncsi_rsp_handlers[i];
1091 netdev_err(nd->dev, "Received unrecognized packet (0x%x)\n",
1096 /* Associate with the request */
1097 spin_lock_irqsave(&ndp->lock, flags);
1098 nr = &ndp->requests[hdr->id];
1100 spin_unlock_irqrestore(&ndp->lock, flags);
1106 spin_unlock_irqrestore(&ndp->lock, flags);
1111 /* Validate the packet */
1112 spin_unlock_irqrestore(&ndp->lock, flags);
1113 payload = nrh->payload;
1115 payload = ntohs(hdr->length);
1116 ret = ncsi_validate_rsp_pkt(nr, payload);
1118 netdev_warn(ndp->ndev.dev,
1119 "NCSI: 'bad' packet ignored for type 0x%x\n",
1122 if (nr->flags == NCSI_REQ_FLAG_NETLINK_DRIVEN) {
1126 ncsi_send_netlink_err(ndp->ndev.dev,
1135 /* Process the packet */
1136 ret = nrh->handler(nr);
1138 netdev_err(ndp->ndev.dev,
1139 "NCSI: Handler for packet type 0x%x returned %d\n",
1143 if (nr->flags == NCSI_REQ_FLAG_NETLINK_DRIVEN) {
1144 ret = ncsi_rsp_handler_netlink(nr);
1146 netdev_err(ndp->ndev.dev,
1147 "NCSI: Netlink handler for packet type 0x%x returned %d\n",
1153 ncsi_free_request(nr);