1 /* 2 * Copyright (C) 2015 Cavium Inc. 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 * 26 * $FreeBSD$ 27 * 28 */ 29 #include "opt_platform.h" 30 31 #include <sys/cdefs.h> 32 __FBSDID("$FreeBSD$"); 33 34 #include <sys/param.h> 35 #include <sys/systm.h> 36 #include <sys/bitset.h> 37 #include <sys/bitstring.h> 38 #include <sys/bus.h> 39 #include <sys/endian.h> 40 #include <sys/kernel.h> 41 #include <sys/malloc.h> 42 #include <sys/module.h> 43 #include <sys/rman.h> 44 #include <sys/pciio.h> 45 #include <sys/pcpu.h> 46 #include <sys/proc.h> 47 #include <sys/socket.h> 48 #include <sys/sockio.h> 49 #include <sys/cpuset.h> 50 #include <sys/lock.h> 51 #include <sys/mutex.h> 52 53 #include <net/ethernet.h> 54 #include <net/if.h> 55 #include <net/if_media.h> 56 57 #include <machine/bus.h> 58 59 #include <dev/pci/pcireg.h> 60 #include <dev/pci/pcivar.h> 61 62 #include "thunder_bgx.h" 63 #include "thunder_bgx_var.h" 64 #include "nic_reg.h" 65 #include "nic.h" 66 67 #include "lmac_if.h" 68 69 #define THUNDER_BGX_DEVSTR "ThunderX BGX Ethernet I/O Interface" 70 71 static MALLOC_DEFINE(M_BGX, "thunder_bgx", "ThunderX BGX dynamic memory"); 72 73 #define BGX_NODE_ID_MASK 0x1 74 #define BGX_NODE_ID_SHIFT 24 75 76 #define DRV_NAME "thunder-BGX" 77 #define DRV_VERSION "1.0" 78 79 static int bgx_init_phy(struct bgx *); 80 81 static struct bgx *bgx_vnic[MAX_BGX_THUNDER]; 82 static int lmac_count __unused; /* Total no of LMACs in system */ 83 84 static int bgx_xaui_check_link(struct lmac *lmac); 85 static void bgx_get_qlm_mode(struct bgx *); 86 static void bgx_init_hw(struct bgx *); 87 static int bgx_lmac_enable(struct bgx *, uint8_t); 88 static void bgx_lmac_disable(struct bgx *, uint8_t); 89 90 static int thunder_bgx_probe(device_t); 91 static int thunder_bgx_attach(device_t); 92 static int thunder_bgx_detach(device_t); 93 94 static device_method_t thunder_bgx_methods[] = { 95 /* Device interface */ 96 DEVMETHOD(device_probe, thunder_bgx_probe), 97 DEVMETHOD(device_attach, thunder_bgx_attach), 98 DEVMETHOD(device_detach, thunder_bgx_detach), 99 100 DEVMETHOD_END, 101 }; 102 103 static driver_t thunder_bgx_driver = { 104 "bgx", 105 thunder_bgx_methods, 106 sizeof(struct lmac), 107 }; 108 109 static devclass_t thunder_bgx_devclass; 110 111 DRIVER_MODULE(thunder_bgx, pci, thunder_bgx_driver, thunder_bgx_devclass, 0, 0); 112 MODULE_DEPEND(thunder_bgx, pci, 1, 1, 1); 113 MODULE_DEPEND(thunder_bgx, ether, 1, 1, 1); 114 MODULE_DEPEND(thunder_bgx, octeon_mdio, 1, 1, 1); 115 116 static int 117 thunder_bgx_probe(device_t dev) 118 { 119 uint16_t vendor_id; 120 uint16_t device_id; 121 122 vendor_id = pci_get_vendor(dev); 123 device_id = pci_get_device(dev); 124 125 if (vendor_id == PCI_VENDOR_ID_CAVIUM && 126 device_id == PCI_DEVICE_ID_THUNDER_BGX) { 127 device_set_desc(dev, THUNDER_BGX_DEVSTR); 128 return (BUS_PROBE_DEFAULT); 129 } 130 131 return (ENXIO); 132 } 133 134 static int 135 thunder_bgx_attach(device_t dev) 136 { 137 struct bgx *bgx; 138 uint8_t lmac; 139 int err; 140 int rid; 141 142 bgx = malloc(sizeof(*bgx), M_BGX, (M_WAITOK | M_ZERO)); 143 bgx->dev = dev; 144 /* Enable bus mastering */ 145 pci_enable_busmaster(dev); 146 /* Allocate resources - configuration registers */ 147 rid = PCIR_BAR(PCI_CFG_REG_BAR_NUM); 148 bgx->reg_base = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &rid, 149 RF_ACTIVE); 150 if (bgx->reg_base == NULL) { 151 device_printf(dev, "Could not allocate CSR memory space\n"); 152 err = ENXIO; 153 goto err_disable_device; 154 } 155 156 bgx->bgx_id = (rman_get_start(bgx->reg_base) >> BGX_NODE_ID_SHIFT) & 157 BGX_NODE_ID_MASK; 158 bgx->bgx_id += nic_get_node_id(bgx->reg_base) * MAX_BGX_PER_CN88XX; 159 160 bgx_vnic[bgx->bgx_id] = bgx; 161 bgx_get_qlm_mode(bgx); 162 163 err = bgx_init_phy(bgx); 164 if (err != 0) 165 goto err_free_res; 166 167 bgx_init_hw(bgx); 168 169 /* Enable all LMACs */ 170 for (lmac = 0; lmac < bgx->lmac_count; lmac++) { 171 err = bgx_lmac_enable(bgx, lmac); 172 if (err) { 173 device_printf(dev, "BGX%d failed to enable lmac%d\n", 174 bgx->bgx_id, lmac); 175 goto err_free_res; 176 } 177 } 178 179 return (0); 180 181 err_free_res: 182 bgx_vnic[bgx->bgx_id] = NULL; 183 bus_release_resource(dev, SYS_RES_MEMORY, 184 rman_get_rid(bgx->reg_base), bgx->reg_base); 185 err_disable_device: 186 free(bgx, M_BGX); 187 pci_disable_busmaster(dev); 188 189 return (err); 190 } 191 192 static int 193 thunder_bgx_detach(device_t dev) 194 { 195 struct lmac *lmac; 196 struct bgx *bgx; 197 uint8_t lmacid; 198 199 lmac = device_get_softc(dev); 200 bgx = lmac->bgx; 201 /* Disable all LMACs */ 202 for (lmacid = 0; lmacid < bgx->lmac_count; lmacid++) 203 bgx_lmac_disable(bgx, lmacid); 204 205 return (0); 206 } 207 208 /* Register read/write APIs */ 209 static uint64_t 210 bgx_reg_read(struct bgx *bgx, uint8_t lmac, uint64_t offset) 211 { 212 bus_space_handle_t addr; 213 214 addr = ((uint32_t)lmac << 20) + offset; 215 216 return (bus_read_8(bgx->reg_base, addr)); 217 } 218 219 static void 220 bgx_reg_write(struct bgx *bgx, uint8_t lmac, uint64_t offset, uint64_t val) 221 { 222 bus_space_handle_t addr; 223 224 addr = ((uint32_t)lmac << 20) + offset; 225 226 bus_write_8(bgx->reg_base, addr, val); 227 } 228 229 static void 230 bgx_reg_modify(struct bgx *bgx, uint8_t lmac, uint64_t offset, uint64_t val) 231 { 232 bus_space_handle_t addr; 233 234 addr = ((uint32_t)lmac << 20) + offset; 235 236 bus_write_8(bgx->reg_base, addr, val | bus_read_8(bgx->reg_base, addr)); 237 } 238 239 static int 240 bgx_poll_reg(struct bgx *bgx, uint8_t lmac, uint64_t reg, uint64_t mask, 241 boolean_t zero) 242 { 243 int timeout = 100; 244 uint64_t reg_val; 245 246 while (timeout) { 247 reg_val = bgx_reg_read(bgx, lmac, reg); 248 if (zero && !(reg_val & mask)) 249 return (0); 250 if (!zero && (reg_val & mask)) 251 return (0); 252 253 DELAY(1000); 254 timeout--; 255 } 256 return (ETIMEDOUT); 257 } 258 259 /* Return number of BGX present in HW */ 260 u_int 261 bgx_get_map(int node) 262 { 263 int i; 264 u_int map = 0; 265 266 for (i = 0; i < MAX_BGX_PER_CN88XX; i++) { 267 if (bgx_vnic[(node * MAX_BGX_PER_CN88XX) + i]) 268 map |= (1 << i); 269 } 270 271 return (map); 272 } 273 274 /* Return number of LMAC configured for this BGX */ 275 int 276 bgx_get_lmac_count(int node, int bgx_idx) 277 { 278 struct bgx *bgx; 279 280 bgx = bgx_vnic[(node * MAX_BGX_PER_CN88XX) + bgx_idx]; 281 if (bgx != NULL) 282 return (bgx->lmac_count); 283 284 return (0); 285 } 286 287 /* Returns the current link status of LMAC */ 288 void 289 bgx_get_lmac_link_state(int node, int bgx_idx, int lmacid, void *status) 290 { 291 struct bgx_link_status *link = (struct bgx_link_status *)status; 292 struct bgx *bgx; 293 struct lmac *lmac; 294 295 bgx = bgx_vnic[(node * MAX_BGX_PER_CN88XX) + bgx_idx]; 296 if (bgx == NULL) 297 return; 298 299 lmac = &bgx->lmac[lmacid]; 300 link->link_up = lmac->link_up; 301 link->duplex = lmac->last_duplex; 302 link->speed = lmac->last_speed; 303 } 304 305 const uint8_t 306 *bgx_get_lmac_mac(int node, int bgx_idx, int lmacid) 307 { 308 struct bgx *bgx = bgx_vnic[(node * MAX_BGX_PER_CN88XX) + bgx_idx]; 309 310 if (bgx != NULL) 311 return (bgx->lmac[lmacid].mac); 312 313 return (NULL); 314 } 315 316 void 317 bgx_set_lmac_mac(int node, int bgx_idx, int lmacid, const uint8_t *mac) 318 { 319 struct bgx *bgx = bgx_vnic[(node * MAX_BGX_PER_CN88XX) + bgx_idx]; 320 321 if (bgx == NULL) 322 return; 323 324 memcpy(bgx->lmac[lmacid].mac, mac, ETHER_ADDR_LEN); 325 } 326 327 static void 328 bgx_sgmii_change_link_state(struct lmac *lmac) 329 { 330 struct bgx *bgx = lmac->bgx; 331 uint64_t cmr_cfg; 332 uint64_t port_cfg = 0; 333 uint64_t misc_ctl = 0; 334 335 cmr_cfg = bgx_reg_read(bgx, lmac->lmacid, BGX_CMRX_CFG); 336 cmr_cfg &= ~CMR_EN; 337 bgx_reg_write(bgx, lmac->lmacid, BGX_CMRX_CFG, cmr_cfg); 338 339 port_cfg = bgx_reg_read(bgx, lmac->lmacid, BGX_GMP_GMI_PRTX_CFG); 340 misc_ctl = bgx_reg_read(bgx, lmac->lmacid, BGX_GMP_PCS_MISCX_CTL); 341 342 if (lmac->link_up) { 343 misc_ctl &= ~PCS_MISC_CTL_GMX_ENO; 344 port_cfg &= ~GMI_PORT_CFG_DUPLEX; 345 port_cfg |= (lmac->last_duplex << 2); 346 } else { 347 misc_ctl |= PCS_MISC_CTL_GMX_ENO; 348 } 349 350 switch (lmac->last_speed) { 351 case 10: 352 port_cfg &= ~GMI_PORT_CFG_SPEED; /* speed 0 */ 353 port_cfg |= GMI_PORT_CFG_SPEED_MSB; /* speed_msb 1 */ 354 port_cfg &= ~GMI_PORT_CFG_SLOT_TIME; /* slottime 0 */ 355 misc_ctl &= ~PCS_MISC_CTL_SAMP_PT_MASK; 356 misc_ctl |= 50; /* samp_pt */ 357 bgx_reg_write(bgx, lmac->lmacid, BGX_GMP_GMI_TXX_SLOT, 64); 358 bgx_reg_write(bgx, lmac->lmacid, BGX_GMP_GMI_TXX_BURST, 0); 359 break; 360 case 100: 361 port_cfg &= ~GMI_PORT_CFG_SPEED; /* speed 0 */ 362 port_cfg &= ~GMI_PORT_CFG_SPEED_MSB; /* speed_msb 0 */ 363 port_cfg &= ~GMI_PORT_CFG_SLOT_TIME; /* slottime 0 */ 364 misc_ctl &= ~PCS_MISC_CTL_SAMP_PT_MASK; 365 misc_ctl |= 5; /* samp_pt */ 366 bgx_reg_write(bgx, lmac->lmacid, BGX_GMP_GMI_TXX_SLOT, 64); 367 bgx_reg_write(bgx, lmac->lmacid, BGX_GMP_GMI_TXX_BURST, 0); 368 break; 369 case 1000: 370 port_cfg |= GMI_PORT_CFG_SPEED; /* speed 1 */ 371 port_cfg &= ~GMI_PORT_CFG_SPEED_MSB; /* speed_msb 0 */ 372 port_cfg |= GMI_PORT_CFG_SLOT_TIME; /* slottime 1 */ 373 misc_ctl &= ~PCS_MISC_CTL_SAMP_PT_MASK; 374 misc_ctl |= 1; /* samp_pt */ 375 bgx_reg_write(bgx, lmac->lmacid, BGX_GMP_GMI_TXX_SLOT, 512); 376 if (lmac->last_duplex) 377 bgx_reg_write(bgx, lmac->lmacid, 378 BGX_GMP_GMI_TXX_BURST, 0); 379 else 380 bgx_reg_write(bgx, lmac->lmacid, 381 BGX_GMP_GMI_TXX_BURST, 8192); 382 break; 383 default: 384 break; 385 } 386 bgx_reg_write(bgx, lmac->lmacid, BGX_GMP_PCS_MISCX_CTL, misc_ctl); 387 bgx_reg_write(bgx, lmac->lmacid, BGX_GMP_GMI_PRTX_CFG, port_cfg); 388 389 port_cfg = bgx_reg_read(bgx, lmac->lmacid, BGX_GMP_GMI_PRTX_CFG); 390 391 /* renable lmac */ 392 cmr_cfg |= CMR_EN; 393 bgx_reg_write(bgx, lmac->lmacid, BGX_CMRX_CFG, cmr_cfg); 394 } 395 396 static void 397 bgx_lmac_handler(void *arg) 398 { 399 struct lmac *lmac; 400 int link, duplex, speed; 401 int link_changed = 0; 402 int err; 403 404 lmac = (struct lmac *)arg; 405 406 err = LMAC_MEDIA_STATUS(lmac->phy_if_dev, lmac->lmacid, 407 &link, &duplex, &speed); 408 if (err != 0) 409 goto out; 410 411 if (!link && lmac->last_link) 412 link_changed = -1; 413 414 if (link && 415 (lmac->last_duplex != duplex || 416 lmac->last_link != link || 417 lmac->last_speed != speed)) { 418 link_changed = 1; 419 } 420 421 lmac->last_link = link; 422 lmac->last_speed = speed; 423 lmac->last_duplex = duplex; 424 425 if (!link_changed) 426 goto out; 427 428 if (link_changed > 0) 429 lmac->link_up = true; 430 else 431 lmac->link_up = false; 432 433 if (lmac->is_sgmii) 434 bgx_sgmii_change_link_state(lmac); 435 else 436 bgx_xaui_check_link(lmac); 437 438 out: 439 callout_reset(&lmac->check_link, hz * 2, bgx_lmac_handler, lmac); 440 } 441 442 uint64_t 443 bgx_get_rx_stats(int node, int bgx_idx, int lmac, int idx) 444 { 445 struct bgx *bgx; 446 447 bgx = bgx_vnic[(node * MAX_BGX_PER_CN88XX) + bgx_idx]; 448 if (bgx == NULL) 449 return (0); 450 451 if (idx > 8) 452 lmac = (0); 453 return (bgx_reg_read(bgx, lmac, BGX_CMRX_RX_STAT0 + (idx * 8))); 454 } 455 456 uint64_t 457 bgx_get_tx_stats(int node, int bgx_idx, int lmac, int idx) 458 { 459 struct bgx *bgx; 460 461 bgx = bgx_vnic[(node * MAX_BGX_PER_CN88XX) + bgx_idx]; 462 if (bgx == NULL) 463 return (0); 464 465 return (bgx_reg_read(bgx, lmac, BGX_CMRX_TX_STAT0 + (idx * 8))); 466 } 467 468 static void 469 bgx_flush_dmac_addrs(struct bgx *bgx, int lmac) 470 { 471 uint64_t offset; 472 473 while (bgx->lmac[lmac].dmac > 0) { 474 offset = ((bgx->lmac[lmac].dmac - 1) * sizeof(uint64_t)) + 475 (lmac * MAX_DMAC_PER_LMAC * sizeof(uint64_t)); 476 bgx_reg_write(bgx, 0, BGX_CMR_RX_DMACX_CAM + offset, 0); 477 bgx->lmac[lmac].dmac--; 478 } 479 } 480 481 void 482 bgx_add_dmac_addr(uint64_t dmac, int node, int bgx_idx, int lmac) 483 { 484 uint64_t offset; 485 struct bgx *bgx; 486 487 #ifdef BGX_IN_PROMISCUOUS_MODE 488 return; 489 #endif 490 491 bgx_idx += node * MAX_BGX_PER_CN88XX; 492 bgx = bgx_vnic[bgx_idx]; 493 494 if (!bgx) { 495 device_printf(bgx->dev, 496 "BGX%d not yet initialized, ignoring DMAC addition\n", 497 bgx_idx); 498 return; 499 } 500 501 dmac = dmac | (1UL << 48) | ((uint64_t)lmac << 49); /* Enable DMAC */ 502 if (bgx->lmac[lmac].dmac == MAX_DMAC_PER_LMAC) { 503 device_printf(bgx->dev, 504 "Max DMAC filters for LMAC%d reached, ignoring\n", 505 lmac); 506 return; 507 } 508 509 if (bgx->lmac[lmac].dmac == MAX_DMAC_PER_LMAC_TNS_BYPASS_MODE) 510 bgx->lmac[lmac].dmac = 1; 511 512 offset = (bgx->lmac[lmac].dmac * sizeof(uint64_t)) + 513 (lmac * MAX_DMAC_PER_LMAC * sizeof(uint64_t)); 514 bgx_reg_write(bgx, 0, BGX_CMR_RX_DMACX_CAM + offset, dmac); 515 bgx->lmac[lmac].dmac++; 516 517 bgx_reg_write(bgx, lmac, BGX_CMRX_RX_DMAC_CTL, 518 (CAM_ACCEPT << 3) | (MCAST_MODE_CAM_FILTER << 1) | 519 (BCAST_ACCEPT << 0)); 520 } 521 522 /* Configure BGX LMAC in internal loopback mode */ 523 void 524 bgx_lmac_internal_loopback(int node, int bgx_idx, 525 int lmac_idx, boolean_t enable) 526 { 527 struct bgx *bgx; 528 struct lmac *lmac; 529 uint64_t cfg; 530 531 bgx = bgx_vnic[(node * MAX_BGX_PER_CN88XX) + bgx_idx]; 532 if (bgx == NULL) 533 return; 534 535 lmac = &bgx->lmac[lmac_idx]; 536 if (lmac->is_sgmii) { 537 cfg = bgx_reg_read(bgx, lmac_idx, BGX_GMP_PCS_MRX_CTL); 538 if (enable) 539 cfg |= PCS_MRX_CTL_LOOPBACK1; 540 else 541 cfg &= ~PCS_MRX_CTL_LOOPBACK1; 542 bgx_reg_write(bgx, lmac_idx, BGX_GMP_PCS_MRX_CTL, cfg); 543 } else { 544 cfg = bgx_reg_read(bgx, lmac_idx, BGX_SPUX_CONTROL1); 545 if (enable) 546 cfg |= SPU_CTL_LOOPBACK; 547 else 548 cfg &= ~SPU_CTL_LOOPBACK; 549 bgx_reg_write(bgx, lmac_idx, BGX_SPUX_CONTROL1, cfg); 550 } 551 } 552 553 static int 554 bgx_lmac_sgmii_init(struct bgx *bgx, int lmacid) 555 { 556 uint64_t cfg; 557 558 bgx_reg_modify(bgx, lmacid, BGX_GMP_GMI_TXX_THRESH, 0x30); 559 /* max packet size */ 560 bgx_reg_modify(bgx, lmacid, BGX_GMP_GMI_RXX_JABBER, MAX_FRAME_SIZE); 561 562 /* Disable frame alignment if using preamble */ 563 cfg = bgx_reg_read(bgx, lmacid, BGX_GMP_GMI_TXX_APPEND); 564 if (cfg & 1) 565 bgx_reg_write(bgx, lmacid, BGX_GMP_GMI_TXX_SGMII_CTL, 0); 566 567 /* Enable lmac */ 568 bgx_reg_modify(bgx, lmacid, BGX_CMRX_CFG, CMR_EN); 569 570 /* PCS reset */ 571 bgx_reg_modify(bgx, lmacid, BGX_GMP_PCS_MRX_CTL, PCS_MRX_CTL_RESET); 572 if (bgx_poll_reg(bgx, lmacid, BGX_GMP_PCS_MRX_CTL, 573 PCS_MRX_CTL_RESET, TRUE) != 0) { 574 device_printf(bgx->dev, "BGX PCS reset not completed\n"); 575 return (ENXIO); 576 } 577 578 /* power down, reset autoneg, autoneg enable */ 579 cfg = bgx_reg_read(bgx, lmacid, BGX_GMP_PCS_MRX_CTL); 580 cfg &= ~PCS_MRX_CTL_PWR_DN; 581 cfg |= (PCS_MRX_CTL_RST_AN | PCS_MRX_CTL_AN_EN); 582 bgx_reg_write(bgx, lmacid, BGX_GMP_PCS_MRX_CTL, cfg); 583 584 if (bgx_poll_reg(bgx, lmacid, BGX_GMP_PCS_MRX_STATUS, 585 PCS_MRX_STATUS_AN_CPT, FALSE) != 0) { 586 device_printf(bgx->dev, "BGX AN_CPT not completed\n"); 587 return (ENXIO); 588 } 589 590 return (0); 591 } 592 593 static int 594 bgx_lmac_xaui_init(struct bgx *bgx, int lmacid, int lmac_type) 595 { 596 uint64_t cfg; 597 598 /* Reset SPU */ 599 bgx_reg_modify(bgx, lmacid, BGX_SPUX_CONTROL1, SPU_CTL_RESET); 600 if (bgx_poll_reg(bgx, lmacid, BGX_SPUX_CONTROL1, 601 SPU_CTL_RESET, TRUE) != 0) { 602 device_printf(bgx->dev, "BGX SPU reset not completed\n"); 603 return (ENXIO); 604 } 605 606 /* Disable LMAC */ 607 cfg = bgx_reg_read(bgx, lmacid, BGX_CMRX_CFG); 608 cfg &= ~CMR_EN; 609 bgx_reg_write(bgx, lmacid, BGX_CMRX_CFG, cfg); 610 611 bgx_reg_modify(bgx, lmacid, BGX_SPUX_CONTROL1, SPU_CTL_LOW_POWER); 612 /* Set interleaved running disparity for RXAUI */ 613 if (bgx->lmac_type != BGX_MODE_RXAUI) { 614 bgx_reg_modify(bgx, lmacid, 615 BGX_SPUX_MISC_CONTROL, SPU_MISC_CTL_RX_DIS); 616 } else { 617 bgx_reg_modify(bgx, lmacid, BGX_SPUX_MISC_CONTROL, 618 SPU_MISC_CTL_RX_DIS | SPU_MISC_CTL_INTLV_RDISP); 619 } 620 621 /* clear all interrupts */ 622 cfg = bgx_reg_read(bgx, lmacid, BGX_SMUX_RX_INT); 623 bgx_reg_write(bgx, lmacid, BGX_SMUX_RX_INT, cfg); 624 cfg = bgx_reg_read(bgx, lmacid, BGX_SMUX_TX_INT); 625 bgx_reg_write(bgx, lmacid, BGX_SMUX_TX_INT, cfg); 626 cfg = bgx_reg_read(bgx, lmacid, BGX_SPUX_INT); 627 bgx_reg_write(bgx, lmacid, BGX_SPUX_INT, cfg); 628 629 if (bgx->use_training) { 630 bgx_reg_write(bgx, lmacid, BGX_SPUX_BR_PMD_LP_CUP, 0x00); 631 bgx_reg_write(bgx, lmacid, BGX_SPUX_BR_PMD_LD_CUP, 0x00); 632 bgx_reg_write(bgx, lmacid, BGX_SPUX_BR_PMD_LD_REP, 0x00); 633 /* training enable */ 634 bgx_reg_modify(bgx, lmacid, BGX_SPUX_BR_PMD_CRTL, 635 SPU_PMD_CRTL_TRAIN_EN); 636 } 637 638 /* Append FCS to each packet */ 639 bgx_reg_modify(bgx, lmacid, BGX_SMUX_TX_APPEND, SMU_TX_APPEND_FCS_D); 640 641 /* Disable forward error correction */ 642 cfg = bgx_reg_read(bgx, lmacid, BGX_SPUX_FEC_CONTROL); 643 cfg &= ~SPU_FEC_CTL_FEC_EN; 644 bgx_reg_write(bgx, lmacid, BGX_SPUX_FEC_CONTROL, cfg); 645 646 /* Disable autoneg */ 647 cfg = bgx_reg_read(bgx, lmacid, BGX_SPUX_AN_CONTROL); 648 cfg = cfg & ~(SPU_AN_CTL_AN_EN | SPU_AN_CTL_XNP_EN); 649 bgx_reg_write(bgx, lmacid, BGX_SPUX_AN_CONTROL, cfg); 650 651 cfg = bgx_reg_read(bgx, lmacid, BGX_SPUX_AN_ADV); 652 if (bgx->lmac_type == BGX_MODE_10G_KR) 653 cfg |= (1 << 23); 654 else if (bgx->lmac_type == BGX_MODE_40G_KR) 655 cfg |= (1 << 24); 656 else 657 cfg &= ~((1 << 23) | (1 << 24)); 658 cfg = cfg & (~((1UL << 25) | (1UL << 22) | (1UL << 12))); 659 bgx_reg_write(bgx, lmacid, BGX_SPUX_AN_ADV, cfg); 660 661 cfg = bgx_reg_read(bgx, 0, BGX_SPU_DBG_CONTROL); 662 cfg &= ~SPU_DBG_CTL_AN_ARB_LINK_CHK_EN; 663 bgx_reg_write(bgx, 0, BGX_SPU_DBG_CONTROL, cfg); 664 665 /* Enable lmac */ 666 bgx_reg_modify(bgx, lmacid, BGX_CMRX_CFG, CMR_EN); 667 668 cfg = bgx_reg_read(bgx, lmacid, BGX_SPUX_CONTROL1); 669 cfg &= ~SPU_CTL_LOW_POWER; 670 bgx_reg_write(bgx, lmacid, BGX_SPUX_CONTROL1, cfg); 671 672 cfg = bgx_reg_read(bgx, lmacid, BGX_SMUX_TX_CTL); 673 cfg &= ~SMU_TX_CTL_UNI_EN; 674 cfg |= SMU_TX_CTL_DIC_EN; 675 bgx_reg_write(bgx, lmacid, BGX_SMUX_TX_CTL, cfg); 676 677 /* take lmac_count into account */ 678 bgx_reg_modify(bgx, lmacid, BGX_SMUX_TX_THRESH, (0x100 - 1)); 679 /* max packet size */ 680 bgx_reg_modify(bgx, lmacid, BGX_SMUX_RX_JABBER, MAX_FRAME_SIZE); 681 682 return (0); 683 } 684 685 static int 686 bgx_xaui_check_link(struct lmac *lmac) 687 { 688 struct bgx *bgx = lmac->bgx; 689 int lmacid = lmac->lmacid; 690 int lmac_type = bgx->lmac_type; 691 uint64_t cfg; 692 693 bgx_reg_modify(bgx, lmacid, BGX_SPUX_MISC_CONTROL, SPU_MISC_CTL_RX_DIS); 694 if (bgx->use_training) { 695 cfg = bgx_reg_read(bgx, lmacid, BGX_SPUX_INT); 696 if ((cfg & (1UL << 13)) == 0) { 697 cfg = (1UL << 13) | (1UL << 14); 698 bgx_reg_write(bgx, lmacid, BGX_SPUX_INT, cfg); 699 cfg = bgx_reg_read(bgx, lmacid, BGX_SPUX_BR_PMD_CRTL); 700 cfg |= (1UL << 0); 701 bgx_reg_write(bgx, lmacid, BGX_SPUX_BR_PMD_CRTL, cfg); 702 return (ENXIO); 703 } 704 } 705 706 /* wait for PCS to come out of reset */ 707 if (bgx_poll_reg(bgx, lmacid, BGX_SPUX_CONTROL1, 708 SPU_CTL_RESET, TRUE) != 0) { 709 device_printf(bgx->dev, "BGX SPU reset not completed\n"); 710 return (ENXIO); 711 } 712 713 if ((lmac_type == BGX_MODE_10G_KR) || (lmac_type == BGX_MODE_XFI) || 714 (lmac_type == BGX_MODE_40G_KR) || (lmac_type == BGX_MODE_XLAUI)) { 715 if (bgx_poll_reg(bgx, lmacid, BGX_SPUX_BR_STATUS1, 716 SPU_BR_STATUS_BLK_LOCK, FALSE)) { 717 device_printf(bgx->dev, 718 "SPU_BR_STATUS_BLK_LOCK not completed\n"); 719 return (ENXIO); 720 } 721 } else { 722 if (bgx_poll_reg(bgx, lmacid, BGX_SPUX_BX_STATUS, 723 SPU_BX_STATUS_RX_ALIGN, FALSE) != 0) { 724 device_printf(bgx->dev, 725 "SPU_BX_STATUS_RX_ALIGN not completed\n"); 726 return (ENXIO); 727 } 728 } 729 730 /* Clear rcvflt bit (latching high) and read it back */ 731 bgx_reg_modify(bgx, lmacid, BGX_SPUX_STATUS2, SPU_STATUS2_RCVFLT); 732 if (bgx_reg_read(bgx, lmacid, BGX_SPUX_STATUS2) & SPU_STATUS2_RCVFLT) { 733 device_printf(bgx->dev, "Receive fault, retry training\n"); 734 if (bgx->use_training) { 735 cfg = bgx_reg_read(bgx, lmacid, BGX_SPUX_INT); 736 if ((cfg & (1UL << 13)) == 0) { 737 cfg = (1UL << 13) | (1UL << 14); 738 bgx_reg_write(bgx, lmacid, BGX_SPUX_INT, cfg); 739 cfg = bgx_reg_read(bgx, lmacid, 740 BGX_SPUX_BR_PMD_CRTL); 741 cfg |= (1UL << 0); 742 bgx_reg_write(bgx, lmacid, 743 BGX_SPUX_BR_PMD_CRTL, cfg); 744 return (ENXIO); 745 } 746 } 747 return (ENXIO); 748 } 749 750 /* Wait for MAC RX to be ready */ 751 if (bgx_poll_reg(bgx, lmacid, BGX_SMUX_RX_CTL, 752 SMU_RX_CTL_STATUS, TRUE) != 0) { 753 device_printf(bgx->dev, "SMU RX link not okay\n"); 754 return (ENXIO); 755 } 756 757 /* Wait for BGX RX to be idle */ 758 if (bgx_poll_reg(bgx, lmacid, BGX_SMUX_CTL, 759 SMU_CTL_RX_IDLE, FALSE) != 0) { 760 device_printf(bgx->dev, "SMU RX not idle\n"); 761 return (ENXIO); 762 } 763 764 /* Wait for BGX TX to be idle */ 765 if (bgx_poll_reg(bgx, lmacid, BGX_SMUX_CTL, 766 SMU_CTL_TX_IDLE, FALSE) != 0) { 767 device_printf(bgx->dev, "SMU TX not idle\n"); 768 return (ENXIO); 769 } 770 771 if ((bgx_reg_read(bgx, lmacid, BGX_SPUX_STATUS2) & 772 SPU_STATUS2_RCVFLT) != 0) { 773 device_printf(bgx->dev, "Receive fault\n"); 774 return (ENXIO); 775 } 776 777 /* Receive link is latching low. Force it high and verify it */ 778 bgx_reg_modify(bgx, lmacid, BGX_SPUX_STATUS1, SPU_STATUS1_RCV_LNK); 779 if (bgx_poll_reg(bgx, lmacid, BGX_SPUX_STATUS1, 780 SPU_STATUS1_RCV_LNK, FALSE) != 0) { 781 device_printf(bgx->dev, "SPU receive link down\n"); 782 return (ENXIO); 783 } 784 785 cfg = bgx_reg_read(bgx, lmacid, BGX_SPUX_MISC_CONTROL); 786 cfg &= ~SPU_MISC_CTL_RX_DIS; 787 bgx_reg_write(bgx, lmacid, BGX_SPUX_MISC_CONTROL, cfg); 788 return (0); 789 } 790 791 static void 792 bgx_poll_for_link(void *arg) 793 { 794 struct lmac *lmac; 795 uint64_t link; 796 797 lmac = (struct lmac *)arg; 798 799 /* Receive link is latching low. Force it high and verify it */ 800 bgx_reg_modify(lmac->bgx, lmac->lmacid, 801 BGX_SPUX_STATUS1, SPU_STATUS1_RCV_LNK); 802 bgx_poll_reg(lmac->bgx, lmac->lmacid, BGX_SPUX_STATUS1, 803 SPU_STATUS1_RCV_LNK, false); 804 805 link = bgx_reg_read(lmac->bgx, lmac->lmacid, BGX_SPUX_STATUS1); 806 if (link & SPU_STATUS1_RCV_LNK) { 807 lmac->link_up = 1; 808 if (lmac->bgx->lmac_type == BGX_MODE_XLAUI) 809 lmac->last_speed = 40000; 810 else 811 lmac->last_speed = 10000; 812 lmac->last_duplex = 1; 813 } else { 814 lmac->link_up = 0; 815 } 816 817 if (lmac->last_link != lmac->link_up) { 818 lmac->last_link = lmac->link_up; 819 if (lmac->link_up) 820 bgx_xaui_check_link(lmac); 821 } 822 823 callout_reset(&lmac->check_link, hz * 2, bgx_poll_for_link, lmac); 824 } 825 826 static int 827 bgx_lmac_enable(struct bgx *bgx, uint8_t lmacid) 828 { 829 uint64_t __unused dmac_bcast = (1UL << 48) - 1; 830 struct lmac *lmac; 831 uint64_t cfg; 832 833 lmac = &bgx->lmac[lmacid]; 834 lmac->bgx = bgx; 835 836 if (bgx->lmac_type == BGX_MODE_SGMII) { 837 lmac->is_sgmii = 1; 838 if (bgx_lmac_sgmii_init(bgx, lmacid) != 0) 839 return -1; 840 } else { 841 lmac->is_sgmii = 0; 842 if (bgx_lmac_xaui_init(bgx, lmacid, bgx->lmac_type)) 843 return -1; 844 } 845 846 if (lmac->is_sgmii) { 847 cfg = bgx_reg_read(bgx, lmacid, BGX_GMP_GMI_TXX_APPEND); 848 cfg |= ((1UL << 2) | (1UL << 1)); /* FCS and PAD */ 849 bgx_reg_modify(bgx, lmacid, BGX_GMP_GMI_TXX_APPEND, cfg); 850 bgx_reg_write(bgx, lmacid, BGX_GMP_GMI_TXX_MIN_PKT, 60 - 1); 851 } else { 852 cfg = bgx_reg_read(bgx, lmacid, BGX_SMUX_TX_APPEND); 853 cfg |= ((1UL << 2) | (1UL << 1)); /* FCS and PAD */ 854 bgx_reg_modify(bgx, lmacid, BGX_SMUX_TX_APPEND, cfg); 855 bgx_reg_write(bgx, lmacid, BGX_SMUX_TX_MIN_PKT, 60 + 4); 856 } 857 858 /* Enable lmac */ 859 bgx_reg_modify(bgx, lmacid, BGX_CMRX_CFG, 860 CMR_EN | CMR_PKT_RX_EN | CMR_PKT_TX_EN); 861 862 /* Restore default cfg, incase low level firmware changed it */ 863 bgx_reg_write(bgx, lmacid, BGX_CMRX_RX_DMAC_CTL, 0x03); 864 865 /* Add broadcast MAC into all LMAC's DMAC filters */ 866 bgx_add_dmac_addr(dmac_bcast, 0, bgx->bgx_id, lmacid); 867 868 if ((bgx->lmac_type != BGX_MODE_XFI) && 869 (bgx->lmac_type != BGX_MODE_XAUI) && 870 (bgx->lmac_type != BGX_MODE_XLAUI) && 871 (bgx->lmac_type != BGX_MODE_40G_KR) && 872 (bgx->lmac_type != BGX_MODE_10G_KR)) { 873 if (lmac->phy_if_dev == NULL) { 874 device_printf(bgx->dev, 875 "LMAC%d missing interface to PHY\n", lmacid); 876 return (ENXIO); 877 } 878 879 if (LMAC_PHY_CONNECT(lmac->phy_if_dev, lmac->phyaddr, 880 lmacid) != 0) { 881 device_printf(bgx->dev, 882 "LMAC%d could not connect to PHY\n", lmacid); 883 return (ENXIO); 884 } 885 mtx_init(&lmac->check_link_mtx, "BGX link poll", NULL, MTX_DEF); 886 callout_init_mtx(&lmac->check_link, &lmac->check_link_mtx, 0); 887 mtx_lock(&lmac->check_link_mtx); 888 bgx_lmac_handler(lmac); 889 mtx_unlock(&lmac->check_link_mtx); 890 } else { 891 mtx_init(&lmac->check_link_mtx, "BGX link poll", NULL, MTX_DEF); 892 callout_init_mtx(&lmac->check_link, &lmac->check_link_mtx, 0); 893 mtx_lock(&lmac->check_link_mtx); 894 bgx_poll_for_link(lmac); 895 mtx_unlock(&lmac->check_link_mtx); 896 } 897 898 return (0); 899 } 900 901 static void 902 bgx_lmac_disable(struct bgx *bgx, uint8_t lmacid) 903 { 904 struct lmac *lmac; 905 uint64_t cmrx_cfg; 906 907 lmac = &bgx->lmac[lmacid]; 908 909 /* Stop callout */ 910 callout_drain(&lmac->check_link); 911 mtx_destroy(&lmac->check_link_mtx); 912 913 cmrx_cfg = bgx_reg_read(bgx, lmacid, BGX_CMRX_CFG); 914 cmrx_cfg &= ~(1 << 15); 915 bgx_reg_write(bgx, lmacid, BGX_CMRX_CFG, cmrx_cfg); 916 bgx_flush_dmac_addrs(bgx, lmacid); 917 918 if ((bgx->lmac_type != BGX_MODE_XFI) && 919 (bgx->lmac_type != BGX_MODE_XLAUI) && 920 (bgx->lmac_type != BGX_MODE_40G_KR) && 921 (bgx->lmac_type != BGX_MODE_10G_KR)) { 922 if (lmac->phy_if_dev == NULL) { 923 device_printf(bgx->dev, 924 "LMAC%d missing interface to PHY\n", lmacid); 925 return; 926 } 927 if (LMAC_PHY_DISCONNECT(lmac->phy_if_dev, lmac->phyaddr, 928 lmacid) != 0) { 929 device_printf(bgx->dev, 930 "LMAC%d could not disconnect PHY\n", lmacid); 931 return; 932 } 933 lmac->phy_if_dev = NULL; 934 } 935 } 936 937 static void 938 bgx_set_num_ports(struct bgx *bgx) 939 { 940 uint64_t lmac_count; 941 942 switch (bgx->qlm_mode) { 943 case QLM_MODE_SGMII: 944 bgx->lmac_count = 4; 945 bgx->lmac_type = BGX_MODE_SGMII; 946 bgx->lane_to_sds = 0; 947 break; 948 case QLM_MODE_XAUI_1X4: 949 bgx->lmac_count = 1; 950 bgx->lmac_type = BGX_MODE_XAUI; 951 bgx->lane_to_sds = 0xE4; 952 break; 953 case QLM_MODE_RXAUI_2X2: 954 bgx->lmac_count = 2; 955 bgx->lmac_type = BGX_MODE_RXAUI; 956 bgx->lane_to_sds = 0xE4; 957 break; 958 case QLM_MODE_XFI_4X1: 959 bgx->lmac_count = 4; 960 bgx->lmac_type = BGX_MODE_XFI; 961 bgx->lane_to_sds = 0; 962 break; 963 case QLM_MODE_XLAUI_1X4: 964 bgx->lmac_count = 1; 965 bgx->lmac_type = BGX_MODE_XLAUI; 966 bgx->lane_to_sds = 0xE4; 967 break; 968 case QLM_MODE_10G_KR_4X1: 969 bgx->lmac_count = 4; 970 bgx->lmac_type = BGX_MODE_10G_KR; 971 bgx->lane_to_sds = 0; 972 bgx->use_training = 1; 973 break; 974 case QLM_MODE_40G_KR4_1X4: 975 bgx->lmac_count = 1; 976 bgx->lmac_type = BGX_MODE_40G_KR; 977 bgx->lane_to_sds = 0xE4; 978 bgx->use_training = 1; 979 break; 980 default: 981 bgx->lmac_count = 0; 982 break; 983 } 984 985 /* 986 * Check if low level firmware has programmed LMAC count 987 * based on board type, if yes consider that otherwise 988 * the default static values 989 */ 990 lmac_count = bgx_reg_read(bgx, 0, BGX_CMR_RX_LMACS) & 0x7; 991 if (lmac_count != 4) 992 bgx->lmac_count = lmac_count; 993 } 994 995 static void 996 bgx_init_hw(struct bgx *bgx) 997 { 998 int i; 999 1000 bgx_set_num_ports(bgx); 1001 1002 bgx_reg_modify(bgx, 0, BGX_CMR_GLOBAL_CFG, CMR_GLOBAL_CFG_FCS_STRIP); 1003 if (bgx_reg_read(bgx, 0, BGX_CMR_BIST_STATUS)) 1004 device_printf(bgx->dev, "BGX%d BIST failed\n", bgx->bgx_id); 1005 1006 /* Set lmac type and lane2serdes mapping */ 1007 for (i = 0; i < bgx->lmac_count; i++) { 1008 if (bgx->lmac_type == BGX_MODE_RXAUI) { 1009 if (i) 1010 bgx->lane_to_sds = 0x0e; 1011 else 1012 bgx->lane_to_sds = 0x04; 1013 bgx_reg_write(bgx, i, BGX_CMRX_CFG, 1014 (bgx->lmac_type << 8) | bgx->lane_to_sds); 1015 continue; 1016 } 1017 bgx_reg_write(bgx, i, BGX_CMRX_CFG, 1018 (bgx->lmac_type << 8) | (bgx->lane_to_sds + i)); 1019 bgx->lmac[i].lmacid_bd = lmac_count; 1020 lmac_count++; 1021 } 1022 1023 bgx_reg_write(bgx, 0, BGX_CMR_TX_LMACS, bgx->lmac_count); 1024 bgx_reg_write(bgx, 0, BGX_CMR_RX_LMACS, bgx->lmac_count); 1025 1026 /* Set the backpressure AND mask */ 1027 for (i = 0; i < bgx->lmac_count; i++) { 1028 bgx_reg_modify(bgx, 0, BGX_CMR_CHAN_MSK_AND, 1029 ((1UL << MAX_BGX_CHANS_PER_LMAC) - 1) << 1030 (i * MAX_BGX_CHANS_PER_LMAC)); 1031 } 1032 1033 /* Disable all MAC filtering */ 1034 for (i = 0; i < RX_DMAC_COUNT; i++) 1035 bgx_reg_write(bgx, 0, BGX_CMR_RX_DMACX_CAM + (i * 8), 0x00); 1036 1037 /* Disable MAC steering (NCSI traffic) */ 1038 for (i = 0; i < RX_TRAFFIC_STEER_RULE_COUNT; i++) 1039 bgx_reg_write(bgx, 0, BGX_CMR_RX_STREERING + (i * 8), 0x00); 1040 } 1041 1042 static void 1043 bgx_get_qlm_mode(struct bgx *bgx) 1044 { 1045 device_t dev = bgx->dev;; 1046 int lmac_type; 1047 int train_en; 1048 1049 /* Read LMAC0 type to figure out QLM mode 1050 * This is configured by low level firmware 1051 */ 1052 lmac_type = bgx_reg_read(bgx, 0, BGX_CMRX_CFG); 1053 lmac_type = (lmac_type >> 8) & 0x07; 1054 1055 train_en = bgx_reg_read(bgx, 0, BGX_SPUX_BR_PMD_CRTL) & 1056 SPU_PMD_CRTL_TRAIN_EN; 1057 1058 switch (lmac_type) { 1059 case BGX_MODE_SGMII: 1060 bgx->qlm_mode = QLM_MODE_SGMII; 1061 if (bootverbose) { 1062 device_printf(dev, "BGX%d QLM mode: SGMII\n", 1063 bgx->bgx_id); 1064 } 1065 break; 1066 case BGX_MODE_XAUI: 1067 bgx->qlm_mode = QLM_MODE_XAUI_1X4; 1068 if (bootverbose) { 1069 device_printf(dev, "BGX%d QLM mode: XAUI\n", 1070 bgx->bgx_id); 1071 } 1072 break; 1073 case BGX_MODE_RXAUI: 1074 bgx->qlm_mode = QLM_MODE_RXAUI_2X2; 1075 if (bootverbose) { 1076 device_printf(dev, "BGX%d QLM mode: RXAUI\n", 1077 bgx->bgx_id); 1078 } 1079 break; 1080 case BGX_MODE_XFI: 1081 if (!train_en) { 1082 bgx->qlm_mode = QLM_MODE_XFI_4X1; 1083 if (bootverbose) { 1084 device_printf(dev, "BGX%d QLM mode: XFI\n", 1085 bgx->bgx_id); 1086 } 1087 } else { 1088 bgx->qlm_mode = QLM_MODE_10G_KR_4X1; 1089 if (bootverbose) { 1090 device_printf(dev, "BGX%d QLM mode: 10G_KR\n", 1091 bgx->bgx_id); 1092 } 1093 } 1094 break; 1095 case BGX_MODE_XLAUI: 1096 if (!train_en) { 1097 bgx->qlm_mode = QLM_MODE_XLAUI_1X4; 1098 if (bootverbose) { 1099 device_printf(dev, "BGX%d QLM mode: XLAUI\n", 1100 bgx->bgx_id); 1101 } 1102 } else { 1103 bgx->qlm_mode = QLM_MODE_40G_KR4_1X4; 1104 if (bootverbose) { 1105 device_printf(dev, "BGX%d QLM mode: 40G_KR4\n", 1106 bgx->bgx_id); 1107 } 1108 } 1109 break; 1110 default: 1111 bgx->qlm_mode = QLM_MODE_SGMII; 1112 if (bootverbose) { 1113 device_printf(dev, "BGX%d QLM default mode: SGMII\n", 1114 bgx->bgx_id); 1115 } 1116 } 1117 } 1118 1119 static int 1120 bgx_init_phy(struct bgx *bgx) 1121 { 1122 int err; 1123 1124 /* By default we fail */ 1125 err = ENXIO; 1126 #ifdef FDT 1127 err = bgx_fdt_init_phy(bgx); 1128 #endif 1129 #ifdef ACPI 1130 if (err != 0) { 1131 /* ARM64TODO: Add ACPI function here */ 1132 } 1133 #endif 1134 return (err); 1135 } 1136