/* * __hal_ring_item_dma_offset - Return the dma offset of an item * @mempoolh: Handle to the memory pool of the ring * @item: Item for which to get the dma offset * * This function returns the dma offset of a given item */ static ptrdiff_t __hal_ring_item_dma_offset( vxge_hal_mempool_h mempoolh, void *item) { u32 memblock_idx; void *memblock; vxge_hal_mempool_t *mempool = (vxge_hal_mempool_t *) mempoolh; __hal_device_t *hldev; vxge_assert((mempoolh != NULL) && (item != NULL) && (dma_handle != NULL)); hldev = (__hal_device_t *) mempool->devh; vxge_hal_trace_log_ring("==> %s:%s:%d", __FILE__, __func__, __LINE__); vxge_hal_trace_log_ring( "mempoolh = 0x"VXGE_OS_STXFMT", item = 0x"VXGE_OS_STXFMT, (ptr_t) mempoolh, (ptr_t) item); /* get owner memblock index */ memblock_idx = __hal_ring_block_memblock_idx(item); /* get owner memblock by memblock index */ memblock = __hal_mempool_memblock(mempoolh, memblock_idx); vxge_hal_trace_log_ring("<== %s:%s:%d Result: 0", __FILE__, __func__, __LINE__); return ((u8 *) item - (u8 *) memblock); }
/* * __hal_rxd_db_post - Post rxd doorbell * * @vpath_handle: vpath handle * @num_bytes: The number of bytes * * This function posts a rxd doorbell * */ void __hal_rxd_db_post(vxge_hal_vpath_h vpath_handle, u32 num_bytes) { __hal_device_t *hldev; __hal_vpath_handle_t *vp = (__hal_vpath_handle_t *) vpath_handle; vxge_assert(vpath_handle != NULL); hldev = (__hal_device_t *) vp->vpath->hldev; vxge_hal_trace_log_ring("==> %s:%s:%d", __FILE__, __func__, __LINE__); vxge_hal_trace_log_fifo( "vpath_handle = 0x"VXGE_OS_STXFMT", num_bytes = %d", (ptr_t) vpath_handle, num_bytes); vxge_os_pio_mem_write64(vp->vpath->hldev->header.pdev, vp->vpath->hldev->header.regh0, VXGE_HAL_PRC_RXD_DOORBELL_NEW_QW_CNT((num_bytes >> 3)), &vp->vpath->vp_reg->prc_rxd_doorbell); vxge_hal_trace_log_ring("<== %s:%s:%d Result: 0", __FILE__, __func__, __LINE__); }
/* * __hal_ring_mempool_item_free - Free RxD blockt callback * @mempoolh: Handle to memory pool * @memblock: Address of this memory block * @memblock_index: Index of this memory block * @dma_object: dma object for this block * @item: Pointer to this item * @index: Index of this item in memory block * @is_last: If this is last item in the block * @userdata: Specific data of user * * This function is callback passed to __hal_mempool_free to destroy memory * pool for RxD block */ static vxge_hal_status_e __hal_ring_mempool_item_free( vxge_hal_mempool_h mempoolh, void *memblock, u32 memblock_index, vxge_hal_mempool_dma_t *dma_object, void *item, u32 item_index, u32 is_last, void *userdata) { __hal_ring_t *ring = (__hal_ring_t *) userdata; __hal_device_t *hldev; vxge_assert((item != NULL) && (ring != NULL)); hldev = (__hal_device_t *) ring->channel.devh; vxge_hal_trace_log_pool("==> %s:%s:%d", __FILE__, __func__, __LINE__); vxge_hal_trace_log_pool( "mempoolh = 0x"VXGE_OS_STXFMT", memblock = 0x"VXGE_OS_STXFMT", " "memblock_index = %d, dma_object = 0x"VXGE_OS_STXFMT", " "item = 0x"VXGE_OS_STXFMT", item_index = %d, is_last = %d, " "userdata = 0x"VXGE_OS_STXFMT, (ptr_t) mempoolh, (ptr_t) memblock, memblock_index, (ptr_t) dma_object, (ptr_t) item, item_index, is_last, (ptr_t) userdata); vxge_hal_trace_log_pool("<== %s:%s:%d Result: 0", __FILE__, __func__, __LINE__); return (VXGE_HAL_OK); }
/* * __hal_ifmsg_device_reset_end_poll - Polls for the * srpcim to vpath reset end * @hldev: HAL Device * @vp_id: Vpath id * * Polls for the srpcim to vpath reset end */ vxge_hal_status_e __hal_ifmsg_device_reset_end_poll( __hal_device_t *hldev, u32 vp_id) { vxge_hal_status_e status; vxge_assert(hldev); vxge_hal_trace_log_mrpcim("==> %s:%s:%d", __FILE__, __func__, __LINE__); vxge_hal_trace_log_mrpcim("hldev = 0x"VXGE_OS_STXFMT", vp_id = %d", (ptr_t) hldev, vp_id); status = vxge_hal_device_register_poll( hldev->header.pdev, hldev->header.regh0, &hldev->vpmgmt_reg[vp_id]->srpcim_to_vpath_wmsg, 0, ~((u64) VXGE_HAL_IFMSG_DEVICE_RESET_END_MSG), WAIT_FACTOR * hldev->header.config.device_poll_millis); vxge_hal_trace_log_mrpcim("<== %s:%s:%d Result = 0", __FILE__, __func__, __LINE__); return (status); }
/* * __hal_srpcim_alarm_process - Process Alarms. * @hldev: HAL Device * @srpcim_id: srpcim index * @skip_alarms: Flag to indicate if not to clear the alarms * * Process srpcim alarms. * */ vxge_hal_status_e __hal_srpcim_alarm_process( __hal_device_t * hldev, u32 srpcim_id, u32 skip_alarms) { u64 val64; u64 alarm_status; u64 pic_status; u64 xgmac_status; vxge_hal_srpcim_reg_t *srpcim_reg; vxge_assert(hldev != NULL); vxge_hal_trace_log_srpcim_irq("==> %s:%s:%d", __FILE__, __func__, __LINE__); vxge_hal_trace_log_srpcim_irq("hldev = 0x"VXGE_OS_STXFMT, (ptr_t) hldev); srpcim_reg = hldev->srpcim_reg[srpcim_id]; alarm_status = vxge_os_pio_mem_read64(hldev->header.pdev, hldev->header.regh0, &srpcim_reg->srpcim_general_int_status); vxge_hal_info_log_srpcim_irq("alarm_status = 0x"VXGE_OS_STXFMT, (ptr_t) alarm_status); if (alarm_status & VXGE_HAL_SRPCIM_GENERAL_INT_STATUS_XMAC_INT) { xgmac_status = vxge_os_pio_mem_read64(hldev->header.pdev, hldev->header.regh0, &srpcim_reg->xgmac_sr_int_status); vxge_hal_info_log_srpcim_irq("xgmac_status = 0x"VXGE_OS_STXFMT, (ptr_t) xgmac_status); if (xgmac_status & VXGE_HAL_XGMAC_SR_INT_STATUS_ASIC_NTWK_SR_ERR_INT) { val64 = vxge_os_pio_mem_read64(hldev->header.pdev, hldev->header.regh0, &srpcim_reg->asic_ntwk_sr_err_reg); vxge_hal_info_log_srpcim_irq("asic_ntwk_sr_err_reg = \ 0x"VXGE_OS_STXFMT, (ptr_t) val64); if (!skip_alarms) vxge_os_pio_mem_write64(hldev->header.pdev, hldev->header.regh0, VXGE_HAL_INTR_MASK_ALL, &srpcim_reg->asic_ntwk_sr_err_reg); }
/* * __hal_ring_first_block_address_get - Returns the dma address of the * first block * @ringh: Handle to the ring * * Returns the dma address of the first RxD block */ u64 __hal_ring_first_block_address_get( vxge_hal_ring_h ringh) { __hal_ring_t *ring = (__hal_ring_t *) ringh; vxge_hal_mempool_dma_t *dma_object; dma_object = __hal_mempool_memblock_dma(ring->mempool, 0); vxge_assert(dma_object != NULL); return (dma_object->addr); }
/* * __hal_ring_item_dma_addr - Return the dma address of an item * @mempoolh: Handle to the memory pool of the ring * @item: Item for which to get the dma offset * @dma_handle: dma handle * * This function returns the dma address of a given item */ static dma_addr_t __hal_ring_item_dma_addr( vxge_hal_mempool_h mempoolh, void *item, pci_dma_h *dma_handle) { u32 memblock_idx; void *memblock; vxge_hal_mempool_dma_t *memblock_dma_object; vxge_hal_mempool_t *mempool = (vxge_hal_mempool_t *) mempoolh; __hal_device_t *hldev; ptrdiff_t dma_item_offset; vxge_assert((mempoolh != NULL) && (item != NULL) && (dma_handle != NULL)); hldev = (__hal_device_t *) mempool->devh; vxge_hal_trace_log_ring("==> %s:%s:%d", __FILE__, __func__, __LINE__); vxge_hal_trace_log_ring( "mempoolh = 0x"VXGE_OS_STXFMT", item = 0x"VXGE_OS_STXFMT", " "dma_handle = 0x"VXGE_OS_STXFMT, (ptr_t) mempoolh, (ptr_t) item, (ptr_t) dma_handle); /* get owner memblock index */ memblock_idx = __hal_ring_block_memblock_idx((u8 *) item); /* get owner memblock by memblock index */ memblock = __hal_mempool_memblock( (vxge_hal_mempool_t *) mempoolh, memblock_idx); /* get memblock DMA object by memblock index */ memblock_dma_object = __hal_mempool_memblock_dma( (vxge_hal_mempool_t *) mempoolh, memblock_idx); /* calculate offset in the memblock of this item */ /* LINTED */ dma_item_offset = (u8 *) item - (u8 *) memblock; *dma_handle = memblock_dma_object->handle; vxge_hal_trace_log_ring("<== %s:%s:%d Result: 0", __FILE__, __func__, __LINE__); return (memblock_dma_object->addr + dma_item_offset); }
/* * __hal_kdfc_swapper_set - Set the swapper bits for the kdfc. * @hldev: HAL device object. * @vp_id: Vpath Id * * Set the swapper bits appropriately for the vpath. * * Returns: VXGE_HAL_OK - success. * VXGE_HAL_ERR_SWAPPER_CTRL - failed. * * See also: vxge_hal_status_e {}. */ vxge_hal_status_e __hal_kdfc_swapper_set( vxge_hal_device_t *hldev, u32 vp_id) { u64 val64; vxge_hal_vpath_reg_t *vpath_reg; vxge_hal_legacy_reg_t *legacy_reg; vxge_assert(hldev != NULL); vxge_hal_trace_log_vpath("==> %s:%s:%d", __FILE__, __func__, __LINE__); vxge_hal_trace_log_vpath("hldev = 0x"VXGE_OS_STXFMT", vp_id = %d", (ptr_t) hldev, vp_id); vpath_reg = ((__hal_device_t *) hldev)->vpath_reg[vp_id]; legacy_reg = ((__hal_device_t *) hldev)->legacy_reg; val64 = vxge_os_pio_mem_read64(hldev->pdev, hldev->regh0, &legacy_reg->pifm_wr_swap_en); if (val64 == VXGE_HAL_SWAPPER_WRITE_BYTE_SWAP_ENABLE) { val64 = vxge_os_pio_mem_read64(hldev->pdev, hldev->regh0, &vpath_reg->kdfcctl_cfg0); vxge_os_wmb(); val64 |= VXGE_HAL_KDFCCTL_CFG0_BYTE_SWAPEN_FIFO0 | VXGE_HAL_KDFCCTL_CFG0_BYTE_SWAPEN_FIFO1 | VXGE_HAL_KDFCCTL_CFG0_BYTE_SWAPEN_FIFO2; vxge_os_pio_mem_write64(hldev->pdev, hldev->regh0, val64, &vpath_reg->kdfcctl_cfg0); vxge_os_wmb(); } vxge_hal_trace_log_vpath("<== %s:%s:%d Result: 0", __FILE__, __func__, __LINE__); return (VXGE_HAL_OK); }
/* * __hal_message_db_post - Post message doorbell * * @vpath_handle: VPATH handle * @num_msg_bytes: The number of new message bytes made available * by this doorbell entry. * @immed_msg: Immediate message to be sent * @immed_msg_len: Immediate message length * * This function posts a message doorbell to doorbell FIFO * */ void __hal_message_db_post(vxge_hal_vpath_h vpath_handle, u32 num_msg_bytes, u8 *immed_msg, u32 immed_msg_len) { u32 i; u64 *db_ptr; __hal_device_t *hldev; __hal_vpath_handle_t *vp = (__hal_vpath_handle_t *) vpath_handle; vxge_assert((vpath_handle != NULL) && (num_msg_bytes != 0)); hldev = (__hal_device_t *) vp->vpath->hldev; vxge_hal_trace_log_dmq("==> %s:%s:%d", __FILE__, __func__, __LINE__); vxge_hal_trace_log_dmq("vpath_handle = 0x"VXGE_OS_STXFMT", " "num_msg_bytes = %d, immed_msg = 0x"VXGE_OS_STXFMT", " "immed_msg_len = %d", (ptr_t) vpath_handle, num_msg_bytes, (ptr_t) immed_msg, immed_msg_len); db_ptr = &vp->vpath->msg_db->control_0; vxge_os_pio_mem_write64(vp->vpath->hldev->header.pdev, vp->vpath->hldev->header.regh0, VXGE_HAL_MDBW_TYPE(VXGE_HAL_MDBW_TYPE_MDBW) | VXGE_HAL_MDBW_MESSAGE_BYTE_COUNT(num_msg_bytes), db_ptr++); vxge_os_pio_mem_write64(vp->vpath->hldev->header.pdev, vp->vpath->hldev->header.regh0, VXGE_HAL_MDBW_IMMEDIATE_BYTE_COUNT(immed_msg_len), db_ptr++); for (i = 0; i < immed_msg_len / 8; i++) { vxge_os_pio_mem_write64(vp->vpath->hldev->header.pdev, vp->vpath->hldev->header.regh0, *((u64 *) ((void *)&immed_msg[i * 8])), db_ptr++); } vxge_hal_trace_log_dmq("<== %s:%s:%d Result: 0", __FILE__, __func__, __LINE__); }
/* * __queue_consume - (Lockless) dequeue an item from the specified queue. * * @queue: Event queue. * @data_max_size: Maximum size of the data * @item: Queue item * See vxge_queue_consume(). */ static vxge_queue_status_e __queue_consume(vxge_queue_t *queue, u32 data_max_size, vxge_queue_item_t *item) { int real_size; vxge_queue_item_t *elem; __hal_device_t *hldev; vxge_assert(queue != NULL); hldev = (__hal_device_t *) queue->hldev; vxge_hal_trace_log_queue("==> %s:%s:%d", __FILE__, __func__, __LINE__); vxge_hal_trace_log_queue( "queue = 0x"VXGE_OS_STXFMT", size = %d, item = 0x"VXGE_OS_STXFMT, (ptr_t) queue, data_max_size, (ptr_t) item); if (vxge_list_is_empty(&queue->list_head)) { vxge_hal_trace_log_queue("<== %s:%s:%d Result = %d", __FILE__, __func__, __LINE__, VXGE_QUEUE_IS_EMPTY); return (VXGE_QUEUE_IS_EMPTY); } elem = (vxge_queue_item_t *) queue->list_head.next; if (elem->data_size > data_max_size) { vxge_hal_trace_log_queue("<== %s:%s:%d Result = %d", __FILE__, __func__, __LINE__, VXGE_QUEUE_NOT_ENOUGH_SPACE); return (VXGE_QUEUE_NOT_ENOUGH_SPACE); } vxge_list_remove(&elem->item); real_size = elem->data_size + sizeof(vxge_queue_item_t); if (queue->head_ptr == elem) { queue->head_ptr = (char *) queue->head_ptr + real_size; vxge_hal_info_log_queue("event_type: %d \ removing from the head: " "0x"VXGE_OS_STXFMT":0x"VXGE_OS_STXFMT":0x"VXGE_OS_STXFMT ":0x0x"VXGE_OS_STXFMT" elem 0x0x"VXGE_OS_STXFMT" length %d", elem->event_type, (ptr_t) queue->start_ptr, (ptr_t) queue->head_ptr, (ptr_t) queue->tail_ptr, (ptr_t) queue->end_ptr, (ptr_t) elem, real_size); } else if ((char *) queue->tail_ptr - real_size == (char *) elem) {
/* * __hal_non_offload_db_post - Post non offload doorbell * * @vpath_handle: vpath handle * @txdl_ptr: The starting location of the TxDL in host memory * @num_txds: The highest TxD in this TxDL (0 to 255 means 1 to 256) * @no_snoop: No snoop flags * * This function posts a non-offload doorbell to doorbell FIFO * */ void __hal_non_offload_db_post(vxge_hal_vpath_h vpath_handle, u64 txdl_ptr, u32 num_txds, u32 no_snoop) { u64 *db_ptr; __hal_device_t *hldev; __hal_vpath_handle_t *vp = (__hal_vpath_handle_t *) vpath_handle; vxge_assert((vpath_handle != NULL) && (txdl_ptr != 0)); hldev = (__hal_device_t *) vp->vpath->hldev; vxge_hal_trace_log_fifo("==> %s:%s:%d", __FILE__, __func__, __LINE__); vxge_hal_trace_log_fifo( "vpath_handle = 0x"VXGE_OS_STXFMT", txdl_ptr = 0x"VXGE_OS_STXFMT ", num_txds = %d, no_snoop = %d", (ptr_t) vpath_handle, (ptr_t) txdl_ptr, num_txds, no_snoop); db_ptr = &vp->vpath->nofl_db->control_0; vxge_os_pio_mem_write64(vp->vpath->hldev->header.pdev, vp->vpath->hldev->header.regh0, VXGE_HAL_NODBW_TYPE(VXGE_HAL_NODBW_TYPE_NODBW) | VXGE_HAL_NODBW_LAST_TXD_NUMBER(num_txds) | VXGE_HAL_NODBW_GET_NO_SNOOP(no_snoop), db_ptr++); vxge_os_pio_mem_write64(vp->vpath->hldev->header.pdev, vp->vpath->hldev->header.regh0, txdl_ptr, db_ptr); vxge_hal_trace_log_fifo("<== %s:%s:%d Result: 0", __FILE__, __func__, __LINE__); }
/* * __hal_vpath_swapper_set - Set the swapper bits for the vpath. * @hldev: HAL device object. * @vp_id: Vpath Id * * Set the swapper bits appropriately for the vpath. * * Returns: VXGE_HAL_OK - success. * VXGE_HAL_ERR_SWAPPER_CTRL - failed. * * See also: vxge_hal_status_e {}. */ vxge_hal_status_e __hal_vpath_swapper_set( vxge_hal_device_t *hldev, u32 vp_id) { #if !defined(VXGE_OS_HOST_BIG_ENDIAN) u64 val64; vxge_hal_vpath_reg_t *vpath_reg; vxge_assert(hldev != NULL); vxge_hal_trace_log_vpath("==> %s:%s:%d", __FILE__, __func__, __LINE__); vxge_hal_trace_log_vpath( "hldev = 0x"VXGE_OS_STXFMT", vp_id = %d", (ptr_t) hldev, vp_id); vpath_reg = ((__hal_device_t *) hldev)->vpath_reg[vp_id]; val64 = vxge_os_pio_mem_read64(hldev->pdev, hldev->regh0, &vpath_reg->vpath_general_cfg1); vxge_os_wmb(); val64 |= VXGE_HAL_VPATH_GENERAL_CFG1_CTL_BYTE_SWAPEN; vxge_os_pio_mem_write64(hldev->pdev, hldev->regh0, val64, &vpath_reg->vpath_general_cfg1); vxge_os_wmb(); vxge_hal_trace_log_vpath("<== %s:%s:%d Result: 0", __FILE__, __func__, __LINE__); #endif return (VXGE_HAL_OK); }
/* * __hal_ring_initial_replenish - Initial replenish of RxDs * @ring: ring * @reopen: Flag to denote if it is open or repopen * * This function replenishes the RxDs from reserve array to work array */ static vxge_hal_status_e __hal_ring_initial_replenish( __hal_ring_t *ring, vxge_hal_reopen_e reopen) { vxge_hal_rxd_h rxd; void *uld_priv; __hal_device_t *hldev; vxge_hal_status_e status; vxge_assert(ring != NULL); hldev = (__hal_device_t *) ring->channel.devh; vxge_hal_trace_log_ring("==> %s:%s:%d", __FILE__, __func__, __LINE__); vxge_hal_trace_log_ring("ring = 0x"VXGE_OS_STXFMT", reopen = %d", (ptr_t) ring, reopen); while (vxge_hal_ring_rxd_reserve(ring->channel.vph, &rxd, &uld_priv) == VXGE_HAL_OK) { if (ring->rxd_init) { status = ring->rxd_init(ring->channel.vph, rxd, uld_priv, VXGE_HAL_RING_RXD_INDEX(rxd), ring->channel.userdata, reopen); if (status != VXGE_HAL_OK) { vxge_hal_ring_rxd_free(ring->channel.vph, rxd); vxge_hal_trace_log_ring("<== %s:%s:%d \ Result: %d", __FILE__, __func__, __LINE__, status); return (status); } }
/* * __hal_non_offload_db_reset - Reset non offload doorbell fifo * * @vpath_handle: vpath handle * * This function resets non-offload doorbell FIFO * */ vxge_hal_status_e __hal_non_offload_db_reset(vxge_hal_vpath_h vpath_handle) { vxge_hal_status_e status; __hal_device_t *hldev; __hal_vpath_handle_t *vp = (__hal_vpath_handle_t *) vpath_handle; vxge_assert(vpath_handle != NULL); hldev = (__hal_device_t *) vp->vpath->hldev; vxge_hal_trace_log_fifo("==> %s:%s:%d", __FILE__, __func__, __LINE__); vxge_hal_trace_log_fifo( "vpath_handle = 0x"VXGE_OS_STXFMT, (ptr_t) vpath_handle); vxge_os_pio_mem_write64(vp->vpath->hldev->header.pdev, vp->vpath->hldev->header.regh0, VXGE_HAL_CMN_RSTHDLR_CFG2_SW_RESET_FIFO0( 1 << (16 - vp->vpath->vp_id)), &vp->vpath->hldev->common_reg->cmn_rsthdlr_cfg2); vxge_os_wmb(); status = vxge_hal_device_register_poll(vp->vpath->hldev->header.pdev, vp->vpath->hldev->header.regh0, &vp->vpath->hldev->common_reg->cmn_rsthdlr_cfg2, 0, (u64) VXGE_HAL_CMN_RSTHDLR_CFG2_SW_RESET_FIFO0( 1 << (16 - vp->vpath->vp_id)), VXGE_HAL_DEF_DEVICE_POLL_MILLIS); vxge_hal_trace_log_fifo("<== %s:%s:%d Result: 0", __FILE__, __func__, __LINE__); return (status); }
/* * __hal_mempool_grow * * Will resize mempool up to %num_allocate value. */ static vxge_hal_status_e __hal_mempool_grow( vxge_hal_mempool_t *mempool, u32 num_allocate, u32 *num_allocated) { u32 i, j, k, item_index, is_last; u32 first_time = mempool->memblocks_allocated == 0 ? 1 : 0; u32 n_items = mempool->items_per_memblock; u32 start_block_idx = mempool->memblocks_allocated; u32 end_block_idx = mempool->memblocks_allocated + num_allocate; __hal_device_t *hldev; vxge_assert(mempool != NULL); hldev = (__hal_device_t *) mempool->devh; vxge_hal_trace_log_mm("==> %s:%s:%d", __FILE__, __func__, __LINE__); vxge_hal_trace_log_mm( "mempool = 0x"VXGE_OS_STXFMT", num_allocate = %d, " "num_allocated = 0x"VXGE_OS_STXFMT, (ptr_t) mempool, num_allocate, (ptr_t) num_allocated); *num_allocated = 0; if (end_block_idx > mempool->memblocks_max) { vxge_hal_err_log_mm("%s", "__hal_mempool_grow: can grow anymore"); vxge_hal_trace_log_mm("<== %s:%s:%d Result: %d", __FILE__, __func__, __LINE__, VXGE_HAL_ERR_OUT_OF_MEMORY); return (VXGE_HAL_ERR_OUT_OF_MEMORY); } for (i = start_block_idx; i < end_block_idx; i++) { void *the_memblock; vxge_hal_mempool_dma_t *dma_object; is_last = ((end_block_idx - 1) == i); dma_object = mempool->memblocks_dma_arr + i; /* * allocate memblock's private part. Each DMA memblock * has a space allocated for item's private usage upon * mempool's user request. Each time mempool grows, it will * allocate new memblock and its private part at once. * This helps to minimize memory usage a lot. */ mempool->memblocks_priv_arr[i] = vxge_os_malloc( ((__hal_device_t *) mempool->devh)->header.pdev, mempool->items_priv_size * n_items); if (mempool->memblocks_priv_arr[i] == NULL) { vxge_hal_err_log_mm("memblock_priv[%d]: \ out of virtual memory, " "requested %d(%d:%d) bytes", i, mempool->items_priv_size * n_items, mempool->items_priv_size, n_items); vxge_hal_trace_log_mm("<== %s:%s:%d Result: %d", __FILE__, __func__, __LINE__, VXGE_HAL_ERR_OUT_OF_MEMORY); return (VXGE_HAL_ERR_OUT_OF_MEMORY); } vxge_os_memzero(mempool->memblocks_priv_arr[i], mempool->items_priv_size * n_items); /* allocate DMA-capable memblock */ mempool->memblocks_arr[i] = __hal_blockpool_malloc(mempool->devh, mempool->memblock_size, &dma_object->addr, &dma_object->handle, &dma_object->acc_handle); if (mempool->memblocks_arr[i] == NULL) { vxge_os_free( ((__hal_device_t *) mempool->devh)->header.pdev, mempool->memblocks_priv_arr[i], mempool->items_priv_size * n_items); vxge_hal_err_log_mm("memblock[%d]: \ out of DMA memory", i); vxge_hal_trace_log_mm("<== %s:%s:%d Result: %d", __FILE__, __func__, __LINE__, VXGE_HAL_ERR_OUT_OF_MEMORY); return (VXGE_HAL_ERR_OUT_OF_MEMORY); }
/* * __hal_ifmsg_wmsg_process - Process the srpcim to vpath wmsg * @vpath: vpath * @wmsg: wsmsg * * Processes the wmsg and invokes appropriate action */ void __hal_ifmsg_wmsg_process( __hal_virtualpath_t *vpath, u64 wmsg) { u32 msg_type; __hal_device_t *hldev = vpath->hldev; vxge_assert(vpath); vxge_hal_trace_log_vpath("==> %s:%s:%d", __FILE__, __func__, __LINE__); vxge_hal_trace_log_vpath("vpath = 0x"VXGE_OS_STXFMT ",wmsg = 0x"VXGE_OS_LLXFMT"", (ptr_t) vpath, wmsg); if ((vpath->vp_id != vpath->hldev->first_vp_id) || (vpath->hldev->vpath_assignments & mBIT((u32) VXGE_HAL_RTS_ACCESS_STEER_DATA0_GET_MSG_SRC(wmsg)))) { vxge_hal_trace_log_vpath("<== %s:%s:%d Result = 0", __FILE__, __func__, __LINE__); return; } msg_type = (u32) VXGE_HAL_RTS_ACCESS_STEER_DATA0_GET_MSG_TYPE(wmsg); switch (msg_type) { default: case VXGE_HAL_RTS_ACCESS_STEER_DATA0_MSG_TYPE_UNKNOWN: break; case VXGE_HAL_RTS_ACCESS_STEER_DATA0_MSG_TYPE_DEVICE_RESET_BEGIN: __hal_device_handle_error(hldev, vpath->vp_id, VXGE_HAL_EVENT_DEVICE_RESET_START); break; case VXGE_HAL_RTS_ACCESS_STEER_DATA0_MSG_TYPE_DEVICE_RESET_END: vpath->hldev->manager_up = TRUE; __hal_device_handle_error(hldev, vpath->vp_id, VXGE_HAL_EVENT_DEVICE_RESET_COMPLETE); break; case VXGE_HAL_RTS_ACCESS_STEER_DATA0_MSG_TYPE_VPATH_RESET_BEGIN: __hal_device_handle_error(hldev, vpath->vp_id, VXGE_HAL_EVENT_VPATH_RESET_START); break; case VXGE_HAL_RTS_ACCESS_STEER_DATA0_MSG_TYPE_VPATH_RESET_END: vpath->hldev->manager_up = TRUE; __hal_device_handle_error(hldev, vpath->vp_id, VXGE_HAL_EVENT_VPATH_RESET_COMPLETE); break; case VXGE_HAL_RTS_ACCESS_STEER_DATA0_MSG_TYPE_PRIV_DRIVER_UP: vpath->hldev->manager_up = TRUE; break; case VXGE_HAL_RTS_ACCESS_STEER_DATA0_MSG_TYPE_PRIV_DRIVER_DOWN: vpath->hldev->manager_up = FALSE; break; case VXGE_HAL_RTS_ACCESS_STEER_DATA0_MSG_TYPE_ACK: break; } vxge_hal_trace_log_vpath("<== %s:%s:%d Result = 0", __FILE__, __func__, __LINE__); }
/* * __hal_ifmsg_wmsg_post - Posts the srpcim to vpath req * @hldev: Hal device * @src_vp_id: Source vpath id * @dest_vp_id: Vpath id, VXGE_HAL_RTS_ACCESS_STEER_MSG_DEST_MRPCIM, or * VXGE_HAL_RTS_ACCESS_STEER_MSG_DEST_BROADCAST * @msg_type: wsmsg type * @msg_data: wsmsg data * * Posts the req */ vxge_hal_status_e __hal_ifmsg_wmsg_post( __hal_device_t *hldev, u32 src_vp_id, u32 dest_vp_id, u32 msg_type, u32 msg_data) { u64 val64; vxge_hal_vpath_reg_t *vp_reg; vxge_hal_status_e status; vxge_assert(hldev); vp_reg = hldev->vpath_reg[src_vp_id]; vxge_hal_trace_log_vpath("==> %s:%s:%d", __FILE__, __func__, __LINE__); vxge_hal_trace_log_srpcim( "hldev = 0x"VXGE_OS_STXFMT", src_vp_id = %d, dest_vp_id = %d, " "msg_type = %d, msg_data = %d", (ptr_t) hldev, src_vp_id, dest_vp_id, msg_type, msg_data); vxge_os_pio_mem_write64(hldev->header.pdev, hldev->header.regh0, 0, &vp_reg->rts_access_steer_ctrl); vxge_os_wmb(); vxge_os_pio_mem_write64(hldev->header.pdev, hldev->header.regh0, VXGE_HAL_RTS_ACCESS_STEER_DATA0_IGNORE_IN_SVC_CHECK | VXGE_HAL_RTS_ACCESS_STEER_DATA0_MSG_TYPE(msg_type) | VXGE_HAL_RTS_ACCESS_STEER_DATA0_MSG_DEST(dest_vp_id) | VXGE_HAL_RTS_ACCESS_STEER_DATA0_MSG_SRC(src_vp_id) | VXGE_HAL_RTS_ACCESS_STEER_DATA0_SEQ_NUM(++hldev->ifmsg_seqno) | VXGE_HAL_RTS_ACCESS_STEER_DATA0_MSG_DATA(msg_data), &vp_reg->rts_access_steer_data0); vxge_os_pio_mem_write64(hldev->header.pdev, hldev->header.regh0, 0, &vp_reg->rts_access_steer_data1); vxge_os_wmb(); val64 = VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION( VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION_SEND_MSG) | VXGE_HAL_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL( VXGE_HAL_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_FW_MEMO) | VXGE_HAL_RTS_ACCESS_STEER_CTRL_STROBE | VXGE_HAL_RTS_ACCESS_STEER_CTRL_OFFSET(0); vxge_hal_pio_mem_write32_lower(hldev->header.pdev, hldev->header.regh0, (u32) bVAL32(val64, 32), &vp_reg->rts_access_steer_ctrl); vxge_os_wmb(); vxge_hal_pio_mem_write32_upper(hldev->header.pdev, hldev->header.regh0, (u32) bVAL32(val64, 0), &vp_reg->rts_access_steer_ctrl); vxge_os_wmb(); status = vxge_hal_device_register_poll(hldev->header.pdev, hldev->header.regh0, &vp_reg->rts_access_steer_ctrl, 0, VXGE_HAL_RTS_ACCESS_STEER_CTRL_STROBE, WAIT_FACTOR * hldev->header.config.device_poll_millis); if (status != VXGE_HAL_OK) { vxge_hal_trace_log_driver("<== %s:%s:%d Result: %d", __FILE__, __func__, __LINE__, status); return (status); } val64 = vxge_os_pio_mem_read64(hldev->header.pdev, hldev->header.regh0, &vp_reg->rts_access_steer_ctrl); if (val64 & VXGE_HAL_RTS_ACCESS_STEER_CTRL_RMACJ_STATUS) { vxge_os_pio_mem_read64(hldev->header.pdev, hldev->header.regh0, &vp_reg->rts_access_steer_data0); status = VXGE_HAL_OK; } else { status = VXGE_HAL_FAIL; } vxge_hal_trace_log_srpcim("<== %s:%s:%d Result = %d", __FILE__, __func__, __LINE__, status); return (status); }
/* * __hal_ring_rxdblock_link - Link the RxD blocks * @mempoolh: Handle to the memory pool of the ring * @ring: ring * @from: RxD block from which to link * @to: RxD block to which to link to * * This function returns the dma address of a given item */ static void __hal_ring_rxdblock_link( vxge_hal_mempool_h mempoolh, __hal_ring_t *ring, u32 from, u32 to) { vxge_hal_ring_block_t *to_item, *from_item; dma_addr_t to_dma, from_dma; pci_dma_h to_dma_handle, from_dma_handle; __hal_device_t *hldev; vxge_assert((mempoolh != NULL) && (ring != NULL)); hldev = (__hal_device_t *) ring->channel.devh; vxge_hal_trace_log_ring("==> %s:%s:%d", __FILE__, __func__, __LINE__); vxge_hal_trace_log_ring( "mempoolh = 0x"VXGE_OS_STXFMT", ring = 0x"VXGE_OS_STXFMT", " "from = %d, to = %d", (ptr_t) mempoolh, (ptr_t) ring, from, to); /* get "from" RxD block */ from_item = (vxge_hal_ring_block_t *) __hal_mempool_item( (vxge_hal_mempool_t *) mempoolh, from); vxge_assert(from_item); /* get "to" RxD block */ to_item = (vxge_hal_ring_block_t *) __hal_mempool_item( (vxge_hal_mempool_t *) mempoolh, to); vxge_assert(to_item); /* return address of the beginning of previous RxD block */ to_dma = __hal_ring_item_dma_addr(mempoolh, to_item, &to_dma_handle); /* * set next pointer for this RxD block to point on * previous item's DMA start address */ __hal_ring_block_next_pointer_set(from_item, to_dma); /* return "from" RxD block's DMA start address */ from_dma = __hal_ring_item_dma_addr( mempoolh, from_item, &from_dma_handle); #if defined(VXGE_OS_DMA_REQUIRES_SYNC) && defined(VXGE_HAL_DMA_RXD_STREAMING) /* we must sync "from" RxD block, so hardware will see it */ vxge_os_dma_sync(ring->channel.pdev, from_dma_handle, from_dma + VXGE_HAL_RING_NEXT_BLOCK_POINTER_OFFSET, __hal_ring_item_dma_offset(mempoolh, from_item) + VXGE_HAL_RING_NEXT_BLOCK_POINTER_OFFSET, sizeof(u64), VXGE_OS_DMA_DIR_TODEVICE); #endif vxge_hal_info_log_ring( "block%d:0x"VXGE_OS_STXFMT" => block%d:0x"VXGE_OS_STXFMT, from, (ptr_t) from_dma, to, (ptr_t) to_dma); vxge_hal_trace_log_ring("<== %s:%s:%d Result: 0", __FILE__, __func__, __LINE__); }
/* * __hal_ring_mempool_item_alloc - Allocate List blocks for RxD block callback * @mempoolh: Handle to memory pool * @memblock: Address of this memory block * @memblock_index: Index of this memory block * @dma_object: dma object for this block * @item: Pointer to this item * @index: Index of this item in memory block * @is_last: If this is last item in the block * @userdata: Specific data of user * * This function is callback passed to __hal_mempool_create to create memory * pool for RxD block */ static vxge_hal_status_e __hal_ring_mempool_item_alloc( vxge_hal_mempool_h mempoolh, void *memblock, u32 memblock_index, vxge_hal_mempool_dma_t *dma_object, void *item, u32 item_index, u32 is_last, void *userdata) { u32 i; __hal_ring_t *ring = (__hal_ring_t *) userdata; __hal_device_t *hldev; vxge_assert((item != NULL) && (ring != NULL)); hldev = (__hal_device_t *) ring->channel.devh; vxge_hal_trace_log_pool("==> %s:%s:%d", __FILE__, __func__, __LINE__); vxge_hal_trace_log_pool( "mempoolh = 0x"VXGE_OS_STXFMT", memblock = 0x"VXGE_OS_STXFMT", " "memblock_index = %d, dma_object = 0x"VXGE_OS_STXFMT", " "item = 0x"VXGE_OS_STXFMT", item_index = %d, is_last = %d, " "userdata = 0x"VXGE_OS_STXFMT, (ptr_t) mempoolh, (ptr_t) memblock, memblock_index, (ptr_t) dma_object, (ptr_t) item, item_index, is_last, (ptr_t) userdata); /* format rxds array */ for (i = 0; i < ring->rxds_per_block; i++) { void *uld_priv; void *rxdblock_priv; __hal_ring_rxd_priv_t *rxd_priv; vxge_hal_ring_rxd_1_t *rxdp; u32 memblock_item_idx; u32 dtr_index = item_index * ring->rxds_per_block + i; ring->channel.dtr_arr[dtr_index].dtr = ((u8 *) item) + i * ring->rxd_size; /* * Note: memblock_item_idx is index of the item within * the memblock. For instance, in case of three RxD-blocks * per memblock this value can be 0, 1 or 2. */ rxdblock_priv = __hal_mempool_item_priv( (vxge_hal_mempool_t *) mempoolh, memblock_index, item, &memblock_item_idx); rxdp = (vxge_hal_ring_rxd_1_t *) ring->channel.dtr_arr[dtr_index].dtr; uld_priv = ((u8 *) rxdblock_priv + ring->rxd_priv_size * i); rxd_priv = (__hal_ring_rxd_priv_t *) ((void *)(((char *) uld_priv) + ring->per_rxd_space)); ((vxge_hal_ring_rxd_5_t *) rxdp)->host_control = dtr_index; ring->channel.dtr_arr[dtr_index].uld_priv = (void *)uld_priv; ring->channel.dtr_arr[dtr_index].hal_priv = (void *)rxd_priv; /* pre-format per-RxD Ring's private */ /* LINTED */ rxd_priv->dma_offset = (u8 *) rxdp - (u8 *) memblock; rxd_priv->dma_addr = dma_object->addr + rxd_priv->dma_offset; rxd_priv->dma_handle = dma_object->handle; #if defined(VXGE_DEBUG_ASSERT) rxd_priv->dma_object = dma_object; #endif rxd_priv->db_bytes = ring->rxd_size; if (i == (ring->rxds_per_block - 1)) { rxd_priv->db_bytes += (((vxge_hal_mempool_t *) mempoolh)->memblock_size - (ring->rxds_per_block * ring->rxd_size)); } } __hal_ring_block_memblock_idx_set((u8 *) item, memblock_index); if (is_last) { /* link last one with first one */ __hal_ring_rxdblock_link(mempoolh, ring, item_index, 0); } if (item_index > 0) { /* link this RxD block with previous one */ __hal_ring_rxdblock_link(mempoolh, ring, item_index - 1, item_index); } vxge_hal_trace_log_pool("<== %s:%s:%d Result: 0", __FILE__, __func__, __LINE__); return (VXGE_HAL_OK); }
/* * _hal_legacy_swapper_set - Set the swapper bits for the legacy secion. * @pdev: PCI device object. * @regh: BAR0 mapped memory handle (Solaris), or simply PCI device @pdev * (Linux and the rest.) * @legacy_reg: Address of the legacy register space. * * Set the swapper bits appropriately for the lagacy section. * * Returns: VXGE_HAL_OK - success. * VXGE_HAL_ERR_SWAPPER_CTRL - failed. * * See also: vxge_hal_status_e {}. */ vxge_hal_status_e __hal_legacy_swapper_set( pci_dev_h pdev, pci_reg_h regh, vxge_hal_legacy_reg_t *legacy_reg) { u64 val64; vxge_hal_status_e status; vxge_assert(legacy_reg != NULL); vxge_hal_trace_log_driver("==> %s:%s:%d", __FILE__, __func__, __LINE__); vxge_hal_trace_log_driver( "pdev = 0x"VXGE_OS_STXFMT", regh = 0x"VXGE_OS_STXFMT", " "legacy_reg = 0x"VXGE_OS_STXFMT, (ptr_t) pdev, (ptr_t) regh, (ptr_t) legacy_reg); val64 = vxge_os_pio_mem_read64(pdev, regh, &legacy_reg->toc_swapper_fb); vxge_hal_info_log_driver("TOC Swapper Fb: 0x"VXGE_OS_LLXFMT, val64); vxge_os_wmb(); switch (val64) { case VXGE_HAL_SWAPPER_INITIAL_VALUE: return (VXGE_HAL_OK); case VXGE_HAL_SWAPPER_BYTE_SWAPPED_BIT_FLIPPED: vxge_os_pio_mem_write64(pdev, regh, VXGE_HAL_SWAPPER_READ_BYTE_SWAP_ENABLE, &legacy_reg->pifm_rd_swap_en); vxge_os_pio_mem_write64(pdev, regh, VXGE_HAL_SWAPPER_READ_BIT_FLAP_ENABLE, &legacy_reg->pifm_rd_flip_en); vxge_os_pio_mem_write64(pdev, regh, VXGE_HAL_SWAPPER_WRITE_BYTE_SWAP_ENABLE, &legacy_reg->pifm_wr_swap_en); vxge_os_pio_mem_write64(pdev, regh, VXGE_HAL_SWAPPER_WRITE_BIT_FLAP_ENABLE, &legacy_reg->pifm_wr_flip_en); break; case VXGE_HAL_SWAPPER_BYTE_SWAPPED: vxge_os_pio_mem_write64(pdev, regh, VXGE_HAL_SWAPPER_READ_BYTE_SWAP_ENABLE, &legacy_reg->pifm_rd_swap_en); vxge_os_pio_mem_write64(pdev, regh, VXGE_HAL_SWAPPER_WRITE_BYTE_SWAP_ENABLE, &legacy_reg->pifm_wr_swap_en); break; case VXGE_HAL_SWAPPER_BIT_FLIPPED: vxge_os_pio_mem_write64(pdev, regh, VXGE_HAL_SWAPPER_READ_BIT_FLAP_ENABLE, &legacy_reg->pifm_rd_flip_en); vxge_os_pio_mem_write64(pdev, regh, VXGE_HAL_SWAPPER_WRITE_BIT_FLAP_ENABLE, &legacy_reg->pifm_wr_flip_en); break; } vxge_os_wmb(); val64 = vxge_os_pio_mem_read64(pdev, regh, &legacy_reg->toc_swapper_fb); if (val64 == VXGE_HAL_SWAPPER_INITIAL_VALUE) { status = VXGE_HAL_OK; } else { vxge_hal_err_log_driver("%s:TOC Swapper setting failed", __func__); status = VXGE_HAL_ERR_SWAPPER_CTRL; } vxge_hal_info_log_driver("TOC Swapper Fb: 0x"VXGE_OS_LLXFMT, val64); vxge_hal_trace_log_driver("<== %s:%s:%d Result: %d", __FILE__, __func__, __LINE__, status); return (status); }