drivers/net/wireless/bcmdhd4361/include/bcmpcie.h

   1 /*
   2  * Broadcom PCIE
   3  * Software-specific definitions shared between device and host side
   4  * Explains the shared area between host and dongle
   5  *
   6  * Copyright (C) 1999-2019, Broadcom.
   7  *
   8  *      Unless you and Broadcom execute a separate written software license
   9  * agreement governing use of this software, this software is licensed to you
  10  * under the terms of the GNU General Public License version 2 (the "GPL"),
  11  * available at http://www.broadcom.com/licenses/GPLv2.php, with the
  12  * following added to such license:
  13  *
  14  *      As a special exception, the copyright holders of this software give you
  15  * permission to link this software with independent modules, and to copy and
  16  * distribute the resulting executable under terms of your choice, provided that
  17  * you also meet, for each linked independent module, the terms and conditions of
  18  * the license of that module.  An independent module is a module which is not
  19  * derived from this software.  The special exception does not apply to any
  20  * modifications of the software.
  21  *
  22  *      Notwithstanding the above, under no circumstances may you combine this
  23  * software in any way with any other Broadcom software provided under a license
  24  * other than the GPL, without Broadcom's express prior written consent.
  25  *
  26  *
  27  * <<Broadcom-WL-IPTag/Open:>>
  28  *
  29  * $Id: bcmpcie.h 755866 2018-04-05 05:07:41Z $
  30  */
  31
  32 #ifndef _bcmpcie_h_
  33 #define _bcmpcie_h_
  34
  35 #include <typedefs.h>
  36
  37 #define ADDR_64(x)                      (x.addr)
  38 #define HIGH_ADDR_32(x)     ((uint32) (((sh_addr_t) x).high_addr))
  39 #define LOW_ADDR_32(x)      ((uint32) (((sh_addr_t) x).low_addr))
  40
  41 typedef struct {
  42         uint32 low_addr;
  43         uint32 high_addr;
  44 } sh_addr_t;
  45
  46 /* May be overridden by 43xxxxx-roml.mk */
  47 #if !defined(BCMPCIE_MAX_TX_FLOWS)
  48 #define BCMPCIE_MAX_TX_FLOWS    40
  49 #endif /* ! BCMPCIE_MAX_TX_FLOWS */
  50
  51 #define PCIE_SHARED_VERSION_7           0x00007
  52 #define PCIE_SHARED_VERSION_6           0x00006 /* rev6 is compatible with rev 5 */
  53 #define PCIE_SHARED_VERSION_5           0x00005 /* rev6 is compatible with rev 5 */
  54 /**
  55  * Feature flags enabled in dongle. Advertised by dongle to DHD via the PCIe Shared structure that
  56  * is located in device memory.
  57  */
  58 #define PCIE_SHARED_VERSION_MASK        0x000FF
  59 #define PCIE_SHARED_ASSERT_BUILT        0x00100
  60 #define PCIE_SHARED_ASSERT              0x00200
  61 #define PCIE_SHARED_TRAP                0x00400
  62 #define PCIE_SHARED_IN_BRPT             0x00800
  63 #define PCIE_SHARED_SET_BRPT            0x01000
  64 #define PCIE_SHARED_PENDING_BRPT        0x02000
  65 /* BCMPCIE_SUPPORT_TX_PUSH_RING         0x04000 obsolete */
  66 #define PCIE_SHARED_EVT_SEQNUM          0x08000
  67 #define PCIE_SHARED_DMA_INDEX           0x10000
  68
  69 /**
  70  * There are host types where a device interrupt can 'race ahead' of data written by the device into
  71  * host memory. The dongle can avoid this condition using a variety of techniques (read barrier,
  72  * using PCIe Message Signalled Interrupts, or by using the PCIE_DMA_INDEX feature). Unfortunately
  73  * these techniques have drawbacks on router platforms. For these platforms, it was decided to not
  74  * avoid the condition, but to detect the condition instead and act on it.
  75  * D2H M2M DMA Complete Sync mechanism: Modulo-253-SeqNum or XORCSUM
  76  */
  77 #define PCIE_SHARED_D2H_SYNC_SEQNUM     0x20000
  78 #define PCIE_SHARED_D2H_SYNC_XORCSUM    0x40000
  79 #define PCIE_SHARED_D2H_SYNC_MODE_MASK \
  80         (PCIE_SHARED_D2H_SYNC_SEQNUM | PCIE_SHARED_D2H_SYNC_XORCSUM)
  81 #define PCIE_SHARED_IDLE_FLOW_RING              0x80000
  82 #define PCIE_SHARED_2BYTE_INDICES       0x100000
  83
  84 #define PCIE_SHARED2_EXTENDED_TRAP_DATA 0x00000001      /* using flags2 in shared area */
  85 #define PCIE_SHARED2_TXSTATUS_METADATA  0x00000002
  86 #define PCIE_SHARED2_BT_LOGGING         0x00000004      /* BT logging support */
  87 #define PCIE_SHARED2_SNAPSHOT_UPLOAD    0x00000008      /* BT/WLAN snapshot upload support */
  88 #define PCIE_SHARED2_SUBMIT_COUNT_WAR   0x00000010      /* submission count WAR */
  89 #define PCIE_SHARED2_FW_SMALL_MEMDUMP   0x00000200      /* FW small memdump */
  90 #define PCIE_SHARED_FAST_DELETE_RING    0x00000020      /* Fast Delete Ring */
  91 #define PCIE_SHARED_EVENT_BUF_POOL_MAX  0x000000c0      /* event buffer pool max bits */
  92 #define PCIE_SHARED_EVENT_BUF_POOL_MAX_POS     6       /* event buffer pool max bit position */
  93
  94 /* dongle supports fatal buf log collection */
  95 #define PCIE_SHARED_FATAL_LOGBUG_VALID  0x200000
  96
  97 /* Implicit DMA with corerev 19 and after */
  98 #define PCIE_SHARED_IDMA                0x400000
  99
 100 /* MSI support */
 101 #define PCIE_SHARED_D2H_MSI_MULTI_MSG   0x800000
 102
 103 /* IFRM with corerev 19 and after */
 104 #define PCIE_SHARED_IFRM                0x1000000
 105
 106 /**
 107  * From Rev6 and above, suspend/resume can be done using two handshake methods.
 108  * 1. Using ctrl post/ctrl cmpl messages (Default rev6)
 109  * 2. Using Mailbox data (old method as used in rev5)
 110  * This shared flag indicates whether to overide rev6 default method and use mailbox for
 111  * suspend/resume.
 112  */
 113 #define PCIE_SHARED_USE_MAILBOX         0x2000000
 114
 115 /* Firmware compiled for mfgbuild purposes */
 116 #define PCIE_SHARED_MFGBUILD_FW         0x4000000
 117
 118 /* Firmware could use DB0 value as host timestamp */
 119 #define PCIE_SHARED_TIMESTAMP_DB0       0x8000000
 120 /* Firmware could use Hostready (IPC rev7) */
 121 #define PCIE_SHARED_HOSTRDY_SUPPORT     0x10000000
 122
 123 /* When set, Firmwar does not support OOB Device Wake based DS protocol */
 124 #define PCIE_SHARED_NO_OOB_DW           0x20000000
 125
 126 /* When set, Firmwar supports Inband DS protocol */
 127 #define PCIE_SHARED_INBAND_DS           0x40000000
 128
 129 /* use DAR registers */
 130 #define PCIE_SHARED_DAR                 0x80000000
 131
 132 /**
 133  * Following are the shared2 flags. All bits in flags have been used. A flags2
 134  * field got added and the definition for these flags come here:
 135  */
 136 /* WAR: D11 txstatus through unused status field of PCIe completion header */
 137 #define PCIE_SHARED2_D2H_D11_TX_STATUS  0x40000000
 138 #define PCIE_SHARED2_H2D_D11_TX_STATUS  0x80000000
 139
 140 #define PCIE_SHARED2_EXTENDED_TRAP_DATA 0x00000001
 141
 142 #define PCIE_SHARED2_TXSTATUS_METADATA  0x00000002
 143
 144 /* BT logging support */
 145 #define PCIE_SHARED2_BT_LOGGING         0x00000004
 146 /* BT/WLAN snapshot upload support */
 147 #define PCIE_SHARED2_SNAPSHOT_UPLOAD    0x00000008
 148 /* submission count WAR */
 149 #define PCIE_SHARED2_SUBMIT_COUNT_WAR   0x00000010
 150
 151 /* Fast Delete ring support */
 152 #define PCIE_SHARED2_FAST_DELETE_RING   0x00000020
 153
 154 /* Host SCB support */
 155 #define PCIE_SHARED2_HSCB               0x00000800
 156
 157 #define PCIE_SHARED_D2H_MAGIC           0xFEDCBA09
 158 #define PCIE_SHARED_H2D_MAGIC           0x12345678
 159
 160 #define PCIE_SHARED2_PKT_TX_STATUS      0x00000100              /* using flags2 to indicate
 161                                                            firmware support added to reuse
 162                                                            timesync to update PKT txstatus
 163                                                            */
 164 /**
 165  * Message rings convey messages between host and device. They are unidirectional, and are located
 166  * in host memory.
 167  *
 168  * This is the minimal set of message rings, known as 'common message rings':
 169  */
 170 #define BCMPCIE_H2D_MSGRING_CONTROL_SUBMIT              0
 171 #define BCMPCIE_H2D_MSGRING_RXPOST_SUBMIT               1
 172 #define BCMPCIE_D2H_MSGRING_CONTROL_COMPLETE            2
 173 #define BCMPCIE_D2H_MSGRING_TX_COMPLETE                 3
 174 #define BCMPCIE_D2H_MSGRING_RX_COMPLETE                 4
 175 #define BCMPCIE_COMMON_MSGRING_MAX_ID                   4
 176
 177 #define BCMPCIE_H2D_COMMON_MSGRINGS                     2
 178 #define BCMPCIE_D2H_COMMON_MSGRINGS                     3
 179 #define BCMPCIE_COMMON_MSGRINGS                         5
 180
 181 #define BCMPCIE_H2D_MSGRINGS(max_tx_flows) \
 182         (BCMPCIE_H2D_COMMON_MSGRINGS + (max_tx_flows))
 183
 184 /* different ring types */
 185 #define BCMPCIE_H2D_RING_TYPE_CTRL_SUBMIT               0x1
 186 #define BCMPCIE_H2D_RING_TYPE_TXFLOW_RING               0x2
 187 #define BCMPCIE_H2D_RING_TYPE_RXBUFPOST                 0x3
 188 #define BCMPCIE_H2D_RING_TYPE_TXSUBMIT                  0x4
 189 #define BCMPCIE_H2D_RING_TYPE_DBGBUF_SUBMIT             0x5
 190 #define BCMPCIE_H2D_RING_TYPE_BTLOG_SUBMIT              0x6
 191
 192 #define BCMPCIE_D2H_RING_TYPE_CTRL_CPL                  0x1
 193 #define BCMPCIE_D2H_RING_TYPE_TX_CPL                    0x2
 194 #define BCMPCIE_D2H_RING_TYPE_RX_CPL                    0x3
 195 #define BCMPCIE_D2H_RING_TYPE_DBGBUF_CPL                0x4
 196 #define BCMPCIE_D2H_RING_TYPE_AC_RX_COMPLETE            0x5
 197 #define BCMPCIE_D2H_RING_TYPE_BTLOG_CPL         0x6
 198
 199 /**
 200  * H2D and D2H, WR and RD index, are maintained in the following arrays:
 201  * - Array of all H2D WR Indices
 202  * - Array of all H2D RD Indices
 203  * - Array of all D2H WR Indices
 204  * - Array of all D2H RD Indices
 205  *
 206  * The offset of the WR or RD indexes (for common rings) in these arrays are
 207  * listed below. Arrays ARE NOT indexed by a ring's id.
 208  *
 209  * D2H common rings WR and RD index start from 0, even though their ringids
 210  * start from BCMPCIE_H2D_COMMON_MSGRINGS
 211  */
 212
 213 #define BCMPCIE_H2D_RING_IDX(h2d_ring_id) (h2d_ring_id)
 214
 215 enum h2dring_idx {
 216         /* H2D common rings */
 217         BCMPCIE_H2D_MSGRING_CONTROL_SUBMIT_IDX =
 218                 BCMPCIE_H2D_RING_IDX(BCMPCIE_H2D_MSGRING_CONTROL_SUBMIT),
 219         BCMPCIE_H2D_MSGRING_RXPOST_SUBMIT_IDX =
 220                 BCMPCIE_H2D_RING_IDX(BCMPCIE_H2D_MSGRING_RXPOST_SUBMIT),
 221
 222         /* First TxPost's WR or RD index starts after all H2D common rings */
 223         BCMPCIE_H2D_MSGRING_TXFLOW_IDX_START =
 224                 BCMPCIE_H2D_RING_IDX(BCMPCIE_H2D_COMMON_MSGRINGS)
 225 };
 226
 227 #define BCMPCIE_D2H_RING_IDX(d2h_ring_id) \
 228         ((d2h_ring_id) - BCMPCIE_H2D_COMMON_MSGRINGS)
 229
 230 enum d2hring_idx {
 231         /* D2H Common Rings */
 232         BCMPCIE_D2H_MSGRING_CONTROL_COMPLETE_IDX =
 233                 BCMPCIE_D2H_RING_IDX(BCMPCIE_D2H_MSGRING_CONTROL_COMPLETE),
 234         BCMPCIE_D2H_MSGRING_TX_COMPLETE_IDX =
 235                 BCMPCIE_D2H_RING_IDX(BCMPCIE_D2H_MSGRING_TX_COMPLETE),
 236         BCMPCIE_D2H_MSGRING_RX_COMPLETE_IDX =
 237                 BCMPCIE_D2H_RING_IDX(BCMPCIE_D2H_MSGRING_RX_COMPLETE)
 238 };
 239
 240 /**
 241  * Macros for managing arrays of RD WR indices:
 242  * rw_index_sz:
 243  *    - in dongle, rw_index_sz is known at compile time
 244  *    - in host/DHD, rw_index_sz is derived from advertized pci_shared flags
 245  *
 246  *  ring_idx: See h2dring_idx and d2hring_idx
 247  */
 248
 249 /** Offset of a RD or WR index in H2D or D2H indices array */
 250 #define BCMPCIE_RW_INDEX_OFFSET(rw_index_sz, ring_idx) \
 251         ((rw_index_sz) * (ring_idx))
 252
 253 /** Fetch the address of RD or WR index in H2D or D2H indices array */
 254 #define BCMPCIE_RW_INDEX_ADDR(indices_array_base, rw_index_sz, ring_idx) \
 255         (void *)((uint32)(indices_array_base) + \
 256         BCMPCIE_RW_INDEX_OFFSET((rw_index_sz), (ring_idx)))
 257
 258 /** H2D DMA Indices array size: given max flow rings */
 259 #define BCMPCIE_H2D_RW_INDEX_ARRAY_SZ(rw_index_sz, max_tx_flows) \
 260         ((rw_index_sz) * BCMPCIE_H2D_MSGRINGS(max_tx_flows))
 261
 262 /** D2H DMA Indices array size */
 263 #define BCMPCIE_D2H_RW_INDEX_ARRAY_SZ(rw_index_sz) \
 264         ((rw_index_sz) * BCMPCIE_D2H_COMMON_MSGRINGS)
 265
 266 #define HOFFLOAD_MODULES_ENAB(shmem) (0)
 267
 268 /**
 269  * This type is used by a 'message buffer' (which is a FIFO for messages). Message buffers are used
 270  * for host<->device communication and are instantiated on both sides. ring_mem_t is instantiated
 271  * both in host as well as device memory.
 272  */
 273 typedef struct ring_mem {
 274         uint16          idx;       /* ring id */
 275         uint8           type;
 276         uint8           rsvd;
 277         uint16          max_item;  /* Max number of items in flow ring */
 278         uint16          len_items; /* Items are fixed size. Length in bytes of one item */
 279         sh_addr_t       base_addr; /* 64 bits address, either in host or device memory */
 280 } ring_mem_t;
 281
 282 /**
 283  * Per flow ring, information is maintained in device memory, eg at what address the ringmem and
 284  * ringstate are located. The flow ring itself can be instantiated in either host or device memory.
 285  *
 286  * Perhaps this type should be renamed to make clear that it resides in device memory only.
 287  */
 288 typedef struct ring_info {
 289         uint32          ringmem_ptr; /* ring mem location in dongle memory */
 290
 291         /* Following arrays are indexed using h2dring_idx and d2hring_idx, and not
 292          * by a ringid.
 293          */
 294
 295         /* 32bit ptr to arrays of WR or RD indices for all rings in dongle memory */
 296         uint32          h2d_w_idx_ptr; /* Array of all H2D ring's WR indices */
 297         uint32          h2d_r_idx_ptr; /* Array of all H2D ring's RD indices */
 298         uint32          d2h_w_idx_ptr; /* Array of all D2H ring's WR indices */
 299         uint32          d2h_r_idx_ptr; /* Array of all D2H ring's RD indices */
 300
 301         /* PCIE_DMA_INDEX feature: Dongle uses mem2mem DMA to sync arrays in host.
 302          * Host may directly fetch WR and RD indices from these host-side arrays.
 303          *
 304          * 64bit ptr to arrays of WR or RD indices for all rings in host memory.
 305          */
 306         sh_addr_t       h2d_w_idx_hostaddr; /* Array of all H2D ring's WR indices */
 307         sh_addr_t       h2d_r_idx_hostaddr; /* Array of all H2D ring's RD indices */
 308         sh_addr_t       d2h_w_idx_hostaddr; /* Array of all D2H ring's WR indices */
 309         sh_addr_t       d2h_r_idx_hostaddr; /* Array of all D2H ring's RD indices */
 310
 311         uint16          max_tx_flowrings; /* maximum number of H2D rings: common + flow */
 312         uint16          max_submission_queues; /* maximum number of H2D rings: common + flow */
 313         uint16          max_completion_rings; /* maximum number of H2D rings: common + flow */
 314         uint16          max_vdevs; /* max number of virtual interfaces supported */
 315
 316         sh_addr_t       ifrm_w_idx_hostaddr; /* Array of all H2D ring's WR indices for IFRM */
 317 } ring_info_t;
 318
 319 /**
 320  * A structure located in TCM that is shared between host and device, primarily used during
 321  * initialization.
 322  */
 323 typedef struct {
 324         /** shared area version captured at flags 7:0 */
 325         uint32  flags;
 326
 327         uint32  trap_addr;
 328         uint32  assert_exp_addr;
 329         uint32  assert_file_addr;
 330         uint32  assert_line;
 331         uint32  console_addr;           /**< Address of hnd_cons_t */
 332
 333         uint32  msgtrace_addr;
 334
 335         uint32  fwid;
 336
 337         /* Used for debug/flow control */
 338         uint16  total_lfrag_pkt_cnt;
 339         uint16  max_host_rxbufs; /* rsvd in spec */
 340
 341         uint32 dma_rxoffset; /* rsvd in spec */
 342
 343         /** these will be used for sleep request/ack, d3 req/ack */
 344         uint32  h2d_mb_data_ptr;
 345         uint32  d2h_mb_data_ptr;
 346
 347         /* information pertinent to host IPC/msgbuf channels */
 348         /** location in the TCM memory which has the ring_info */
 349         uint32  rings_info_ptr;
 350
 351         /** block of host memory for the scratch buffer */
 352         uint32          host_dma_scratch_buffer_len;
 353         sh_addr_t       host_dma_scratch_buffer;
 354
 355         /* location in host memory for scb host offload structures */
 356         sh_addr_t       host_scb_addr;
 357         uint32          host_scb_size;
 358
 359         /* anonymous union for overloading fields in structure */
 360         union {
 361                 uint32  buzz_dbg_ptr;   /* BUZZZ state format strings and trace buffer */
 362                 struct {
 363                         /* Host provided trap buffer length in words */
 364                         uint16  device_trap_debug_buffer_len;
 365                         uint16  rsvd2;
 366                 };
 367         };
 368
 369         /* rev6 compatible changes */
 370         uint32          flags2;
 371         uint32          host_cap;
 372
 373         /* location in the host address space to write trap indication.
 374         * At this point for the current rev of the spec, firmware will
 375         * support only indications to 32 bit host addresses.
 376         * This essentially is device_trap_debug_buffer_addr
 377         */
 378         sh_addr_t       host_trap_addr;
 379
 380         /* location for host fatal error log buffer start address */
 381         uint32          device_fatal_logbuf_start;
 382
 383         /* location in host memory for offloaded modules */
 384         sh_addr_t       hoffload_addr;
 385 } pciedev_shared_t;
 386
 387 /* Device F/W provides the following access function:
 388  * pciedev_shared_t *hnd_get_pciedev_shared(void);
 389  */
 390
 391 /* host capabilities */
 392 #define HOSTCAP_PCIEAPI_VERSION_MASK            0x000000FF
 393 #define HOSTCAP_H2D_VALID_PHASE                 0x00000100
 394 #define HOSTCAP_H2D_ENABLE_TRAP_ON_BADPHASE     0x00000200
 395 #define HOSTCAP_H2D_ENABLE_HOSTRDY              0x00000400
 396 #define HOSTCAP_DB0_TIMESTAMP                   0x00000800
 397 #define HOSTCAP_DS_NO_OOB_DW                    0x00001000
 398 #define HOSTCAP_DS_INBAND_DW                    0x00002000
 399 #define HOSTCAP_H2D_IDMA                        0x00004000
 400 #define HOSTCAP_H2D_IFRM                        0x00008000
 401 #define HOSTCAP_H2D_DAR                         0x00010000
 402 #define HOSTCAP_EXTENDED_TRAP_DATA              0x00020000
 403 #define HOSTCAP_TXSTATUS_METADATA               0x00040000
 404 #define HOSTCAP_BT_LOGGING                      0x00080000
 405 #define HOSTCAP_SNAPSHOT_UPLOAD                 0x00100000
 406 #define HOSTCAP_FAST_DELETE_RING                0x00200000
 407 #define HOSTCAP_PKT_TXSTATUS                    0x00400000
 408 #define HOSTCAP_UR_FW_NO_TRAP                   0x00800000 /* Don't trap on UR */
 409 #define HOSTCAP_HSCB                            0x02000000
 410 /* Host support for extended device trap debug buffer */
 411 #define HOSTCAP_EXT_TRAP_DBGBUF                 0x04000000
 412
 413 /* extended trap debug buffer allocation sizes. Note that this buffer can be used for
 414  * other trap related purposes also.
 415  */
 416 #define BCMPCIE_HOST_EXT_TRAP_DBGBUF_LEN_MIN    (64u * 1024u)
 417 #define BCMPCIE_HOST_EXT_TRAP_DBGBUF_LEN_MAX    (256u * 1024u)
 418
 419 /**
 420  * Mailboxes notify a remote party that an event took place, using interrupts. They use hardware
 421  * support.
 422  */
 423
 424 /* H2D mail box Data */
 425 #define H2D_HOST_D3_INFORM              0x00000001
 426 #define H2D_HOST_DS_ACK         0x00000002
 427 #define H2D_HOST_DS_NAK         0x00000004
 428 #define H2D_HOST_D0_INFORM_IN_USE       0x00000008
 429 #define H2D_HOST_D0_INFORM              0x00000010
 430 #define H2DMB_DS_ACTIVE                 0x00000020
 431 #define H2DMB_DS_DEVICE_WAKE    0x00000040
 432 #define H2D_HOST_IDMA_INITED    0x00000080
 433 #define H2D_HOST_ACK_NOINT              0x00010000 /* d2h_ack interrupt ignore */
 434 #define H2D_HOST_CONS_INT       0x80000000      /**< h2d int for console cmds  */
 435 #define H2D_FW_TRAP             0x20000000      /**< h2d force TRAP */
 436 #define H2DMB_DS_HOST_SLEEP_INFORM H2D_HOST_D3_INFORM
 437 #define H2DMB_DS_DEVICE_SLEEP_ACK  H2D_HOST_DS_ACK
 438 #define H2DMB_DS_DEVICE_SLEEP_NAK  H2D_HOST_DS_NAK
 439 #define H2DMB_D0_INFORM_IN_USE     H2D_HOST_D0_INFORM_IN_USE
 440 #define H2DMB_D0_INFORM            H2D_HOST_D0_INFORM
 441 #define H2DMB_FW_TRAP              H2D_FW_TRAP
 442 #define H2DMB_HOST_CONS_INT        H2D_HOST_CONS_INT
 443 #define H2DMB_DS_DEVICE_WAKE_ASSERT             H2DMB_DS_DEVICE_WAKE
 444 #define H2DMB_DS_DEVICE_WAKE_DEASSERT   H2DMB_DS_ACTIVE
 445
 446 /* D2H mail box Data */
 447 #define D2H_DEV_D3_ACK                                  0x00000001
 448 #define D2H_DEV_DS_ENTER_REQ                    0x00000002
 449 #define D2H_DEV_DS_EXIT_NOTE                    0x00000004
 450 #define D2HMB_DS_HOST_SLEEP_EXIT_ACK    0x00000008
 451 #define D2H_DEV_IDMA_INITED                             0x00000010
 452 #define D2H_DEV_FWHALT                                  0x10000000
 453 #define D2H_DEV_EXT_TRAP_DATA                   0x20000000
 454 #define D2H_DEV_TRAP_IN_TRAP                    0x40000000
 455 #define D2H_DEV_TRAP_DUE_TO_BT                  0x01000000
 456 /* Indicates trap due to HMAP violation */
 457 #define D2H_DEV_TRAP_DUE_TO_HMAP                0x02000000
 458 /* Indicates whether HMAP violation was Write */
 459 #define D2H_DEV_TRAP_HMAP_WRITE                 0x04000000
 460
 461 #define D2HMB_DS_HOST_SLEEP_ACK         D2H_DEV_D3_ACK
 462 #define D2HMB_DS_DEVICE_SLEEP_ENTER_REQ D2H_DEV_DS_ENTER_REQ
 463 #define D2HMB_DS_DEVICE_SLEEP_EXIT      D2H_DEV_DS_EXIT_NOTE
 464 #define D2HMB_FWHALT                    D2H_DEV_FWHALT
 465 #define D2HMB_TRAP_IN_TRAP              D2H_DEV_TRAP_IN_TRAP
 466 #define D2HMB_EXT_TRAP_DATA             D2H_DEV_EXT_TRAP_DATA
 467 #define D2H_FWTRAP_MASK         0x0000001F      /* Adding maskbits for TRAP information */
 468 #define D2H_DEV_MB_MASK         (D2H_DEV_D3_ACK | D2H_DEV_DS_ENTER_REQ | \
 469                                 D2H_DEV_DS_EXIT_NOTE | D2H_DEV_IDMA_INITED | D2H_DEV_FWHALT | \
 470                                 D2H_FWTRAP_MASK | D2H_DEV_EXT_TRAP_DATA | D2H_DEV_TRAP_IN_TRAP)
 471 #define D2H_DEV_MB_INVALIDATED(x)       ((!x) || (x & ~D2H_DEV_MB_MASK))
 472
 473 /* Size of Extended Trap data Buffer */
 474 #define BCMPCIE_EXT_TRAP_DATA_MAXLEN  4096
 475
 476 /** These macro's operate on type 'inuse_lclbuf_pool_t' and are used by firmware only */
 477 #define PREVTXP(i, d)           (((i) == 0) ? ((d) - 1) : ((i) - 1))
 478 #define NEXTTXP(i, d)           ((((i)+1) >= (d)) ? 0 : ((i)+1))
 479 #define NEXTNTXP(i, n, d)       ((((i)+(n)) >= (d)) ? 0 : ((i)+(n)))
 480 #define NTXPACTIVE(r, w, d)     (((r) <= (w)) ? ((w)-(r)) : ((d)-(r)+(w)))
 481 #define NTXPAVAIL(r, w, d)      (((d) - NTXPACTIVE((r), (w), (d))) > 1)
 482
 483 /* Function can be used to notify host of FW halt */
 484 #define READ_AVAIL_SPACE(w, r, d) ((w >= r) ? (uint32)(w - r) : (uint32)(d - r))
 485 #define WRITE_SPACE_AVAIL_CONTINUOUS(r, w, d) ((w >= r) ? (d - w) : (r - w))
 486 #define WRITE_SPACE_AVAIL(r, w, d) (d - (NTXPACTIVE(r, w, d)) - 1)
 487 #define CHECK_WRITE_SPACE(r, w, d) ((r) > (w)) ? \
 488         (uint32)((r) - (w) - 1) : ((r) == 0 || (w) == 0) ? \
 489         (uint32)((d) - (w) - 1) : (uint32)((d) - (w))
 490
 491 #define CHECK_NOWRITE_SPACE(r, w, d) \
 492         (((uint32)(r) == (uint32)((w) + 1)) || (((r) == 0) && ((w) == ((d) - 1))))
 493
 494 #define WRT_PEND(x)     ((x)->wr_pending)
 495 #define DNGL_RING_WPTR(msgbuf)          (*((msgbuf)->tcm_rs_w_ptr)) /**< advanced by producer */
 496 #define BCMMSGBUF_RING_SET_W_PTR(msgbuf, a)     (DNGL_RING_WPTR(msgbuf) = (a))
 497
 498 #define DNGL_RING_RPTR(msgbuf)          (*((msgbuf)->tcm_rs_r_ptr)) /**< advanced by consumer */
 499 #define BCMMSGBUF_RING_SET_R_PTR(msgbuf, a)     (DNGL_RING_RPTR(msgbuf) = (a))
 500
 501 #define MODULO_RING_IDX(x, y)   ((x) % (y)->bitmap_size)
 502
 503 #define  RING_READ_PTR(x)       ((x)->ringstate->r_offset)
 504 #define  RING_WRITE_PTR(x)      ((x)->ringstate->w_offset)
 505 #define  RING_START_PTR(x)      ((x)->ringmem->base_addr.low_addr)
 506 #define  RING_MAX_ITEM(x)       ((x)->ringmem->max_item)
 507 #define  RING_LEN_ITEMS(x)      ((x)->ringmem->len_items)
 508 #define  HOST_RING_BASE(x)      ((x)->dma_buf.va)
 509 #define  HOST_RING_END(x)       ((uint8 *)HOST_RING_BASE((x)) + \
 510                                         ((RING_MAX_ITEM((x))-1)*RING_LEN_ITEMS((x))))
 511
 512 /* Trap types copied in the pciedev_shared.trap_addr */
 513 #define FW_INITIATED_TRAP_TYPE  (0x1 << 7)
 514 #define HEALTHCHECK_NODS_TRAP_TYPE      (0x1 << 6)
 515
 516 #endif  /* _bcmpcie_h_ */