sys/dev/vxge/vxgehal/vxgehal-doorbells.c

   1 /*-
   2  * Copyright(c) 2002-2011 Exar Corp.
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification are permitted provided the following conditions are met:
   7  *
   8  *    1. Redistributions of source code must retain the above copyright notice,
   9  *       this list of conditions and the following disclaimer.
  10  *
  11  *    2. Redistributions in binary form must reproduce the above copyright
  12  *       notice, this list of conditions and the following disclaimer in the
  13  *       documentation and/or other materials provided with the distribution.
  14  *
  15  *    3. Neither the name of the Exar Corporation nor the names of its
  16  *       contributors may be used to endorse or promote products derived from
  17  *       this software without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  20  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  22  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  23  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  29  * POSSIBILITY OF SUCH DAMAGE.
  30  */
  31 /*$FreeBSD$*/
  32 #include <dev/vxge/vxgehal/vxgehal.h>
  33
  34
  35 /*
  36  * __hal_non_offload_db_post - Post non offload doorbell
  37  *
  38  * @vpath_handle: vpath handle
  39  * @txdl_ptr: The starting location of the TxDL in host memory
  40  * @num_txds: The highest TxD in this TxDL (0 to 255 means 1 to 256)
  41  * @no_snoop: No snoop flags
  42  *
  43  * This function posts a non-offload doorbell to doorbell FIFO
  44  *
  45  */
  46 void
  47 __hal_non_offload_db_post(vxge_hal_vpath_h vpath_handle,
  48     u64 txdl_ptr,
  49     u32 num_txds,
  50     u32 no_snoop)
  51 {
  52         u64 *db_ptr;
  53         __hal_device_t *hldev;
  54         __hal_vpath_handle_t *vp = (__hal_vpath_handle_t *) vpath_handle;
  55
  56         vxge_assert((vpath_handle != NULL) && (txdl_ptr != 0));
  57
  58         hldev = (__hal_device_t *) vp->vpath->hldev;
  59
  60         vxge_hal_trace_log_fifo("==> %s:%s:%d",
  61             __FILE__, __func__, __LINE__);
  62
  63         vxge_hal_trace_log_fifo(
  64             "vpath_handle = 0x"VXGE_OS_STXFMT", txdl_ptr = 0x"VXGE_OS_STXFMT
  65             ", num_txds = %d, no_snoop = %d", (ptr_t) vpath_handle,
  66             (ptr_t) txdl_ptr, num_txds, no_snoop);
  67
  68         db_ptr = &vp->vpath->nofl_db->control_0;
  69
  70         vxge_os_pio_mem_write64(vp->vpath->hldev->header.pdev,
  71             vp->vpath->hldev->header.regh0,
  72             VXGE_HAL_NODBW_TYPE(VXGE_HAL_NODBW_TYPE_NODBW) |
  73             VXGE_HAL_NODBW_LAST_TXD_NUMBER(num_txds) |
  74             VXGE_HAL_NODBW_GET_NO_SNOOP(no_snoop),
  75             db_ptr++);
  76
  77         vxge_os_pio_mem_write64(vp->vpath->hldev->header.pdev,
  78             vp->vpath->hldev->header.regh0,
  79             txdl_ptr,
  80             db_ptr);
  81
  82         vxge_hal_trace_log_fifo("<== %s:%s:%d  Result: 0",
  83             __FILE__, __func__, __LINE__);
  84 }
  85
  86 /*
  87  * __hal_non_offload_db_reset - Reset non offload doorbell fifo
  88  *
  89  * @vpath_handle: vpath handle
  90  *
  91  * This function resets non-offload doorbell FIFO
  92  *
  93  */
  94 vxge_hal_status_e
  95 __hal_non_offload_db_reset(vxge_hal_vpath_h vpath_handle)
  96 {
  97         vxge_hal_status_e status;
  98         __hal_device_t *hldev;
  99         __hal_vpath_handle_t *vp = (__hal_vpath_handle_t *) vpath_handle;
 100
 101         vxge_assert(vpath_handle != NULL);
 102
 103         hldev = (__hal_device_t *) vp->vpath->hldev;
 104
 105         vxge_hal_trace_log_fifo("==> %s:%s:%d",
 106             __FILE__, __func__, __LINE__);
 107
 108         vxge_hal_trace_log_fifo(
 109             "vpath_handle = 0x"VXGE_OS_STXFMT, (ptr_t) vpath_handle);
 110
 111         vxge_os_pio_mem_write64(vp->vpath->hldev->header.pdev,
 112             vp->vpath->hldev->header.regh0,
 113             VXGE_HAL_CMN_RSTHDLR_CFG2_SW_RESET_FIFO0(
 114             1 << (16 - vp->vpath->vp_id)),
 115             &vp->vpath->hldev->common_reg->cmn_rsthdlr_cfg2);
 116
 117         vxge_os_wmb();
 118
 119         status = vxge_hal_device_register_poll(vp->vpath->hldev->header.pdev,
 120             vp->vpath->hldev->header.regh0,
 121             &vp->vpath->hldev->common_reg->cmn_rsthdlr_cfg2, 0,
 122             (u64) VXGE_HAL_CMN_RSTHDLR_CFG2_SW_RESET_FIFO0(
 123             1 << (16 - vp->vpath->vp_id)),
 124             VXGE_HAL_DEF_DEVICE_POLL_MILLIS);
 125
 126         vxge_hal_trace_log_fifo("<== %s:%s:%d  Result: 0",
 127             __FILE__, __func__, __LINE__);
 128
 129         return (status);
 130 }
 131
 132 /*
 133  * __hal_rxd_db_post - Post rxd doorbell
 134  *
 135  * @vpath_handle: vpath handle
 136  * @num_bytes: The number of bytes
 137  *
 138  * This function posts a rxd doorbell
 139  *
 140  */
 141 void
 142 __hal_rxd_db_post(vxge_hal_vpath_h vpath_handle,
 143     u32 num_bytes)
 144 {
 145         __hal_device_t *hldev;
 146         __hal_vpath_handle_t *vp = (__hal_vpath_handle_t *) vpath_handle;
 147
 148         vxge_assert(vpath_handle != NULL);
 149
 150         hldev = (__hal_device_t *) vp->vpath->hldev;
 151
 152         vxge_hal_trace_log_ring("==> %s:%s:%d",
 153             __FILE__, __func__, __LINE__);
 154
 155         vxge_hal_trace_log_fifo(
 156             "vpath_handle = 0x"VXGE_OS_STXFMT", num_bytes = %d",
 157             (ptr_t) vpath_handle, num_bytes);
 158
 159         vxge_os_pio_mem_write64(vp->vpath->hldev->header.pdev,
 160             vp->vpath->hldev->header.regh0,
 161             VXGE_HAL_PRC_RXD_DOORBELL_NEW_QW_CNT((num_bytes >> 3)),
 162             &vp->vpath->vp_reg->prc_rxd_doorbell);
 163
 164         vxge_hal_trace_log_ring("<== %s:%s:%d  Result: 0",
 165             __FILE__, __func__, __LINE__);
 166 }
 167
 168
 169 /*
 170  * __hal_message_db_post - Post message doorbell
 171  *
 172  * @vpath_handle: VPATH handle
 173  * @num_msg_bytes: The number of new message bytes made available
 174  *              by this doorbell entry.
 175  * @immed_msg: Immediate message to be sent
 176  * @immed_msg_len: Immediate message length
 177  *
 178  * This function posts a message doorbell to doorbell FIFO
 179  *
 180  */
 181 void
 182 __hal_message_db_post(vxge_hal_vpath_h vpath_handle,
 183     u32 num_msg_bytes,
 184     u8 *immed_msg,
 185     u32 immed_msg_len)
 186 {
 187         u32 i;
 188         u64 *db_ptr;
 189         __hal_device_t *hldev;
 190         __hal_vpath_handle_t *vp = (__hal_vpath_handle_t *) vpath_handle;
 191
 192         vxge_assert((vpath_handle != NULL) && (num_msg_bytes != 0));
 193
 194         hldev = (__hal_device_t *) vp->vpath->hldev;
 195
 196         vxge_hal_trace_log_dmq("==> %s:%s:%d",
 197             __FILE__, __func__, __LINE__);
 198
 199         vxge_hal_trace_log_dmq("vpath_handle = 0x"VXGE_OS_STXFMT", "
 200             "num_msg_bytes = %d, immed_msg = 0x"VXGE_OS_STXFMT", "
 201             "immed_msg_len = %d", (ptr_t) vpath_handle, num_msg_bytes,
 202             (ptr_t) immed_msg, immed_msg_len);
 203
 204         db_ptr = &vp->vpath->msg_db->control_0;
 205
 206         vxge_os_pio_mem_write64(vp->vpath->hldev->header.pdev,
 207             vp->vpath->hldev->header.regh0,
 208             VXGE_HAL_MDBW_TYPE(VXGE_HAL_MDBW_TYPE_MDBW) |
 209             VXGE_HAL_MDBW_MESSAGE_BYTE_COUNT(num_msg_bytes),
 210             db_ptr++);
 211
 212         vxge_os_pio_mem_write64(vp->vpath->hldev->header.pdev,
 213             vp->vpath->hldev->header.regh0,
 214             VXGE_HAL_MDBW_IMMEDIATE_BYTE_COUNT(immed_msg_len),
 215             db_ptr++);
 216
 217         for (i = 0; i < immed_msg_len / 8; i++) {
 218                 vxge_os_pio_mem_write64(vp->vpath->hldev->header.pdev,
 219                     vp->vpath->hldev->header.regh0,
 220                     *((u64 *) ((void *)&immed_msg[i * 8])),
 221                     db_ptr++);
 222         }
 223
 224         vxge_hal_trace_log_dmq("<== %s:%s:%d  Result: 0",
 225             __FILE__, __func__, __LINE__);
 226 }
 227
 228 /*
 229  * __hal_message_db_reset - Reset message doorbell fifo
 230  *
 231  * @vpath_handle: vpath handle
 232  *
 233  * This function resets message doorbell FIFO
 234  *
 235  */
 236 vxge_hal_status_e
 237 __hal_message_db_reset(vxge_hal_vpath_h vpath_handle)
 238 {
 239         vxge_hal_status_e status;
 240         __hal_device_t *hldev;
 241         __hal_vpath_handle_t *vp = (__hal_vpath_handle_t *) vpath_handle;
 242
 243         vxge_assert(vpath_handle != NULL);
 244
 245         hldev = (__hal_device_t *) vp->vpath->hldev;
 246
 247         vxge_hal_trace_log_dmq("==> %s:%s:%d",
 248             __FILE__, __func__, __LINE__);
 249
 250         vxge_hal_trace_log_dmq("vpath_handle = 0x"VXGE_OS_STXFMT,
 251             (ptr_t) vpath_handle);
 252
 253         vxge_os_pio_mem_write64(vp->vpath->hldev->header.pdev,
 254             vp->vpath->hldev->header.regh0,
 255             VXGE_HAL_CMN_RSTHDLR_CFG3_SW_RESET_FIFO1(
 256             1 << (16 - vp->vpath->vp_id)),
 257             &vp->vpath->hldev->common_reg->cmn_rsthdlr_cfg3);
 258
 259         vxge_os_wmb();
 260
 261         status = vxge_hal_device_register_poll(vp->vpath->hldev->header.pdev,
 262             vp->vpath->hldev->header.regh0,
 263             &vp->vpath->hldev->common_reg->cmn_rsthdlr_cfg3, 0,
 264             (u64) VXGE_HAL_CMN_RSTHDLR_CFG3_SW_RESET_FIFO1(
 265             1 << (16 - vp->vpath->vp_id)),
 266             VXGE_HAL_DEF_DEVICE_POLL_MILLIS);
 267
 268         vxge_hal_trace_log_dmq("<== %s:%s:%d  Result: 0",
 269             __FILE__, __func__, __LINE__);
 270
 271         return (status);
 272 }