arch/ia64/sn/io/sn2/pcibr/pcibr_reg.c

   1 /*
   2  * This file is subject to the terms and conditions of the GNU General Public
   3  * License.  See the file "COPYING" in the main directory of this archive
   4  * for more details.
   5  *
   6  * Copyright (C) 2003 Silicon Graphics, Inc. All rights reserved.
   7  */
   8
   9 #include <linux/types.h>
  10 #include <asm/sn/sgi.h>
  11 #include <asm/sn/addrs.h>
  12 #include <asm/sn/pci/pcibr.h>
  13 #include <asm/sn/pci/pcibr_private.h>
  14 #include <asm/sn/pci/pci_defs.h>
  15
  16
  17 /*
  18  * Identification Register Access -- Read Only                      0000_0000
  19  */
  20 static uint64_t
  21 __pcireg_id_get(pic_t *bridge)
  22 {
  23         return bridge->p_wid_id;
  24 }
  25
  26 uint64_t
  27 pcireg_bridge_id_get(void *ptr)
  28 {
  29         return __pcireg_id_get((pic_t *)ptr);
  30 }
  31
  32 uint64_t
  33 pcireg_id_get(pcibr_soft_t ptr)
  34 {
  35         return __pcireg_id_get((pic_t *)ptr->bs_base);
  36 }
  37
  38
  39
  40 /*
  41  * Address Bus Side Holding Register Access -- Read Only            0000_0010
  42  */
  43 uint64_t
  44 pcireg_bus_err_get(pcibr_soft_t ptr)
  45 {
  46         pic_t *bridge = (pic_t *)ptr->bs_base;
  47
  48         return bridge->p_wid_err;
  49 }
  50
  51
  52 /*
  53  * Control Register Access -- Read/Write                            0000_0020
  54  */
  55 static uint64_t
  56 __pcireg_control_get(pic_t *bridge)
  57 {
  58         return bridge->p_wid_control;
  59 }
  60
  61 uint64_t
  62 pcireg_bridge_control_get(void *ptr)
  63 {
  64         return __pcireg_control_get((pic_t *)ptr);
  65 }
  66
  67 uint64_t
  68 pcireg_control_get(pcibr_soft_t ptr)
  69 {
  70         return __pcireg_control_get((pic_t *)ptr->bs_base);
  71 }
  72
  73
  74 void
  75 pcireg_control_set(pcibr_soft_t ptr, uint64_t val)
  76 {
  77         pic_t *bridge = (pic_t *)ptr->bs_base;
  78
  79         /* WAR for PV 439897 & 454474.  Add a readback of the control
  80          * register.  Lock to protect against MP accesses to this
  81          * register along with other write-only registers (See PVs).
  82          * This register isnt accessed in the "hot path" so the splhi
  83          * shouldn't be a bottleneck
  84          */
  85
  86         bridge->p_wid_control = val;
  87         bridge->p_wid_control;  /* WAR */
  88 }
  89
  90
  91 void
  92 pcireg_control_bit_clr(pcibr_soft_t ptr, uint64_t bits)
  93 {
  94         pic_t *bridge = (pic_t *)ptr->bs_base;
  95
  96         /* WAR for PV 439897 & 454474.  Add a readback of the control
  97          * register.  Lock to protect against MP accesses to this
  98          * register along with other write-only registers (See PVs).
  99          * This register isnt accessed in the "hot path" so the splhi
 100          * shouldn't be a bottleneck
 101          */
 102
 103         bridge->p_wid_control &= ~bits;
 104         bridge->p_wid_control;  /* WAR */
 105 }
 106
 107
 108 void
 109 pcireg_control_bit_set(pcibr_soft_t ptr, uint64_t bits)
 110 {
 111         pic_t *bridge = (pic_t *)ptr->bs_base;
 112
 113         /* WAR for PV 439897 & 454474.  Add a readback of the control
 114          * register.  Lock to protect against MP accesses to this
 115          * register along with other write-only registers (See PVs).
 116          * This register isnt accessed in the "hot path" so the splhi
 117          * shouldn't be a bottleneck
 118          */
 119
 120         bridge->p_wid_control |= bits;
 121         bridge->p_wid_control;  /* WAR */
 122 }
 123
 124 /*
 125  * Bus Speed (from control register); -- Read Only access           0000_0020
 126  * 0x00 == 33MHz, 0x01 == 66MHz, 0x10 == 100MHz, 0x11 == 133MHz
 127  */
 128 uint64_t
 129 pcireg_speed_get(pcibr_soft_t ptr)
 130 {
 131         uint64_t speedbits;
 132         pic_t *bridge = (pic_t *)ptr->bs_base;
 133
 134         speedbits = bridge->p_wid_control & PIC_CTRL_PCI_SPEED;
 135         return (speedbits >> 4);
 136 }
 137
 138 /*
 139  * Bus Mode (ie. PCIX or PCI) (from Status register);               0000_0008
 140  * 0x0 == PCI, 0x1 == PCI-X
 141  */
 142 uint64_t
 143 pcireg_mode_get(pcibr_soft_t ptr)
 144 {
 145         uint64_t pcix_active_bit;
 146         pic_t *bridge = (pic_t *)ptr->bs_base;
 147
 148         pcix_active_bit = bridge->p_wid_stat & PIC_STAT_PCIX_ACTIVE;
 149         return (pcix_active_bit >> PIC_STAT_PCIX_ACTIVE_SHFT);
 150 }
 151
 152 void
 153 pcireg_req_timeout_set(pcibr_soft_t ptr, uint64_t val)
 154 {
 155         pic_t *bridge = (pic_t *)ptr->bs_base;
 156
 157         bridge->p_wid_req_timeout = val;
 158 }
 159
 160 /*
 161  * Interrupt Destination Addr Register Access -- Read/Write         0000_0038
 162  */
 163
 164 void
 165 pcireg_intr_dst_set(pcibr_soft_t ptr, uint64_t val)
 166 {
 167         pic_t *bridge = (pic_t *)ptr->bs_base;
 168
 169         bridge->p_wid_int = val;
 170 }
 171
 172 /*
 173  * Intr Destination Addr Reg Access (target_id) -- Read/Write       0000_0038
 174  */
 175 uint64_t
 176 pcireg_intr_dst_target_id_get(pcibr_soft_t ptr)
 177 {
 178         uint64_t tid_bits;
 179         pic_t *bridge = (pic_t *)ptr->bs_base;
 180
 181         tid_bits = (bridge->p_wid_int & PIC_INTR_DEST_TID);
 182         return (tid_bits >> PIC_INTR_DEST_TID_SHFT);
 183 }
 184
 185 void
 186 pcireg_intr_dst_target_id_set(pcibr_soft_t ptr, uint64_t target_id)
 187 {
 188         pic_t *bridge = (pic_t *)ptr->bs_base;
 189
 190         bridge->p_wid_int &= ~PIC_INTR_DEST_TID;
 191         bridge->p_wid_int |=
 192                     ((target_id << PIC_INTR_DEST_TID_SHFT) & PIC_INTR_DEST_TID);
 193 }
 194
 195 /*
 196  * Intr Destination Addr Register Access (addr) -- Read/Write       0000_0038
 197  */
 198 uint64_t
 199 pcireg_intr_dst_addr_get(pcibr_soft_t ptr)
 200 {
 201         pic_t *bridge = (pic_t *)ptr->bs_base;
 202
 203         return bridge->p_wid_int & PIC_XTALK_ADDR_MASK;
 204 }
 205
 206 void
 207 pcireg_intr_dst_addr_set(pcibr_soft_t ptr, uint64_t addr)
 208 {
 209         pic_t *bridge = (pic_t *)ptr->bs_base;
 210
 211         bridge->p_wid_int &= ~PIC_XTALK_ADDR_MASK;
 212         bridge->p_wid_int |= (addr & PIC_XTALK_ADDR_MASK);
 213 }
 214
 215 /*
 216  * Cmd Word Holding Bus Side Error Register Access -- Read Only     0000_0040
 217  */
 218 uint64_t
 219 pcireg_cmdword_err_get(pcibr_soft_t ptr)
 220 {
 221         pic_t *bridge = (pic_t *)ptr->bs_base;
 222
 223         return bridge->p_wid_err_cmdword;
 224 }
 225
 226 /*
 227  * PCI/PCIX Target Flush Register Access -- Read Only               0000_0050
 228  */
 229 uint64_t
 230 pcireg_tflush_get(pcibr_soft_t ptr)
 231 {
 232         uint64_t ret = 0;
 233         pic_t *bridge = (pic_t *)ptr->bs_base;
 234
 235         ret = bridge->p_wid_tflush;
 236
 237         /* Read of the Targer Flush should always return zero */
 238         ASSERT_ALWAYS(ret == 0);
 239         return ret;
 240 }
 241
 242 /*
 243  * Cmd Word Holding Link Side Error Register Access -- Read Only    0000_0058
 244  */
 245 uint64_t
 246 pcireg_linkside_err_get(pcibr_soft_t ptr)
 247 {
 248         pic_t *bridge = (pic_t *)ptr->bs_base;
 249
 250         return bridge->p_wid_aux_err;
 251 }
 252
 253 /*
 254  * PCI Response Buffer Address Holding Register -- Read Only        0000_0068
 255  */
 256 uint64_t
 257 pcireg_resp_err_get(pcibr_soft_t ptr)
 258 {
 259         pic_t *bridge = (pic_t *)ptr->bs_base;
 260
 261         return bridge->p_wid_resp;
 262 }
 263
 264 /*
 265  * PCI Resp Buffer Address Holding Reg (Address) -- Read Only       0000_0068
 266  */
 267 uint64_t
 268 pcireg_resp_err_addr_get(pcibr_soft_t ptr)
 269 {
 270         pic_t *bridge = (pic_t *)ptr->bs_base;
 271
 272         return bridge->p_wid_resp & PIC_RSP_BUF_ADDR;
 273 }
 274
 275 /*
 276  * PCI Resp Buffer Address Holding Register (Buffer)-- Read Only    0000_0068
 277  */
 278 uint64_t
 279 pcireg_resp_err_buf_get(pcibr_soft_t ptr)
 280 {
 281         uint64_t bufnum_bits;
 282         pic_t *bridge = (pic_t *)ptr->bs_base;
 283
 284         bufnum_bits = (bridge->p_wid_resp_upper & PIC_RSP_BUF_NUM);
 285         return (bufnum_bits >> PIC_RSP_BUF_NUM_SHFT);
 286 }
 287
 288 /*
 289  * PCI Resp Buffer Address Holding Register (Device)-- Read Only    0000_0068
 290  */
 291 uint64_t
 292 pcireg_resp_err_dev_get(pcibr_soft_t ptr)
 293 {
 294         uint64_t devnum_bits;
 295         pic_t *bridge = (pic_t *)ptr->bs_base;
 296
 297         devnum_bits = (bridge->p_wid_resp_upper & PIC_RSP_BUF_DEV_NUM);
 298         return (devnum_bits >> PIC_RSP_BUF_DEV_NUM_SHFT);
 299 }
 300
 301 /*
 302  * Address Holding Register Link Side Errors -- Read Only           0000_0078
 303  */
 304 uint64_t
 305 pcireg_linkside_err_addr_get(pcibr_soft_t ptr)
 306 {
 307         pic_t *bridge = (pic_t *)ptr->bs_base;
 308
 309         return bridge->p_wid_addr_lkerr;
 310 }
 311
 312 void
 313 pcireg_dirmap_wid_set(pcibr_soft_t ptr, uint64_t target)
 314 {
 315         pic_t *bridge = (pic_t *)ptr->bs_base;
 316
 317         bridge->p_dir_map &= ~PIC_DIRMAP_WID;
 318         bridge->p_dir_map |=
 319                     ((target << PIC_DIRMAP_WID_SHFT) & PIC_DIRMAP_WID);
 320 }
 321
 322 void
 323 pcireg_dirmap_diroff_set(pcibr_soft_t ptr, uint64_t dir_off)
 324 {
 325         pic_t *bridge = (pic_t *)ptr->bs_base;
 326
 327         bridge->p_dir_map &= ~PIC_DIRMAP_DIROFF;
 328         bridge->p_dir_map |= (dir_off & PIC_DIRMAP_DIROFF);
 329 }
 330
 331 void
 332 pcireg_dirmap_add512_set(pcibr_soft_t ptr)
 333 {
 334         pic_t *bridge = (pic_t *)ptr->bs_base;
 335
 336         bridge->p_dir_map |= PIC_DIRMAP_ADD512;
 337 }
 338
 339 void
 340 pcireg_dirmap_add512_clr(pcibr_soft_t ptr)
 341 {
 342         pic_t *bridge = (pic_t *)ptr->bs_base;
 343
 344         bridge->p_dir_map &= ~PIC_DIRMAP_ADD512;
 345 }
 346
 347 /*
 348  * PCI Page Map Fault Address Register Access -- Read Only          0000_0090
 349  */
 350 uint64_t
 351 pcireg_map_fault_get(pcibr_soft_t ptr)
 352 {
 353         pic_t *bridge = (pic_t *)ptr->bs_base;
 354
 355         return bridge->p_map_fault;
 356 }
 357
 358 /*
 359  * Arbitration Register Access -- Read/Write                        0000_00A0
 360  */
 361 uint64_t
 362 pcireg_arbitration_get(pcibr_soft_t ptr)
 363 {
 364         pic_t *bridge = (pic_t *)ptr->bs_base;
 365
 366         return bridge->p_arb;
 367 }
 368
 369 void
 370 pcireg_arbitration_bit_set(pcibr_soft_t ptr, uint64_t bits)
 371 {
 372         pic_t *bridge = (pic_t *)ptr->bs_base;
 373
 374         bridge->p_arb |= bits;
 375 }
 376
 377 /*
 378  * Internal Ram Parity Error Register Access -- Read Only           0000_00B0
 379  */
 380 uint64_t
 381 pcireg_parity_err_get(pcibr_soft_t ptr)
 382 {
 383         pic_t *bridge = (pic_t *)ptr->bs_base;
 384
 385         return bridge->p_ate_parity_err;
 386 }
 387
 388 /*
 389  * Type 1 Configuration Register Access -- Read/Write               0000_00C8
 390  */
 391 void
 392 pcireg_type1_cntr_set(pcibr_soft_t ptr, uint64_t val)
 393 {
 394         pic_t *bridge = (pic_t *)ptr->bs_base;
 395
 396         bridge->p_pci_cfg = val;
 397 }
 398
 399 /*
 400  * PCI Bus Error Lower Addr Holding Reg Access -- Read Only         0000_00D8
 401  */
 402 uint64_t
 403 pcireg_pci_bus_addr_get(pcibr_soft_t ptr)
 404 {
 405         pic_t *bridge = (pic_t *)ptr->bs_base;
 406
 407         return bridge->p_pci_err;
 408 }
 409
 410 /*
 411  * PCI Bus Error Addr Holding Reg Access (Address) -- Read Only     0000_00D8
 412  */
 413 uint64_t
 414 pcireg_pci_bus_addr_addr_get(pcibr_soft_t ptr)
 415 {
 416         pic_t *bridge = (pic_t *)ptr->bs_base;
 417
 418         return bridge->p_pci_err & PIC_XTALK_ADDR_MASK;
 419 }
 420
 421 /*
 422  * Interrupt Status Register Access -- Read Only                    0000_0100
 423  */
 424 uint64_t
 425 pcireg_intr_status_get(pcibr_soft_t ptr)
 426 {
 427         pic_t *bridge = (pic_t *)ptr->bs_base;
 428
 429         return bridge->p_int_status;
 430 }
 431
 432 /*
 433  * Interrupt Enable Register Access -- Read/Write                   0000_0108
 434  */
 435 uint64_t
 436 pcireg_intr_enable_get(pcibr_soft_t ptr)
 437 {
 438         pic_t *bridge = (pic_t *)ptr->bs_base;
 439
 440         return bridge->p_int_enable;
 441 }
 442
 443 void
 444 pcireg_intr_enable_set(pcibr_soft_t ptr, uint64_t val)
 445 {
 446         pic_t *bridge = (pic_t *)ptr->bs_base;
 447
 448         bridge->p_int_enable = val;
 449 }
 450
 451 void
 452 pcireg_intr_enable_bit_clr(pcibr_soft_t ptr, uint64_t bits)
 453 {
 454         pic_t *bridge = (pic_t *)ptr->bs_base;
 455
 456         bridge->p_int_enable &= ~bits;
 457 }
 458
 459 void
 460 pcireg_intr_enable_bit_set(pcibr_soft_t ptr, uint64_t bits)
 461 {
 462         pic_t *bridge = (pic_t *)ptr->bs_base;
 463
 464         bridge->p_int_enable |= bits;
 465 }
 466
 467 /*
 468  * Interrupt Reset Register Access -- Write Only                    0000_0110
 469  */
 470 void
 471 pcireg_intr_reset_set(pcibr_soft_t ptr, uint64_t val)
 472 {
 473         pic_t *bridge = (pic_t *)ptr->bs_base;
 474
 475         bridge->p_int_rst_stat = val;
 476 }
 477
 478 void
 479 pcireg_intr_mode_set(pcibr_soft_t ptr, uint64_t val)
 480 {
 481         pic_t *bridge = (pic_t *)ptr->bs_base;
 482
 483         bridge->p_int_mode = val;
 484 }
 485
 486 void
 487 pcireg_intr_device_set(pcibr_soft_t ptr, uint64_t val)
 488 {
 489         pic_t *bridge = (pic_t *)ptr->bs_base;
 490
 491         bridge->p_int_device = val;
 492 }
 493
 494 static void
 495 __pcireg_intr_device_bit_set(pic_t *bridge, uint64_t bits)
 496 {
 497         bridge->p_int_device |= bits;
 498 }
 499
 500 void
 501 pcireg_bridge_intr_device_bit_set(void *ptr, uint64_t bits)
 502 {
 503         __pcireg_intr_device_bit_set((pic_t *)ptr, bits);
 504 }
 505
 506 void
 507 pcireg_intr_device_bit_set(pcibr_soft_t ptr, uint64_t bits)
 508 {
 509         __pcireg_intr_device_bit_set((pic_t *)ptr->bs_base, bits);
 510 }
 511
 512 void
 513 pcireg_intr_device_bit_clr(pcibr_soft_t ptr, uint64_t bits)
 514 {
 515         pic_t *bridge = (pic_t *)ptr->bs_base;
 516
 517         bridge->p_int_device &= ~bits;
 518 }
 519
 520 /*
 521  * Host Error Interrupt Field Register Access -- Read/Write         0000_0128
 522  */
 523 void
 524 pcireg_intr_host_err_set(pcibr_soft_t ptr, uint64_t val)
 525 {
 526         pic_t *bridge = (pic_t *)ptr->bs_base;
 527
 528         bridge->p_int_host_err = val;
 529 }
 530
 531 /*
 532  * Interrupt Host Address Register -- Read/Write        0000_0130 - 0000_0168
 533  */
 534 uint64_t
 535 pcireg_intr_addr_get(pcibr_soft_t ptr, int int_n)
 536 {
 537         pic_t *bridge = (pic_t *)ptr->bs_base;
 538
 539         return bridge->p_int_addr[int_n];
 540 }
 541
 542 static void
 543 __pcireg_intr_addr_set(pic_t *bridge, int int_n, uint64_t val)
 544 {
 545         bridge->p_int_addr[int_n] = val;
 546 }
 547
 548 void
 549 pcireg_bridge_intr_addr_set(void *ptr, int int_n, uint64_t val)
 550 {
 551         __pcireg_intr_addr_set((pic_t *)ptr, int_n, val);
 552 }
 553
 554 void
 555 pcireg_intr_addr_set(pcibr_soft_t ptr, int int_n, uint64_t val)
 556 {
 557         __pcireg_intr_addr_set((pic_t *)ptr->bs_base, int_n, val);
 558 }
 559
 560 void *
 561 pcireg_intr_addr_addr(pcibr_soft_t ptr, int int_n)
 562 {
 563         pic_t *bridge = (pic_t *)ptr->bs_base;
 564
 565         return (void *)&(bridge->p_int_addr[int_n]);
 566 }
 567
 568 static void
 569 __pcireg_intr_addr_vect_set(pic_t *bridge, int int_n, uint64_t vect)
 570 {
 571         bridge->p_int_addr[int_n] &= ~PIC_HOST_INTR_FLD;
 572         bridge->p_int_addr[int_n] |=
 573                     ((vect << PIC_HOST_INTR_FLD_SHFT) & PIC_HOST_INTR_FLD);
 574 }
 575
 576 void
 577 pcireg_bridge_intr_addr_vect_set(void *ptr, int int_n, uint64_t vect)
 578 {
 579         __pcireg_intr_addr_vect_set((pic_t *)ptr, int_n, vect);
 580 }
 581
 582 void
 583 pcireg_intr_addr_vect_set(pcibr_soft_t ptr, int int_n, uint64_t vect)
 584 {
 585         __pcireg_intr_addr_vect_set((pic_t *)ptr->bs_base, int_n, vect);
 586 }
 587
 588
 589
 590 /*
 591  * Intr Host Address Register (int_addr) -- Read/Write  0000_0130 - 0000_0168
 592  */
 593 static void
 594 __pcireg_intr_addr_addr_set(pic_t *bridge, int int_n, uint64_t addr)
 595 {
 596         bridge->p_int_addr[int_n] &= ~PIC_HOST_INTR_ADDR;
 597         bridge->p_int_addr[int_n] |= (addr & PIC_HOST_INTR_ADDR);
 598 }
 599
 600 void
 601 pcireg_bridge_intr_addr_addr_set(void *ptr, int int_n, uint64_t addr)
 602 {
 603         __pcireg_intr_addr_addr_set((pic_t *)ptr, int_n, addr);
 604 }
 605
 606 void
 607 pcireg_intr_addr_addr_set(pcibr_soft_t ptr, int int_n, uint64_t addr)
 608 {
 609         __pcireg_intr_addr_addr_set((pic_t *)ptr->bs_base, int_n, addr);
 610 }
 611
 612 /*
 613  * Multiple Interrupt Register Access -- Read Only                  0000_0178
 614  */
 615 uint64_t
 616 pcireg_intr_multiple_get(pcibr_soft_t ptr)
 617 {
 618         pic_t *bridge = (pic_t *)ptr->bs_base;
 619
 620         return bridge->p_mult_int;
 621 }
 622
 623 /*
 624  * Force Always Intr Register Access -- Write Only      0000_0180 - 0000_01B8
 625  */
 626 static void *
 627 __pcireg_force_always_addr_get(pic_t *bridge, int int_n)
 628 {
 629         return (void *)&(bridge->p_force_always[int_n]);
 630 }
 631
 632 void *
 633 pcireg_bridge_force_always_addr_get(void *ptr, int int_n)
 634 {
 635         return __pcireg_force_always_addr_get((pic_t *)ptr, int_n);
 636 }
 637
 638 void *
 639 pcireg_force_always_addr_get(pcibr_soft_t ptr, int int_n)
 640 {
 641         return __pcireg_force_always_addr_get((pic_t *)ptr->bs_base, int_n);
 642 }
 643
 644 /*
 645  * Force Interrupt Register Access -- Write Only        0000_01C0 - 0000_01F8
 646  */
 647 void
 648 pcireg_force_intr_set(pcibr_soft_t ptr, int int_n)
 649 {
 650         pic_t *bridge = (pic_t *)ptr->bs_base;
 651
 652         bridge->p_force_pin[int_n] = 1;
 653 }
 654
 655 /*
 656  * Device(x) Register Access -- Read/Write              0000_0200 - 0000_0218
 657  */
 658 uint64_t
 659 pcireg_device_get(pcibr_soft_t ptr, int device)
 660 {
 661         pic_t *bridge = (pic_t *)ptr->bs_base;
 662
 663         ASSERT_ALWAYS((device >= 0) && (device <= 3));
 664         return bridge->p_device[device];
 665 }
 666
 667 void
 668 pcireg_device_set(pcibr_soft_t ptr, int device, uint64_t val)
 669 {
 670         pic_t *bridge = (pic_t *)ptr->bs_base;
 671
 672         ASSERT_ALWAYS((device >= 0) && (device <= 3));
 673         bridge->p_device[device] = val;
 674 }
 675
 676 /*
 677  * Device(x) Write Buffer Flush Reg Access -- Read Only 0000_0240 - 0000_0258
 678  */
 679 uint64_t
 680 pcireg_wrb_flush_get(pcibr_soft_t ptr, int device)
 681 {
 682         pic_t *bridge = (pic_t *)ptr->bs_base;
 683         uint64_t ret = 0;
 684
 685         ASSERT_ALWAYS((device >= 0) && (device <= 3));
 686         ret = bridge->p_wr_req_buf[device];
 687
 688         /* Read of the Write Buffer Flush should always return zero */
 689         ASSERT_ALWAYS(ret == 0);
 690         return ret;
 691 }
 692
 693 /*
 694  * Even/Odd RRB Register Access -- Read/Write           0000_0280 - 0000_0288
 695  */
 696 uint64_t
 697 pcireg_rrb_get(pcibr_soft_t ptr, int even_odd)
 698 {
 699         pic_t *bridge = (pic_t *)ptr->bs_base;
 700
 701         return bridge->p_rrb_map[even_odd];
 702 }
 703
 704 void
 705 pcireg_rrb_set(pcibr_soft_t ptr, int even_odd, uint64_t val)
 706 {
 707         pic_t *bridge = (pic_t *)ptr->bs_base;
 708
 709         bridge->p_rrb_map[even_odd] = val;
 710 }
 711
 712 void
 713 pcireg_rrb_bit_set(pcibr_soft_t ptr, int even_odd, uint64_t bits)
 714 {
 715         pic_t *bridge = (pic_t *)ptr->bs_base;
 716
 717         bridge->p_rrb_map[even_odd] |= bits;
 718 }
 719
 720 /*
 721  * RRB Status Register Access -- Read Only                          0000_0290
 722  */
 723 uint64_t
 724 pcireg_rrb_status_get(pcibr_soft_t ptr)
 725 {
 726         pic_t *bridge = (pic_t *)ptr->bs_base;
 727
 728         return bridge->p_resp_status;
 729 }
 730
 731 /*
 732  * RRB Clear Register Access -- Write Only                          0000_0298
 733  */
 734 void
 735 pcireg_rrb_clear_set(pcibr_soft_t ptr, uint64_t val)
 736 {
 737         pic_t *bridge = (pic_t *)ptr->bs_base;
 738
 739         bridge->p_resp_clear = val;
 740 }
 741
 742 /*
 743  * PCIX Bus Error Address Register Access -- Read Only              0000_0600
 744  */
 745 uint64_t
 746 pcireg_pcix_bus_err_addr_get(pcibr_soft_t ptr)
 747 {
 748         pic_t *bridge = (pic_t *)ptr->bs_base;
 749
 750         return bridge->p_pcix_bus_err_addr;
 751 }
 752
 753 /*
 754  * PCIX Bus Error Attribute Register Access -- Read Only            0000_0608
 755  */
 756 uint64_t
 757 pcireg_pcix_bus_err_attr_get(pcibr_soft_t ptr)
 758 {
 759         pic_t *bridge = (pic_t *)ptr->bs_base;
 760
 761         return bridge->p_pcix_bus_err_attr;
 762 }
 763
 764 /*
 765  * PCIX Bus Error Data Register Access -- Read Only                 0000_0610
 766  */
 767 uint64_t
 768 pcireg_pcix_bus_err_data_get(pcibr_soft_t ptr)
 769 {
 770         pic_t *bridge = (pic_t *)ptr->bs_base;
 771
 772         return bridge->p_pcix_bus_err_data;
 773 }
 774
 775 /*
 776  * PCIX PIO Split Request Address Register Access -- Read Only      0000_0618
 777  */
 778 uint64_t
 779 pcireg_pcix_pio_split_addr_get(pcibr_soft_t ptr)
 780 {
 781         pic_t *bridge = (pic_t *)ptr->bs_base;
 782
 783         return bridge->p_pcix_pio_split_addr;
 784 }
 785
 786 /*
 787  * PCIX PIO Split Request Attribute Register Access -- Read Only    0000_0620
 788  */
 789 uint64_t
 790 pcireg_pcix_pio_split_attr_get(pcibr_soft_t ptr)
 791 {
 792         pic_t *bridge = (pic_t *)ptr->bs_base;
 793
 794         return bridge->p_pcix_pio_split_attr;
 795 }
 796
 797 /*
 798  * PCIX DMA Request Error Attribute Register Access -- Read Only    0000_0628
 799  */
 800 uint64_t
 801 pcireg_pcix_req_err_attr_get(pcibr_soft_t ptr)
 802 {
 803         pic_t *bridge = (pic_t *)ptr->bs_base;
 804
 805         return bridge->p_pcix_dma_req_err_attr;
 806 }
 807
 808 /*
 809  * PCIX DMA Request Error Address Register Access -- Read Only      0000_0630
 810  */
 811 uint64_t
 812 pcireg_pcix_req_err_addr_get(pcibr_soft_t ptr)
 813 {
 814         pic_t *bridge = (pic_t *)ptr->bs_base;
 815
 816         return bridge->p_pcix_dma_req_err_addr;
 817 }
 818
 819 /*
 820  * Type 0 Configuration Space Access -- Read/Write
 821  */
 822 cfg_p
 823 pcireg_type0_cfg_addr(pcibr_soft_t ptr, uint8_t slot, uint8_t func, int off)
 824 {
 825         pic_t *bridge = (pic_t *)ptr->bs_base;
 826
 827         /* Type 0 Config space accesses on PIC are 1-4, not 0-3 since
 828          * it is a PCIX Bridge.  See sys/PCI/pic.h for explanation.
 829          */
 830         slot++;
 831         ASSERT_ALWAYS(((int) slot >= 1) && ((int) slot <= 4));
 832         return &(bridge->p_type0_cfg_dev[slot].f[func].l[(off / 4)]);
 833 }
 834
 835 /*
 836  * Type 1 Configuration Space Access -- Read/Write
 837  */
 838 cfg_p
 839 pcireg_type1_cfg_addr(pcibr_soft_t ptr, uint8_t func, int offset)
 840 {
 841         pic_t *bridge = (pic_t *)ptr->bs_base;
 842
 843         /*
 844          * Return a config space address for the given slot/func/offset.
 845          * Note the returned ptr is a 32bit word (ie. cfg_p) aligned ptr
 846          * pointing to the 32bit word that contains the "offset" byte.
 847          */
 848         return &(bridge->p_type1_cfg.f[func].l[(offset / 4)]);
 849 }
 850
 851 /*
 852  * Internal ATE SSRAM Access -- Read/Write
 853  */
 854 bridge_ate_t
 855 pcireg_int_ate_get(pcibr_soft_t ptr, int ate_index)
 856 {
 857         pic_t *bridge = (pic_t *)ptr->bs_base;
 858
 859         ASSERT_ALWAYS((ate_index >= 0) && (ate_index <= 1024));
 860         return bridge->p_int_ate_ram[ate_index];
 861 }
 862
 863 void
 864 pcireg_int_ate_set(pcibr_soft_t ptr, int ate_index, bridge_ate_t val)
 865 {
 866         pic_t *bridge = (pic_t *)ptr->bs_base;
 867
 868         ASSERT_ALWAYS((ate_index >= 0) && (ate_index <= 1024));
 869         bridge->p_int_ate_ram[ate_index] = (picate_t) val;
 870 }
 871
 872 bridge_ate_p
 873 pcireg_int_ate_addr(pcibr_soft_t ptr, int ate_index)
 874 {
 875         pic_t *bridge = (pic_t *)ptr->bs_base;
 876
 877         ASSERT_ALWAYS((ate_index >= 0) && (ate_index <= 1024));
 878         return &(bridge->p_int_ate_ram[ate_index]);
 879 }