1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause 3 * 4 * Copyright (c) 2007-2016 Solarflare Communications Inc. 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions are met: 9 * 10 * 1. Redistributions of source code must retain the above copyright notice, 11 * this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright notice, 13 * this list of conditions and the following disclaimer in the documentation 14 * and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 17 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, 18 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 19 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR 20 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 21 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 22 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 23 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 24 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 25 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, 26 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 27 * 28 * The views and conclusions contained in the software and documentation are 29 * those of the authors and should not be interpreted as representing official 30 * policies, either expressed or implied, of the FreeBSD Project. 31 */ 32 33 #include <sys/cdefs.h> 34 __FBSDID("$FreeBSD$"); 35 36 #include "efx.h" 37 #include "efx_impl.h" 38 39 #if EFSYS_OPT_SIENA 40 41 static __checkReturn efx_rc_t 42 siena_intr_init( 43 __in efx_nic_t *enp, 44 __in efx_intr_type_t type, 45 __in efsys_mem_t *esmp); 46 47 static void 48 siena_intr_enable( 49 __in efx_nic_t *enp); 50 51 static void 52 siena_intr_disable( 53 __in efx_nic_t *enp); 54 55 static void 56 siena_intr_disable_unlocked( 57 __in efx_nic_t *enp); 58 59 static __checkReturn efx_rc_t 60 siena_intr_trigger( 61 __in efx_nic_t *enp, 62 __in unsigned int level); 63 64 static void 65 siena_intr_fini( 66 __in efx_nic_t *enp); 67 68 static void 69 siena_intr_status_line( 70 __in efx_nic_t *enp, 71 __out boolean_t *fatalp, 72 __out uint32_t *qmaskp); 73 74 static void 75 siena_intr_status_message( 76 __in efx_nic_t *enp, 77 __in unsigned int message, 78 __out boolean_t *fatalp); 79 80 static void 81 siena_intr_fatal( 82 __in efx_nic_t *enp); 83 84 static __checkReturn boolean_t 85 siena_intr_check_fatal( 86 __in efx_nic_t *enp); 87 88 #endif /* EFSYS_OPT_SIENA */ 89 90 #if EFSYS_OPT_SIENA 91 static const efx_intr_ops_t __efx_intr_siena_ops = { 92 siena_intr_init, /* eio_init */ 93 siena_intr_enable, /* eio_enable */ 94 siena_intr_disable, /* eio_disable */ 95 siena_intr_disable_unlocked, /* eio_disable_unlocked */ 96 siena_intr_trigger, /* eio_trigger */ 97 siena_intr_status_line, /* eio_status_line */ 98 siena_intr_status_message, /* eio_status_message */ 99 siena_intr_fatal, /* eio_fatal */ 100 siena_intr_fini, /* eio_fini */ 101 }; 102 #endif /* EFSYS_OPT_SIENA */ 103 104 #if EFSYS_OPT_HUNTINGTON || EFSYS_OPT_MEDFORD || EFSYS_OPT_MEDFORD2 105 static const efx_intr_ops_t __efx_intr_ef10_ops = { 106 ef10_intr_init, /* eio_init */ 107 ef10_intr_enable, /* eio_enable */ 108 ef10_intr_disable, /* eio_disable */ 109 ef10_intr_disable_unlocked, /* eio_disable_unlocked */ 110 ef10_intr_trigger, /* eio_trigger */ 111 ef10_intr_status_line, /* eio_status_line */ 112 ef10_intr_status_message, /* eio_status_message */ 113 ef10_intr_fatal, /* eio_fatal */ 114 ef10_intr_fini, /* eio_fini */ 115 }; 116 #endif /* EFSYS_OPT_HUNTINGTON || EFSYS_OPT_MEDFORD || EFSYS_OPT_MEDFORD2 */ 117 118 __checkReturn efx_rc_t 119 efx_intr_init( 120 __in efx_nic_t *enp, 121 __in efx_intr_type_t type, 122 __in_opt efsys_mem_t *esmp) 123 { 124 efx_intr_t *eip = &(enp->en_intr); 125 const efx_intr_ops_t *eiop; 126 efx_rc_t rc; 127 128 EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC); 129 EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_NIC); 130 131 if (enp->en_mod_flags & EFX_MOD_INTR) { 132 rc = EINVAL; 133 goto fail1; 134 } 135 136 eip->ei_esmp = esmp; 137 eip->ei_type = type; 138 eip->ei_level = 0; 139 140 enp->en_mod_flags |= EFX_MOD_INTR; 141 142 switch (enp->en_family) { 143 #if EFSYS_OPT_SIENA 144 case EFX_FAMILY_SIENA: 145 eiop = &__efx_intr_siena_ops; 146 break; 147 #endif /* EFSYS_OPT_SIENA */ 148 149 #if EFSYS_OPT_HUNTINGTON 150 case EFX_FAMILY_HUNTINGTON: 151 eiop = &__efx_intr_ef10_ops; 152 break; 153 #endif /* EFSYS_OPT_HUNTINGTON */ 154 155 #if EFSYS_OPT_MEDFORD 156 case EFX_FAMILY_MEDFORD: 157 eiop = &__efx_intr_ef10_ops; 158 break; 159 #endif /* EFSYS_OPT_MEDFORD */ 160 161 #if EFSYS_OPT_MEDFORD2 162 case EFX_FAMILY_MEDFORD2: 163 eiop = &__efx_intr_ef10_ops; 164 break; 165 #endif /* EFSYS_OPT_MEDFORD2 */ 166 167 default: 168 EFSYS_ASSERT(B_FALSE); 169 rc = ENOTSUP; 170 goto fail2; 171 } 172 173 if ((rc = eiop->eio_init(enp, type, esmp)) != 0) 174 goto fail3; 175 176 eip->ei_eiop = eiop; 177 178 return (0); 179 180 fail3: 181 EFSYS_PROBE(fail3); 182 fail2: 183 EFSYS_PROBE(fail2); 184 fail1: 185 EFSYS_PROBE1(fail1, efx_rc_t, rc); 186 187 return (rc); 188 } 189 190 void 191 efx_intr_fini( 192 __in efx_nic_t *enp) 193 { 194 efx_intr_t *eip = &(enp->en_intr); 195 const efx_intr_ops_t *eiop = eip->ei_eiop; 196 197 EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC); 198 EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_NIC); 199 EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_INTR); 200 201 eiop->eio_fini(enp); 202 203 enp->en_mod_flags &= ~EFX_MOD_INTR; 204 } 205 206 void 207 efx_intr_enable( 208 __in efx_nic_t *enp) 209 { 210 efx_intr_t *eip = &(enp->en_intr); 211 const efx_intr_ops_t *eiop = eip->ei_eiop; 212 213 EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC); 214 EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_INTR); 215 216 eiop->eio_enable(enp); 217 } 218 219 void 220 efx_intr_disable( 221 __in efx_nic_t *enp) 222 { 223 efx_intr_t *eip = &(enp->en_intr); 224 const efx_intr_ops_t *eiop = eip->ei_eiop; 225 226 EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC); 227 EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_INTR); 228 229 eiop->eio_disable(enp); 230 } 231 232 void 233 efx_intr_disable_unlocked( 234 __in efx_nic_t *enp) 235 { 236 efx_intr_t *eip = &(enp->en_intr); 237 const efx_intr_ops_t *eiop = eip->ei_eiop; 238 239 EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC); 240 EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_INTR); 241 242 eiop->eio_disable_unlocked(enp); 243 } 244 245 __checkReturn efx_rc_t 246 efx_intr_trigger( 247 __in efx_nic_t *enp, 248 __in unsigned int level) 249 { 250 efx_intr_t *eip = &(enp->en_intr); 251 const efx_intr_ops_t *eiop = eip->ei_eiop; 252 253 EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC); 254 EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_INTR); 255 256 return (eiop->eio_trigger(enp, level)); 257 } 258 259 void 260 efx_intr_status_line( 261 __in efx_nic_t *enp, 262 __out boolean_t *fatalp, 263 __out uint32_t *qmaskp) 264 { 265 efx_intr_t *eip = &(enp->en_intr); 266 const efx_intr_ops_t *eiop = eip->ei_eiop; 267 268 EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC); 269 EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_INTR); 270 271 eiop->eio_status_line(enp, fatalp, qmaskp); 272 } 273 274 void 275 efx_intr_status_message( 276 __in efx_nic_t *enp, 277 __in unsigned int message, 278 __out boolean_t *fatalp) 279 { 280 efx_intr_t *eip = &(enp->en_intr); 281 const efx_intr_ops_t *eiop = eip->ei_eiop; 282 283 EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC); 284 EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_INTR); 285 286 eiop->eio_status_message(enp, message, fatalp); 287 } 288 289 void 290 efx_intr_fatal( 291 __in efx_nic_t *enp) 292 { 293 efx_intr_t *eip = &(enp->en_intr); 294 const efx_intr_ops_t *eiop = eip->ei_eiop; 295 296 EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC); 297 EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_INTR); 298 299 eiop->eio_fatal(enp); 300 } 301 302 /* ************************************************************************* */ 303 /* ************************************************************************* */ 304 /* ************************************************************************* */ 305 306 #if EFSYS_OPT_SIENA 307 308 static __checkReturn efx_rc_t 309 siena_intr_init( 310 __in efx_nic_t *enp, 311 __in efx_intr_type_t type, 312 __in efsys_mem_t *esmp) 313 { 314 efx_intr_t *eip = &(enp->en_intr); 315 efx_oword_t oword; 316 efx_rc_t rc; 317 318 if ((esmp == NULL) || (EFSYS_MEM_SIZE(esmp) < EFX_INTR_SIZE)) { 319 rc = EINVAL; 320 goto fail1; 321 } 322 323 /* 324 * bug17213 workaround. 325 * 326 * Under legacy interrupts, don't share a level between fatal 327 * interrupts and event queue interrupts. Under MSI-X, they 328 * must share, or we won't get an interrupt. 329 */ 330 if (enp->en_family == EFX_FAMILY_SIENA && 331 eip->ei_type == EFX_INTR_LINE) 332 eip->ei_level = 0x1f; 333 else 334 eip->ei_level = 0; 335 336 /* Enable all the genuinely fatal interrupts */ 337 EFX_SET_OWORD(oword); 338 EFX_SET_OWORD_FIELD(oword, FRF_AZ_ILL_ADR_INT_KER_EN, 0); 339 EFX_SET_OWORD_FIELD(oword, FRF_AZ_RBUF_OWN_INT_KER_EN, 0); 340 EFX_SET_OWORD_FIELD(oword, FRF_AZ_TBUF_OWN_INT_KER_EN, 0); 341 if (enp->en_family >= EFX_FAMILY_SIENA) 342 EFX_SET_OWORD_FIELD(oword, FRF_CZ_SRAM_PERR_INT_P_KER_EN, 0); 343 EFX_BAR_WRITEO(enp, FR_AZ_FATAL_INTR_REG_KER, &oword); 344 345 /* Set up the interrupt address register */ 346 EFX_POPULATE_OWORD_3(oword, 347 FRF_AZ_NORM_INT_VEC_DIS_KER, (type == EFX_INTR_MESSAGE) ? 1 : 0, 348 FRF_AZ_INT_ADR_KER_DW0, EFSYS_MEM_ADDR(esmp) & 0xffffffff, 349 FRF_AZ_INT_ADR_KER_DW1, EFSYS_MEM_ADDR(esmp) >> 32); 350 EFX_BAR_WRITEO(enp, FR_AZ_INT_ADR_REG_KER, &oword); 351 352 return (0); 353 354 fail1: 355 EFSYS_PROBE1(fail1, efx_rc_t, rc); 356 357 return (rc); 358 } 359 360 static void 361 siena_intr_enable( 362 __in efx_nic_t *enp) 363 { 364 efx_intr_t *eip = &(enp->en_intr); 365 efx_oword_t oword; 366 367 EFX_BAR_READO(enp, FR_AZ_INT_EN_REG_KER, &oword); 368 369 EFX_SET_OWORD_FIELD(oword, FRF_AZ_KER_INT_LEVE_SEL, eip->ei_level); 370 EFX_SET_OWORD_FIELD(oword, FRF_AZ_DRV_INT_EN_KER, 1); 371 EFX_BAR_WRITEO(enp, FR_AZ_INT_EN_REG_KER, &oword); 372 } 373 374 static void 375 siena_intr_disable( 376 __in efx_nic_t *enp) 377 { 378 efx_oword_t oword; 379 380 EFX_BAR_READO(enp, FR_AZ_INT_EN_REG_KER, &oword); 381 EFX_SET_OWORD_FIELD(oword, FRF_AZ_DRV_INT_EN_KER, 0); 382 EFX_BAR_WRITEO(enp, FR_AZ_INT_EN_REG_KER, &oword); 383 384 EFSYS_SPIN(10); 385 } 386 387 static void 388 siena_intr_disable_unlocked( 389 __in efx_nic_t *enp) 390 { 391 efx_oword_t oword; 392 393 EFSYS_BAR_READO(enp->en_esbp, FR_AZ_INT_EN_REG_KER_OFST, 394 &oword, B_FALSE); 395 EFX_SET_OWORD_FIELD(oword, FRF_AZ_DRV_INT_EN_KER, 0); 396 EFSYS_BAR_WRITEO(enp->en_esbp, FR_AZ_INT_EN_REG_KER_OFST, 397 &oword, B_FALSE); 398 } 399 400 static __checkReturn efx_rc_t 401 siena_intr_trigger( 402 __in efx_nic_t *enp, 403 __in unsigned int level) 404 { 405 efx_intr_t *eip = &(enp->en_intr); 406 efx_oword_t oword; 407 unsigned int count; 408 uint32_t sel; 409 efx_rc_t rc; 410 411 /* bug16757: No event queues can be initialized */ 412 EFSYS_ASSERT(!(enp->en_mod_flags & EFX_MOD_EV)); 413 414 if (level >= EFX_NINTR_SIENA) { 415 rc = EINVAL; 416 goto fail1; 417 } 418 419 if (level > EFX_MASK32(FRF_AZ_KER_INT_LEVE_SEL)) 420 return (ENOTSUP); /* avoid EFSYS_PROBE() */ 421 422 sel = level; 423 424 /* Trigger a test interrupt */ 425 EFX_BAR_READO(enp, FR_AZ_INT_EN_REG_KER, &oword); 426 EFX_SET_OWORD_FIELD(oword, FRF_AZ_KER_INT_LEVE_SEL, sel); 427 EFX_SET_OWORD_FIELD(oword, FRF_AZ_KER_INT_KER, 1); 428 EFX_BAR_WRITEO(enp, FR_AZ_INT_EN_REG_KER, &oword); 429 430 /* 431 * Wait up to 100ms for the interrupt to be raised before restoring 432 * KER_INT_LEVE_SEL. Ignore a failure to raise (the caller will 433 * observe this soon enough anyway), but always reset KER_INT_LEVE_SEL 434 */ 435 count = 0; 436 do { 437 EFSYS_SPIN(100); /* 100us */ 438 439 EFX_BAR_READO(enp, FR_AZ_INT_EN_REG_KER, &oword); 440 } while (EFX_OWORD_FIELD(oword, FRF_AZ_KER_INT_KER) && ++count < 1000); 441 442 EFX_SET_OWORD_FIELD(oword, FRF_AZ_KER_INT_LEVE_SEL, eip->ei_level); 443 EFX_BAR_WRITEO(enp, FR_AZ_INT_EN_REG_KER, &oword); 444 445 return (0); 446 447 fail1: 448 EFSYS_PROBE1(fail1, efx_rc_t, rc); 449 450 return (rc); 451 } 452 453 static __checkReturn boolean_t 454 siena_intr_check_fatal( 455 __in efx_nic_t *enp) 456 { 457 efx_intr_t *eip = &(enp->en_intr); 458 efsys_mem_t *esmp = eip->ei_esmp; 459 efx_oword_t oword; 460 461 /* Read the syndrome */ 462 EFSYS_MEM_READO(esmp, 0, &oword); 463 464 if (EFX_OWORD_FIELD(oword, FSF_AZ_NET_IVEC_FATAL_INT) != 0) { 465 EFSYS_PROBE(fatal); 466 467 /* Clear the fatal interrupt condition */ 468 EFX_SET_OWORD_FIELD(oword, FSF_AZ_NET_IVEC_FATAL_INT, 0); 469 EFSYS_MEM_WRITEO(esmp, 0, &oword); 470 471 return (B_TRUE); 472 } 473 474 return (B_FALSE); 475 } 476 477 static void 478 siena_intr_status_line( 479 __in efx_nic_t *enp, 480 __out boolean_t *fatalp, 481 __out uint32_t *qmaskp) 482 { 483 efx_intr_t *eip = &(enp->en_intr); 484 efx_dword_t dword; 485 486 EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC); 487 EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_INTR); 488 489 /* 490 * Read the queue mask and implicitly acknowledge the 491 * interrupt. 492 */ 493 EFX_BAR_READD(enp, FR_BZ_INT_ISR0_REG, &dword, B_FALSE); 494 *qmaskp = EFX_DWORD_FIELD(dword, EFX_DWORD_0); 495 496 EFSYS_PROBE1(qmask, uint32_t, *qmaskp); 497 498 if (*qmaskp & (1U << eip->ei_level)) 499 *fatalp = siena_intr_check_fatal(enp); 500 else 501 *fatalp = B_FALSE; 502 } 503 504 static void 505 siena_intr_status_message( 506 __in efx_nic_t *enp, 507 __in unsigned int message, 508 __out boolean_t *fatalp) 509 { 510 efx_intr_t *eip = &(enp->en_intr); 511 512 EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC); 513 EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_INTR); 514 515 if (message == eip->ei_level) 516 *fatalp = siena_intr_check_fatal(enp); 517 else 518 *fatalp = B_FALSE; 519 } 520 521 static void 522 siena_intr_fatal( 523 __in efx_nic_t *enp) 524 { 525 #if EFSYS_OPT_DECODE_INTR_FATAL 526 efx_oword_t fatal; 527 efx_oword_t mem_per; 528 529 EFX_BAR_READO(enp, FR_AZ_FATAL_INTR_REG_KER, &fatal); 530 EFX_ZERO_OWORD(mem_per); 531 532 if (EFX_OWORD_FIELD(fatal, FRF_AZ_SRM_PERR_INT_KER) != 0 || 533 EFX_OWORD_FIELD(fatal, FRF_AZ_MEM_PERR_INT_KER) != 0) 534 EFX_BAR_READO(enp, FR_AZ_MEM_STAT_REG, &mem_per); 535 536 if (EFX_OWORD_FIELD(fatal, FRF_AZ_SRAM_OOB_INT_KER) != 0) 537 EFSYS_ERR(enp->en_esip, EFX_ERR_SRAM_OOB, 0, 0); 538 539 if (EFX_OWORD_FIELD(fatal, FRF_AZ_BUFID_DC_OOB_INT_KER) != 0) 540 EFSYS_ERR(enp->en_esip, EFX_ERR_BUFID_DC_OOB, 0, 0); 541 542 if (EFX_OWORD_FIELD(fatal, FRF_AZ_MEM_PERR_INT_KER) != 0) 543 EFSYS_ERR(enp->en_esip, EFX_ERR_MEM_PERR, 544 EFX_OWORD_FIELD(mem_per, EFX_DWORD_0), 545 EFX_OWORD_FIELD(mem_per, EFX_DWORD_1)); 546 547 if (EFX_OWORD_FIELD(fatal, FRF_AZ_RBUF_OWN_INT_KER) != 0) 548 EFSYS_ERR(enp->en_esip, EFX_ERR_RBUF_OWN, 0, 0); 549 550 if (EFX_OWORD_FIELD(fatal, FRF_AZ_TBUF_OWN_INT_KER) != 0) 551 EFSYS_ERR(enp->en_esip, EFX_ERR_TBUF_OWN, 0, 0); 552 553 if (EFX_OWORD_FIELD(fatal, FRF_AZ_RDESCQ_OWN_INT_KER) != 0) 554 EFSYS_ERR(enp->en_esip, EFX_ERR_RDESQ_OWN, 0, 0); 555 556 if (EFX_OWORD_FIELD(fatal, FRF_AZ_TDESCQ_OWN_INT_KER) != 0) 557 EFSYS_ERR(enp->en_esip, EFX_ERR_TDESQ_OWN, 0, 0); 558 559 if (EFX_OWORD_FIELD(fatal, FRF_AZ_EVQ_OWN_INT_KER) != 0) 560 EFSYS_ERR(enp->en_esip, EFX_ERR_EVQ_OWN, 0, 0); 561 562 if (EFX_OWORD_FIELD(fatal, FRF_AZ_EVF_OFLO_INT_KER) != 0) 563 EFSYS_ERR(enp->en_esip, EFX_ERR_EVFF_OFLO, 0, 0); 564 565 if (EFX_OWORD_FIELD(fatal, FRF_AZ_ILL_ADR_INT_KER) != 0) 566 EFSYS_ERR(enp->en_esip, EFX_ERR_ILL_ADDR, 0, 0); 567 568 if (EFX_OWORD_FIELD(fatal, FRF_AZ_SRM_PERR_INT_KER) != 0) 569 EFSYS_ERR(enp->en_esip, EFX_ERR_SRAM_PERR, 570 EFX_OWORD_FIELD(mem_per, EFX_DWORD_0), 571 EFX_OWORD_FIELD(mem_per, EFX_DWORD_1)); 572 #else 573 EFSYS_ASSERT(0); 574 #endif 575 } 576 577 static void 578 siena_intr_fini( 579 __in efx_nic_t *enp) 580 { 581 efx_oword_t oword; 582 583 /* Clear the interrupt address register */ 584 EFX_ZERO_OWORD(oword); 585 EFX_BAR_WRITEO(enp, FR_AZ_INT_ADR_REG_KER, &oword); 586 } 587 588 #endif /* EFSYS_OPT_SIENA */ 589