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 */ 25 static 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 35 static 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(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((unsigned char *)h, 77 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 89 static 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(nr->rsp); 98 ncsi_find_package_and_channel(ndp, rsp->rsp.common.channel, &np, &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 110 static 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(nr->rsp); 121 ncsi_find_package_and_channel(ndp, rsp->rsp.common.channel, 122 &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 136 static 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(nr->rsp); 146 ncsi_find_package_and_channel(ndp, rsp->rsp.common.channel, 147 &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(&nc->lock, flags); 156 } 157 158 return 0; 159 } 160 161 static 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(nr->rsp); 170 ncsi_find_package_and_channel(ndp, rsp->rsp.common.channel, 171 NULL, &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 183 static 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, 4); 192 if (ret) 193 return ret; 194 195 /* Find the package and channel */ 196 rsp = (struct ncsi_rsp_pkt *)skb_network_header(nr->rsp); 197 ncsi_find_package_and_channel(ndp, rsp->rsp.common.channel, 198 NULL, &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 210 static 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(nr->rsp); 219 ncsi_find_package_and_channel(ndp, rsp->rsp.common.channel, 220 NULL, &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(&nc->lock, flags); 228 229 return 0; 230 } 231 232 static 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(nr->rsp); 241 ncsi_find_package_and_channel(ndp, rsp->rsp.common.channel, 242 NULL, &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 254 static 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(nr->rsp); 263 ncsi_find_package_and_channel(ndp, rsp->rsp.common.channel, 264 NULL, &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 276 static 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(nr->rsp); 286 ncsi_find_package_and_channel(ndp, rsp->rsp.common.channel, 287 NULL, &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(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 305 static 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(nr->rsp); 315 ncsi_find_package_and_channel(ndp, rsp->rsp.common.channel, 316 NULL, &nc); 317 if (!nc) 318 return -ENODEV; 319 320 cmd = (struct ncsi_cmd_sl_pkt *)skb_network_header(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 328 static 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(nr->rsp); 338 ncsi_find_package_and_channel(ndp, rsp->rsp.common.channel, 339 NULL, &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(&nc->lock, flags); 355 356 return 0; 357 } 358 359 static 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(nr->rsp); 371 ncsi_find_package_and_channel(ndp, rsp->rsp.common.channel, 372 NULL, &nc); 373 if (!nc) 374 return -ENODEV; 375 376 cmd = (struct ncsi_cmd_svf_pkt *)skb_network_header(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(cmd->index - 1, bitmap)) 386 ncf->vids[cmd->index - 1] = 0; 387 } else { 388 set_bit(cmd->index - 1, bitmap); 389 ncf->vids[cmd->index - 1] = ntohs(cmd->vlan); 390 } 391 spin_unlock_irqrestore(&nc->lock, flags); 392 393 return 0; 394 } 395 396 static 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(nr->rsp); 406 ncsi_find_package_and_channel(ndp, rsp->rsp.common.channel, 407 NULL, &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(nr->cmd); 418 ncm->enable = 1; 419 ncm->data[0] = ntohl((__force __be32)cmd->mode); 420 421 return 0; 422 } 423 424 static 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(nr->rsp); 433 ncsi_find_package_and_channel(ndp, rsp->rsp.common.channel, 434 NULL, &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 448 static 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(nr->rsp); 463 ncsi_find_package_and_channel(ndp, rsp->rsp.common.channel, 464 NULL, &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(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(cmd->index - 1, bitmap); 484 memcpy(&ncf->addrs[index], cmd->mac, ETH_ALEN); 485 } else { 486 clear_bit(cmd->index - 1, bitmap); 487 eth_zero_addr(&ncf->addrs[index]); 488 } 489 spin_unlock_irqrestore(&nc->lock, flags); 490 491 return 0; 492 } 493 494 static 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(nr->rsp); 504 ncsi_find_package_and_channel(ndp, rsp->rsp.common.channel, NULL, &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(nr->cmd); 515 ncm->enable = 1; 516 ncm->data[0] = ntohl(cmd->mode); 517 518 return 0; 519 } 520 521 static 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(nr->rsp); 529 ncsi_find_package_and_channel(ndp, rsp->rsp.common.channel, 530 NULL, &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 546 static 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(nr->rsp); 556 ncsi_find_package_and_channel(ndp, rsp->rsp.common.channel, 557 NULL, &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(nr->cmd); 568 ncm->enable = 1; 569 ncm->data[0] = ntohl(cmd->mode); 570 571 return 0; 572 } 573 574 static 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(nr->rsp); 582 ncsi_find_package_and_channel(ndp, rsp->rsp.common.channel, 583 NULL, &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 599 static 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(nr->rsp); 609 ncsi_find_package_and_channel(ndp, rsp->rsp.common.channel, 610 NULL, &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(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 */ 628 static 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(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((u8 *)saddr.sa_data); 652 if (!is_valid_ether_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(ndev, &saddr, NULL); 660 rtnl_unlock(); 661 if (ret < 0) 662 netdev_warn(ndev, "NCSI: 'Writing mac address to device failed\n"); 663 664 return ret; 665 } 666 667 /* Response handler for Mellanox card */ 668 static 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(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 */ 684 static 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(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 */ 699 static 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(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 714 static 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 */ 724 static 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(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(nr->ndp->ndev.dev, "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 756 static 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(nr->rsp); 766 ncsi_find_package_and_channel(ndp, rsp->rsp.common.channel, 767 NULL, &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(rsp->major); 780 ncv->minor = decode_bcd_u8(rsp->minor); 781 ncv->update = decode_bcd_u8(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 793 static 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 struct ncsi_package *np; 799 size_t size; 800 801 /* Find the channel */ 802 rsp = (struct ncsi_rsp_gc_pkt *)skb_network_header(nr->rsp); 803 ncsi_find_package_and_channel(ndp, rsp->rsp.common.channel, 804 &np, &nc); 805 if (!nc) 806 return -ENODEV; 807 808 /* Update channel's capabilities */ 809 nc->caps[NCSI_CAP_GENERIC].cap = ntohl(rsp->cap) & 810 NCSI_CAP_GENERIC_MASK; 811 nc->caps[NCSI_CAP_BC].cap = ntohl(rsp->bc_cap) & 812 NCSI_CAP_BC_MASK; 813 nc->caps[NCSI_CAP_MC].cap = ntohl(rsp->mc_cap) & 814 NCSI_CAP_MC_MASK; 815 nc->caps[NCSI_CAP_BUFFER].cap = ntohl(rsp->buf_cap); 816 nc->caps[NCSI_CAP_AEN].cap = ntohl(rsp->aen_cap) & 817 NCSI_CAP_AEN_MASK; 818 nc->caps[NCSI_CAP_VLAN].cap = rsp->vlan_mode & 819 NCSI_CAP_VLAN_MASK; 820 821 size = (rsp->uc_cnt + rsp->mc_cnt + rsp->mixed_cnt) * ETH_ALEN; 822 nc->mac_filter.addrs = kzalloc(size, GFP_ATOMIC); 823 if (!nc->mac_filter.addrs) 824 return -ENOMEM; 825 nc->mac_filter.n_uc = rsp->uc_cnt; 826 nc->mac_filter.n_mc = rsp->mc_cnt; 827 nc->mac_filter.n_mixed = rsp->mixed_cnt; 828 829 nc->vlan_filter.vids = kcalloc(rsp->vlan_cnt, 830 sizeof(*nc->vlan_filter.vids), 831 GFP_ATOMIC); 832 if (!nc->vlan_filter.vids) 833 return -ENOMEM; 834 /* Set VLAN filters active so they are cleared in the first 835 * configuration state 836 */ 837 nc->vlan_filter.bitmap = U64_MAX; 838 nc->vlan_filter.n_vids = rsp->vlan_cnt; 839 np->ndp->channel_count = rsp->channel_cnt; 840 841 return 0; 842 } 843 844 static int ncsi_rsp_handler_gp(struct ncsi_request *nr) 845 { 846 struct ncsi_channel_vlan_filter *ncvf; 847 struct ncsi_channel_mac_filter *ncmf; 848 struct ncsi_dev_priv *ndp = nr->ndp; 849 struct ncsi_rsp_gp_pkt *rsp; 850 struct ncsi_channel *nc; 851 unsigned short enable; 852 unsigned char *pdata; 853 unsigned long flags; 854 void *bitmap; 855 int i; 856 857 /* Find the channel */ 858 rsp = (struct ncsi_rsp_gp_pkt *)skb_network_header(nr->rsp); 859 ncsi_find_package_and_channel(ndp, rsp->rsp.common.channel, 860 NULL, &nc); 861 if (!nc) 862 return -ENODEV; 863 864 /* Modes with explicit enabled indications */ 865 if (ntohl(rsp->valid_modes) & 0x1) { /* BC filter mode */ 866 nc->modes[NCSI_MODE_BC].enable = 1; 867 nc->modes[NCSI_MODE_BC].data[0] = ntohl(rsp->bc_mode); 868 } 869 if (ntohl(rsp->valid_modes) & 0x2) /* Channel enabled */ 870 nc->modes[NCSI_MODE_ENABLE].enable = 1; 871 if (ntohl(rsp->valid_modes) & 0x4) /* Channel Tx enabled */ 872 nc->modes[NCSI_MODE_TX_ENABLE].enable = 1; 873 if (ntohl(rsp->valid_modes) & 0x8) /* MC filter mode */ 874 nc->modes[NCSI_MODE_MC].enable = 1; 875 876 /* Modes without explicit enabled indications */ 877 nc->modes[NCSI_MODE_LINK].enable = 1; 878 nc->modes[NCSI_MODE_LINK].data[0] = ntohl(rsp->link_mode); 879 nc->modes[NCSI_MODE_VLAN].enable = 1; 880 nc->modes[NCSI_MODE_VLAN].data[0] = rsp->vlan_mode; 881 nc->modes[NCSI_MODE_FC].enable = 1; 882 nc->modes[NCSI_MODE_FC].data[0] = rsp->fc_mode; 883 nc->modes[NCSI_MODE_AEN].enable = 1; 884 nc->modes[NCSI_MODE_AEN].data[0] = ntohl(rsp->aen_mode); 885 886 /* MAC addresses filter table */ 887 pdata = (unsigned char *)rsp + 48; 888 enable = rsp->mac_enable; 889 ncmf = &nc->mac_filter; 890 spin_lock_irqsave(&nc->lock, flags); 891 bitmap = &ncmf->bitmap; 892 for (i = 0; i < rsp->mac_cnt; i++, pdata += 6) { 893 if (!(enable & (0x1 << i))) 894 clear_bit(i, bitmap); 895 else 896 set_bit(i, bitmap); 897 898 memcpy(&ncmf->addrs[i * ETH_ALEN], pdata, ETH_ALEN); 899 } 900 spin_unlock_irqrestore(&nc->lock, flags); 901 902 /* VLAN filter table */ 903 enable = ntohs(rsp->vlan_enable); 904 ncvf = &nc->vlan_filter; 905 bitmap = &ncvf->bitmap; 906 spin_lock_irqsave(&nc->lock, flags); 907 for (i = 0; i < rsp->vlan_cnt; i++, pdata += 2) { 908 if (!(enable & (0x1 << i))) 909 clear_bit(i, bitmap); 910 else 911 set_bit(i, bitmap); 912 913 ncvf->vids[i] = ntohs(*(__be16 *)pdata); 914 } 915 spin_unlock_irqrestore(&nc->lock, flags); 916 917 return 0; 918 } 919 920 static int ncsi_rsp_handler_gcps(struct ncsi_request *nr) 921 { 922 struct ncsi_rsp_gcps_pkt *rsp; 923 struct ncsi_dev_priv *ndp = nr->ndp; 924 struct ncsi_channel *nc; 925 struct ncsi_channel_stats *ncs; 926 927 /* Find the channel */ 928 rsp = (struct ncsi_rsp_gcps_pkt *)skb_network_header(nr->rsp); 929 ncsi_find_package_and_channel(ndp, rsp->rsp.common.channel, 930 NULL, &nc); 931 if (!nc) 932 return -ENODEV; 933 934 /* Update HNC's statistics */ 935 ncs = &nc->stats; 936 ncs->hnc_cnt_hi = ntohl(rsp->cnt_hi); 937 ncs->hnc_cnt_lo = ntohl(rsp->cnt_lo); 938 ncs->hnc_rx_bytes = ntohl(rsp->rx_bytes); 939 ncs->hnc_tx_bytes = ntohl(rsp->tx_bytes); 940 ncs->hnc_rx_uc_pkts = ntohl(rsp->rx_uc_pkts); 941 ncs->hnc_rx_mc_pkts = ntohl(rsp->rx_mc_pkts); 942 ncs->hnc_rx_bc_pkts = ntohl(rsp->rx_bc_pkts); 943 ncs->hnc_tx_uc_pkts = ntohl(rsp->tx_uc_pkts); 944 ncs->hnc_tx_mc_pkts = ntohl(rsp->tx_mc_pkts); 945 ncs->hnc_tx_bc_pkts = ntohl(rsp->tx_bc_pkts); 946 ncs->hnc_fcs_err = ntohl(rsp->fcs_err); 947 ncs->hnc_align_err = ntohl(rsp->align_err); 948 ncs->hnc_false_carrier = ntohl(rsp->false_carrier); 949 ncs->hnc_runt_pkts = ntohl(rsp->runt_pkts); 950 ncs->hnc_jabber_pkts = ntohl(rsp->jabber_pkts); 951 ncs->hnc_rx_pause_xon = ntohl(rsp->rx_pause_xon); 952 ncs->hnc_rx_pause_xoff = ntohl(rsp->rx_pause_xoff); 953 ncs->hnc_tx_pause_xon = ntohl(rsp->tx_pause_xon); 954 ncs->hnc_tx_pause_xoff = ntohl(rsp->tx_pause_xoff); 955 ncs->hnc_tx_s_collision = ntohl(rsp->tx_s_collision); 956 ncs->hnc_tx_m_collision = ntohl(rsp->tx_m_collision); 957 ncs->hnc_l_collision = ntohl(rsp->l_collision); 958 ncs->hnc_e_collision = ntohl(rsp->e_collision); 959 ncs->hnc_rx_ctl_frames = ntohl(rsp->rx_ctl_frames); 960 ncs->hnc_rx_64_frames = ntohl(rsp->rx_64_frames); 961 ncs->hnc_rx_127_frames = ntohl(rsp->rx_127_frames); 962 ncs->hnc_rx_255_frames = ntohl(rsp->rx_255_frames); 963 ncs->hnc_rx_511_frames = ntohl(rsp->rx_511_frames); 964 ncs->hnc_rx_1023_frames = ntohl(rsp->rx_1023_frames); 965 ncs->hnc_rx_1522_frames = ntohl(rsp->rx_1522_frames); 966 ncs->hnc_rx_9022_frames = ntohl(rsp->rx_9022_frames); 967 ncs->hnc_tx_64_frames = ntohl(rsp->tx_64_frames); 968 ncs->hnc_tx_127_frames = ntohl(rsp->tx_127_frames); 969 ncs->hnc_tx_255_frames = ntohl(rsp->tx_255_frames); 970 ncs->hnc_tx_511_frames = ntohl(rsp->tx_511_frames); 971 ncs->hnc_tx_1023_frames = ntohl(rsp->tx_1023_frames); 972 ncs->hnc_tx_1522_frames = ntohl(rsp->tx_1522_frames); 973 ncs->hnc_tx_9022_frames = ntohl(rsp->tx_9022_frames); 974 ncs->hnc_rx_valid_bytes = ntohl(rsp->rx_valid_bytes); 975 ncs->hnc_rx_runt_pkts = ntohl(rsp->rx_runt_pkts); 976 ncs->hnc_rx_jabber_pkts = ntohl(rsp->rx_jabber_pkts); 977 978 return 0; 979 } 980 981 static int ncsi_rsp_handler_gns(struct ncsi_request *nr) 982 { 983 struct ncsi_rsp_gns_pkt *rsp; 984 struct ncsi_dev_priv *ndp = nr->ndp; 985 struct ncsi_channel *nc; 986 struct ncsi_channel_stats *ncs; 987 988 /* Find the channel */ 989 rsp = (struct ncsi_rsp_gns_pkt *)skb_network_header(nr->rsp); 990 ncsi_find_package_and_channel(ndp, rsp->rsp.common.channel, 991 NULL, &nc); 992 if (!nc) 993 return -ENODEV; 994 995 /* Update HNC's statistics */ 996 ncs = &nc->stats; 997 ncs->ncsi_rx_cmds = ntohl(rsp->rx_cmds); 998 ncs->ncsi_dropped_cmds = ntohl(rsp->dropped_cmds); 999 ncs->ncsi_cmd_type_errs = ntohl(rsp->cmd_type_errs); 1000 ncs->ncsi_cmd_csum_errs = ntohl(rsp->cmd_csum_errs); 1001 ncs->ncsi_rx_pkts = ntohl(rsp->rx_pkts); 1002 ncs->ncsi_tx_pkts = ntohl(rsp->tx_pkts); 1003 ncs->ncsi_tx_aen_pkts = ntohl(rsp->tx_aen_pkts); 1004 1005 return 0; 1006 } 1007 1008 static int ncsi_rsp_handler_gnpts(struct ncsi_request *nr) 1009 { 1010 struct ncsi_rsp_gnpts_pkt *rsp; 1011 struct ncsi_dev_priv *ndp = nr->ndp; 1012 struct ncsi_channel *nc; 1013 struct ncsi_channel_stats *ncs; 1014 1015 /* Find the channel */ 1016 rsp = (struct ncsi_rsp_gnpts_pkt *)skb_network_header(nr->rsp); 1017 ncsi_find_package_and_channel(ndp, rsp->rsp.common.channel, 1018 NULL, &nc); 1019 if (!nc) 1020 return -ENODEV; 1021 1022 /* Update HNC's statistics */ 1023 ncs = &nc->stats; 1024 ncs->pt_tx_pkts = ntohl(rsp->tx_pkts); 1025 ncs->pt_tx_dropped = ntohl(rsp->tx_dropped); 1026 ncs->pt_tx_channel_err = ntohl(rsp->tx_channel_err); 1027 ncs->pt_tx_us_err = ntohl(rsp->tx_us_err); 1028 ncs->pt_rx_pkts = ntohl(rsp->rx_pkts); 1029 ncs->pt_rx_dropped = ntohl(rsp->rx_dropped); 1030 ncs->pt_rx_channel_err = ntohl(rsp->rx_channel_err); 1031 ncs->pt_rx_us_err = ntohl(rsp->rx_us_err); 1032 ncs->pt_rx_os_err = ntohl(rsp->rx_os_err); 1033 1034 return 0; 1035 } 1036 1037 static int ncsi_rsp_handler_gps(struct ncsi_request *nr) 1038 { 1039 struct ncsi_rsp_gps_pkt *rsp; 1040 struct ncsi_dev_priv *ndp = nr->ndp; 1041 struct ncsi_package *np; 1042 1043 /* Find the package */ 1044 rsp = (struct ncsi_rsp_gps_pkt *)skb_network_header(nr->rsp); 1045 ncsi_find_package_and_channel(ndp, rsp->rsp.common.channel, 1046 &np, NULL); 1047 if (!np) 1048 return -ENODEV; 1049 1050 return 0; 1051 } 1052 1053 static int ncsi_rsp_handler_gpuuid(struct ncsi_request *nr) 1054 { 1055 struct ncsi_rsp_gpuuid_pkt *rsp; 1056 struct ncsi_dev_priv *ndp = nr->ndp; 1057 struct ncsi_package *np; 1058 1059 /* Find the package */ 1060 rsp = (struct ncsi_rsp_gpuuid_pkt *)skb_network_header(nr->rsp); 1061 ncsi_find_package_and_channel(ndp, rsp->rsp.common.channel, 1062 &np, NULL); 1063 if (!np) 1064 return -ENODEV; 1065 1066 memcpy(np->uuid, rsp->uuid, sizeof(rsp->uuid)); 1067 1068 return 0; 1069 } 1070 1071 static int ncsi_rsp_handler_pldm(struct ncsi_request *nr) 1072 { 1073 return 0; 1074 } 1075 1076 static int ncsi_rsp_handler_netlink(struct ncsi_request *nr) 1077 { 1078 struct ncsi_dev_priv *ndp = nr->ndp; 1079 struct ncsi_rsp_pkt *rsp; 1080 struct ncsi_package *np; 1081 struct ncsi_channel *nc; 1082 int ret; 1083 1084 /* Find the package */ 1085 rsp = (struct ncsi_rsp_pkt *)skb_network_header(nr->rsp); 1086 ncsi_find_package_and_channel(ndp, rsp->rsp.common.channel, 1087 &np, &nc); 1088 if (!np) 1089 return -ENODEV; 1090 1091 ret = ncsi_send_netlink_rsp(nr, np, nc); 1092 1093 return ret; 1094 } 1095 1096 static int ncsi_rsp_handler_gmcma(struct ncsi_request *nr) 1097 { 1098 struct ncsi_dev_priv *ndp = nr->ndp; 1099 struct net_device *ndev = ndp->ndev.dev; 1100 struct ncsi_rsp_gmcma_pkt *rsp; 1101 struct sockaddr saddr; 1102 int ret = -1; 1103 int i; 1104 1105 rsp = (struct ncsi_rsp_gmcma_pkt *)skb_network_header(nr->rsp); 1106 saddr.sa_family = ndev->type; 1107 ndev->priv_flags |= IFF_LIVE_ADDR_CHANGE; 1108 1109 netdev_info(ndev, "NCSI: Received %d provisioned MAC addresses\n", 1110 rsp->address_count); 1111 for (i = 0; i < rsp->address_count; i++) { 1112 netdev_info(ndev, "NCSI: MAC address %d: %02x:%02x:%02x:%02x:%02x:%02x\n", 1113 i, rsp->addresses[i][0], rsp->addresses[i][1], 1114 rsp->addresses[i][2], rsp->addresses[i][3], 1115 rsp->addresses[i][4], rsp->addresses[i][5]); 1116 } 1117 1118 for (i = 0; i < rsp->address_count; i++) { 1119 memcpy(saddr.sa_data, &rsp->addresses[i], ETH_ALEN); 1120 ret = ndev->netdev_ops->ndo_set_mac_address(ndev, &saddr); 1121 if (ret < 0) { 1122 netdev_warn(ndev, "NCSI: Unable to assign %pM to device\n", 1123 saddr.sa_data); 1124 continue; 1125 } 1126 netdev_warn(ndev, "NCSI: Set MAC address to %pM\n", saddr.sa_data); 1127 break; 1128 } 1129 1130 ndp->gma_flag = ret == 0; 1131 return ret; 1132 } 1133 1134 static struct ncsi_rsp_handler { 1135 unsigned char type; 1136 int payload; 1137 int (*handler)(struct ncsi_request *nr); 1138 } ncsi_rsp_handlers[] = { 1139 { NCSI_PKT_RSP_CIS, 4, ncsi_rsp_handler_cis }, 1140 { NCSI_PKT_RSP_SP, 4, ncsi_rsp_handler_sp }, 1141 { NCSI_PKT_RSP_DP, 4, ncsi_rsp_handler_dp }, 1142 { NCSI_PKT_RSP_EC, 4, ncsi_rsp_handler_ec }, 1143 { NCSI_PKT_RSP_DC, 4, ncsi_rsp_handler_dc }, 1144 { NCSI_PKT_RSP_RC, 4, ncsi_rsp_handler_rc }, 1145 { NCSI_PKT_RSP_ECNT, 4, ncsi_rsp_handler_ecnt }, 1146 { NCSI_PKT_RSP_DCNT, 4, ncsi_rsp_handler_dcnt }, 1147 { NCSI_PKT_RSP_AE, 4, ncsi_rsp_handler_ae }, 1148 { NCSI_PKT_RSP_SL, 4, ncsi_rsp_handler_sl }, 1149 { NCSI_PKT_RSP_GLS, 16, ncsi_rsp_handler_gls }, 1150 { NCSI_PKT_RSP_SVF, 4, ncsi_rsp_handler_svf }, 1151 { NCSI_PKT_RSP_EV, 4, ncsi_rsp_handler_ev }, 1152 { NCSI_PKT_RSP_DV, 4, ncsi_rsp_handler_dv }, 1153 { NCSI_PKT_RSP_SMA, 4, ncsi_rsp_handler_sma }, 1154 { NCSI_PKT_RSP_EBF, 4, ncsi_rsp_handler_ebf }, 1155 { NCSI_PKT_RSP_DBF, 4, ncsi_rsp_handler_dbf }, 1156 { NCSI_PKT_RSP_EGMF, 4, ncsi_rsp_handler_egmf }, 1157 { NCSI_PKT_RSP_DGMF, 4, ncsi_rsp_handler_dgmf }, 1158 { NCSI_PKT_RSP_SNFC, 4, ncsi_rsp_handler_snfc }, 1159 { NCSI_PKT_RSP_GVI, 40, ncsi_rsp_handler_gvi }, 1160 { NCSI_PKT_RSP_GC, 32, ncsi_rsp_handler_gc }, 1161 { NCSI_PKT_RSP_GP, -1, ncsi_rsp_handler_gp }, 1162 { NCSI_PKT_RSP_GCPS, 204, ncsi_rsp_handler_gcps }, 1163 { NCSI_PKT_RSP_GNS, 32, ncsi_rsp_handler_gns }, 1164 { NCSI_PKT_RSP_GNPTS, 48, ncsi_rsp_handler_gnpts }, 1165 { NCSI_PKT_RSP_GPS, 8, ncsi_rsp_handler_gps }, 1166 { NCSI_PKT_RSP_OEM, -1, ncsi_rsp_handler_oem }, 1167 { NCSI_PKT_RSP_PLDM, -1, ncsi_rsp_handler_pldm }, 1168 { NCSI_PKT_RSP_GPUUID, 20, ncsi_rsp_handler_gpuuid }, 1169 { NCSI_PKT_RSP_QPNPR, -1, ncsi_rsp_handler_pldm }, 1170 { NCSI_PKT_RSP_SNPR, -1, ncsi_rsp_handler_pldm }, 1171 { NCSI_PKT_RSP_GMCMA, -1, ncsi_rsp_handler_gmcma }, 1172 }; 1173 1174 int ncsi_rcv_rsp(struct sk_buff *skb, struct net_device *dev, 1175 struct packet_type *pt, struct net_device *orig_dev) 1176 { 1177 struct ncsi_rsp_handler *nrh = NULL; 1178 struct ncsi_dev *nd; 1179 struct ncsi_dev_priv *ndp; 1180 struct ncsi_request *nr; 1181 struct ncsi_pkt_hdr *hdr; 1182 unsigned long flags; 1183 int payload, i, ret; 1184 1185 /* Find the NCSI device */ 1186 nd = ncsi_find_dev(orig_dev); 1187 ndp = nd ? TO_NCSI_DEV_PRIV(nd) : NULL; 1188 if (!ndp) 1189 return -ENODEV; 1190 1191 /* Check if it is AEN packet */ 1192 hdr = (struct ncsi_pkt_hdr *)skb_network_header(skb); 1193 if (hdr->type == NCSI_PKT_AEN) 1194 return ncsi_aen_handler(ndp, skb); 1195 1196 /* Find the handler */ 1197 for (i = 0; i < ARRAY_SIZE(ncsi_rsp_handlers); i++) { 1198 if (ncsi_rsp_handlers[i].type == hdr->type) { 1199 if (ncsi_rsp_handlers[i].handler) 1200 nrh = &ncsi_rsp_handlers[i]; 1201 else 1202 nrh = NULL; 1203 1204 break; 1205 } 1206 } 1207 1208 if (!nrh) { 1209 netdev_err(nd->dev, "Received unrecognized packet (0x%x)\n", 1210 hdr->type); 1211 return -ENOENT; 1212 } 1213 1214 /* Associate with the request */ 1215 spin_lock_irqsave(&ndp->lock, flags); 1216 nr = &ndp->requests[hdr->id]; 1217 if (!nr->used) { 1218 spin_unlock_irqrestore(&ndp->lock, flags); 1219 return -ENODEV; 1220 } 1221 1222 nr->rsp = skb; 1223 if (!nr->enabled) { 1224 spin_unlock_irqrestore(&ndp->lock, flags); 1225 ret = -ENOENT; 1226 goto out; 1227 } 1228 1229 /* Validate the packet */ 1230 spin_unlock_irqrestore(&ndp->lock, flags); 1231 payload = nrh->payload; 1232 if (payload < 0) 1233 payload = ntohs(hdr->length); 1234 ret = ncsi_validate_rsp_pkt(nr, payload); 1235 if (ret) { 1236 netdev_warn(ndp->ndev.dev, 1237 "NCSI: 'bad' packet ignored for type 0x%x\n", 1238 hdr->type); 1239 1240 if (nr->flags == NCSI_REQ_FLAG_NETLINK_DRIVEN) { 1241 if (ret == -EPERM) 1242 goto out_netlink; 1243 else 1244 ncsi_send_netlink_err(ndp->ndev.dev, 1245 nr->snd_seq, 1246 nr->snd_portid, 1247 &nr->nlhdr, 1248 ret); 1249 } 1250 goto out; 1251 } 1252 1253 /* Process the packet */ 1254 ret = nrh->handler(nr); 1255 if (ret) 1256 netdev_err(ndp->ndev.dev, 1257 "NCSI: Handler for packet type 0x%x returned %d\n", 1258 hdr->type, ret); 1259 1260 out_netlink: 1261 if (nr->flags == NCSI_REQ_FLAG_NETLINK_DRIVEN) { 1262 ret = ncsi_rsp_handler_netlink(nr); 1263 if (ret) { 1264 netdev_err(ndp->ndev.dev, 1265 "NCSI: Netlink handler for packet type 0x%x returned %d\n", 1266 hdr->type, ret); 1267 } 1268 } 1269 1270 out: 1271 ncsi_free_request(nr); 1272 return ret; 1273 } 1274