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