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