1d14abf15SRobert Mustacchi /*
2d14abf15SRobert Mustacchi * CDDL HEADER START
3d14abf15SRobert Mustacchi *
4d14abf15SRobert Mustacchi * The contents of this file are subject to the terms of the
5d14abf15SRobert Mustacchi * Common Development and Distribution License (the "License").
6d14abf15SRobert Mustacchi * You may not use this file except in compliance with the License.
7d14abf15SRobert Mustacchi *
8d14abf15SRobert Mustacchi * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9d14abf15SRobert Mustacchi * or http://www.opensolaris.org/os/licensing.
10d14abf15SRobert Mustacchi * See the License for the specific language governing permissions
11d14abf15SRobert Mustacchi * and limitations under the License.
12d14abf15SRobert Mustacchi *
13d14abf15SRobert Mustacchi * When distributing Covered Code, include this CDDL HEADER in each
14d14abf15SRobert Mustacchi * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15d14abf15SRobert Mustacchi * If applicable, add the following below this CDDL HEADER, with the
16d14abf15SRobert Mustacchi * fields enclosed by brackets "[]" replaced with your own identifying
17d14abf15SRobert Mustacchi * information: Portions Copyright [yyyy] [name of copyright owner]
18d14abf15SRobert Mustacchi *
19d14abf15SRobert Mustacchi * CDDL HEADER END
20d14abf15SRobert Mustacchi */
21d14abf15SRobert Mustacchi
22d14abf15SRobert Mustacchi /*
23d14abf15SRobert Mustacchi * Copyright 2014 QLogic Corporation
24d14abf15SRobert Mustacchi * The contents of this file are subject to the terms of the
25d14abf15SRobert Mustacchi * QLogic End User License (the "License").
26d14abf15SRobert Mustacchi * You may not use this file except in compliance with the License.
27d14abf15SRobert Mustacchi *
28d14abf15SRobert Mustacchi * You can obtain a copy of the License at
29d14abf15SRobert Mustacchi * http://www.qlogic.com/Resources/Documents/DriverDownloadHelp/
30d14abf15SRobert Mustacchi * QLogic_End_User_Software_License.txt
31d14abf15SRobert Mustacchi * See the License for the specific language governing permissions
32d14abf15SRobert Mustacchi * and limitations under the License.
33d14abf15SRobert Mustacchi */
34d14abf15SRobert Mustacchi
35d14abf15SRobert Mustacchi /*
36d14abf15SRobert Mustacchi * Copyright (c) 2002, 2011, Oracle and/or its affiliates. All rights reserved.
37d14abf15SRobert Mustacchi */
38d14abf15SRobert Mustacchi
39d14abf15SRobert Mustacchi #include "bnxe.h"
40d14abf15SRobert Mustacchi
41d14abf15SRobert Mustacchi #define BNXE_DEF_TX_BD_PAGE_CNT 12
42d14abf15SRobert Mustacchi #define BNXE_DEF_TX_COAL_BUF_CNT 10
43d14abf15SRobert Mustacchi
44d14abf15SRobert Mustacchi typedef struct
45d14abf15SRobert Mustacchi {
46d14abf15SRobert Mustacchi int bufCnt;
47d14abf15SRobert Mustacchi int txBdPageCnt;
48d14abf15SRobert Mustacchi int txCoalBufCnt;
49d14abf15SRobert Mustacchi } BnxeHwPageConfig;
50d14abf15SRobert Mustacchi
51d14abf15SRobert Mustacchi static BnxeHwPageConfig bnxeHwPageConfigs[] =
52d14abf15SRobert Mustacchi {
53d14abf15SRobert Mustacchi /* Buffers TX BD Pages TX Coalesce Bufs */
54d14abf15SRobert Mustacchi { 1000, 4, 10 },
55d14abf15SRobert Mustacchi { 1500, 6, 10 },
56d14abf15SRobert Mustacchi { 3000, 12, 10 },
57d14abf15SRobert Mustacchi { 0, 0, 0 }
58d14abf15SRobert Mustacchi };
59d14abf15SRobert Mustacchi
60d14abf15SRobert Mustacchi #if 0
61d14abf15SRobert Mustacchi #define MEM_LOG BnxeLogInfo
62d14abf15SRobert Mustacchi #else
63d14abf15SRobert Mustacchi #define MEM_LOG
64d14abf15SRobert Mustacchi #endif
65d14abf15SRobert Mustacchi
66d14abf15SRobert Mustacchi ddi_device_acc_attr_t bnxeAccessAttribBAR =
67d14abf15SRobert Mustacchi {
68d14abf15SRobert Mustacchi DDI_DEVICE_ATTR_V0, /* devacc_attr_version */
69d14abf15SRobert Mustacchi DDI_STRUCTURE_LE_ACC, /* devacc_attr_endian_flags */
70d14abf15SRobert Mustacchi DDI_STRICTORDER_ACC, /* devacc_attr_dataorder */
71d14abf15SRobert Mustacchi DDI_DEFAULT_ACC /* devacc_attr_access */
72d14abf15SRobert Mustacchi };
73d14abf15SRobert Mustacchi
74d14abf15SRobert Mustacchi ddi_device_acc_attr_t bnxeAccessAttribBUF =
75d14abf15SRobert Mustacchi {
76d14abf15SRobert Mustacchi DDI_DEVICE_ATTR_V0, /* devacc_attr_version */
77d14abf15SRobert Mustacchi DDI_NEVERSWAP_ACC, /* devacc_attr_endian_flags */
78d14abf15SRobert Mustacchi DDI_STRICTORDER_ACC, /* devacc_attr_dataorder */
79d14abf15SRobert Mustacchi DDI_DEFAULT_ACC /* devacc_attr_access */
80d14abf15SRobert Mustacchi };
81d14abf15SRobert Mustacchi
82d14abf15SRobert Mustacchi ddi_dma_attr_t bnxeDmaPageAttrib =
83d14abf15SRobert Mustacchi {
84d14abf15SRobert Mustacchi DMA_ATTR_V0, /* dma_attr_version */
85d14abf15SRobert Mustacchi 0, /* dma_attr_addr_lo */
86d14abf15SRobert Mustacchi 0xffffffffffffffff, /* dma_attr_addr_hi */
87d14abf15SRobert Mustacchi 0xffffffffffffffff, /* dma_attr_count_max */
88d14abf15SRobert Mustacchi 0, /* dma_attr_align */
89d14abf15SRobert Mustacchi 0xffffffff, /* dma_attr_burstsizes */
90d14abf15SRobert Mustacchi 1, /* dma_attr_minxfer */
91d14abf15SRobert Mustacchi 0xffffffffffffffff, /* dma_attr_maxxfer */
92d14abf15SRobert Mustacchi 0xffffffffffffffff, /* dma_attr_seg */
93d14abf15SRobert Mustacchi 1, /* dma_attr_sgllen */
94d14abf15SRobert Mustacchi 1, /* dma_attr_granular */
95d14abf15SRobert Mustacchi 0, /* dma_attr_flags */
96d14abf15SRobert Mustacchi };
97d14abf15SRobert Mustacchi
98d14abf15SRobert Mustacchi
mm_wait(lm_device_t * pDev,u32_t delayUs)99d14abf15SRobert Mustacchi void mm_wait(lm_device_t * pDev,
100d14abf15SRobert Mustacchi u32_t delayUs)
101d14abf15SRobert Mustacchi {
102d14abf15SRobert Mustacchi (void)pDev;
103d14abf15SRobert Mustacchi drv_usecwait(delayUs);
104d14abf15SRobert Mustacchi }
105d14abf15SRobert Mustacchi
106d14abf15SRobert Mustacchi
mm_read_pci(lm_device_t * pDev,u32_t pciReg,u32_t * pRegValue)107d14abf15SRobert Mustacchi lm_status_t mm_read_pci(lm_device_t * pDev,
108d14abf15SRobert Mustacchi u32_t pciReg,
109d14abf15SRobert Mustacchi u32_t * pRegValue)
110d14abf15SRobert Mustacchi {
111d14abf15SRobert Mustacchi um_device_t * pUM = (um_device_t *)pDev;
112d14abf15SRobert Mustacchi
113d14abf15SRobert Mustacchi *pRegValue = pci_config_get32(pUM->pPciCfg, (off_t)pciReg);
114d14abf15SRobert Mustacchi
115d14abf15SRobert Mustacchi return LM_STATUS_SUCCESS;
116d14abf15SRobert Mustacchi }
117d14abf15SRobert Mustacchi
118d14abf15SRobert Mustacchi
mm_write_pci(lm_device_t * pDev,u32_t pciReg,u32_t regValue)119d14abf15SRobert Mustacchi lm_status_t mm_write_pci(lm_device_t * pDev,
120d14abf15SRobert Mustacchi u32_t pciReg,
121d14abf15SRobert Mustacchi u32_t regValue)
122d14abf15SRobert Mustacchi {
123d14abf15SRobert Mustacchi um_device_t * pUM = (um_device_t *)pDev;
124d14abf15SRobert Mustacchi
125d14abf15SRobert Mustacchi pci_config_put32(pUM->pPciCfg, (off_t)pciReg, regValue);
126d14abf15SRobert Mustacchi
127d14abf15SRobert Mustacchi return LM_STATUS_SUCCESS;
128d14abf15SRobert Mustacchi }
129d14abf15SRobert Mustacchi
130d14abf15SRobert Mustacchi
BnxeInitBdCnts(um_device_t * pUM,int cli_idx)131d14abf15SRobert Mustacchi void BnxeInitBdCnts(um_device_t * pUM,
132d14abf15SRobert Mustacchi int cli_idx)
133d14abf15SRobert Mustacchi {
134d14abf15SRobert Mustacchi lm_device_t * pLM = (lm_device_t *)pUM;
135d14abf15SRobert Mustacchi BnxeHwPageConfig * pPageCfg;
136d14abf15SRobert Mustacchi
137d14abf15SRobert Mustacchi pLM->params.l2_tx_bd_page_cnt[cli_idx] = BNXE_DEF_TX_BD_PAGE_CNT;
138d14abf15SRobert Mustacchi pLM->params.l2_tx_coal_buf_cnt[cli_idx] = BNXE_DEF_TX_COAL_BUF_CNT;
139d14abf15SRobert Mustacchi
140d14abf15SRobert Mustacchi pPageCfg = &bnxeHwPageConfigs[0];
141d14abf15SRobert Mustacchi while (pPageCfg->bufCnt)
142d14abf15SRobert Mustacchi {
143d14abf15SRobert Mustacchi if (pLM->params.l2_rx_desc_cnt[cli_idx] <= pPageCfg->bufCnt)
144d14abf15SRobert Mustacchi {
145d14abf15SRobert Mustacchi pLM->params.l2_tx_bd_page_cnt[cli_idx] = pPageCfg->txBdPageCnt;
146d14abf15SRobert Mustacchi pLM->params.l2_tx_coal_buf_cnt[cli_idx] = pPageCfg->txCoalBufCnt;
147d14abf15SRobert Mustacchi break;
148d14abf15SRobert Mustacchi }
149d14abf15SRobert Mustacchi
150d14abf15SRobert Mustacchi pPageCfg++;
151d14abf15SRobert Mustacchi }
152d14abf15SRobert Mustacchi }
153d14abf15SRobert Mustacchi
154d14abf15SRobert Mustacchi
155d14abf15SRobert Mustacchi extern u32_t LOG2(u32_t v);
156d14abf15SRobert Mustacchi unsigned long log2_align(unsigned long n);
157d14abf15SRobert Mustacchi
mm_get_user_config(lm_device_t * pLM)158d14abf15SRobert Mustacchi lm_status_t mm_get_user_config(lm_device_t * pLM)
159d14abf15SRobert Mustacchi {
160d14abf15SRobert Mustacchi um_device_t * pUM = (um_device_t *)pLM;
161d14abf15SRobert Mustacchi u32_t total_size;
162d14abf15SRobert Mustacchi u32_t required_page_size;
163d14abf15SRobert Mustacchi
164d14abf15SRobert Mustacchi BnxeCfgInit(pUM);
165d14abf15SRobert Mustacchi
166d14abf15SRobert Mustacchi pLM->params.sw_config = LM_SWCFG_10G;
167d14abf15SRobert Mustacchi
168d14abf15SRobert Mustacchi pLM->params.ofld_cap = (LM_OFFLOAD_TX_IP_CKSUM |
169d14abf15SRobert Mustacchi LM_OFFLOAD_RX_IP_CKSUM |
170d14abf15SRobert Mustacchi LM_OFFLOAD_TX_TCP_CKSUM |
171d14abf15SRobert Mustacchi LM_OFFLOAD_RX_TCP_CKSUM |
172d14abf15SRobert Mustacchi LM_OFFLOAD_TX_TCP6_CKSUM |
173d14abf15SRobert Mustacchi LM_OFFLOAD_RX_TCP6_CKSUM |
174d14abf15SRobert Mustacchi LM_OFFLOAD_TX_UDP_CKSUM |
175d14abf15SRobert Mustacchi LM_OFFLOAD_RX_UDP_CKSUM |
176d14abf15SRobert Mustacchi LM_OFFLOAD_TX_UDP6_CKSUM |
177d14abf15SRobert Mustacchi LM_OFFLOAD_RX_UDP6_CKSUM);
178d14abf15SRobert Mustacchi
179d14abf15SRobert Mustacchi /* XXX Wake on LAN? */
180d14abf15SRobert Mustacchi //pLM->params.wol_cap = (LM_WAKE_UP_MODE_MAGIC_PACKET | LM_WAKE_UP_MODE_NWUF);
181d14abf15SRobert Mustacchi
182d14abf15SRobert Mustacchi /* keep the VLAN tag in the mac header when receiving */
183d14abf15SRobert Mustacchi pLM->params.keep_vlan_tag = 1;
184d14abf15SRobert Mustacchi
185d14abf15SRobert Mustacchi /* set in BnxeIntrInit based on the allocated number of MSIX interrupts */
186d14abf15SRobert Mustacchi //pLM->params.rss_chain_cnt = pUM->devParams.numRings;
187d14abf15SRobert Mustacchi //pLM->params.tss_chain_cnt = pUM->devParams.numRings;
188d14abf15SRobert Mustacchi
189d14abf15SRobert Mustacchi pLM->params.l2_rx_desc_cnt[LM_CLI_IDX_NDIS] = pUM->devParams.numRxDesc[LM_CLI_IDX_NDIS];
190d14abf15SRobert Mustacchi pLM->params.l2_tx_bd_page_cnt[LM_CLI_IDX_NDIS] = 0;
191d14abf15SRobert Mustacchi pLM->params.l2_tx_coal_buf_cnt[LM_CLI_IDX_NDIS] = 0;
192d14abf15SRobert Mustacchi
193d14abf15SRobert Mustacchi BnxeInitBdCnts(pUM, LM_CLI_IDX_NDIS);
194d14abf15SRobert Mustacchi
195d14abf15SRobert Mustacchi pLM->params.l2_rx_desc_cnt[LM_CLI_IDX_FWD] = 0;
196d14abf15SRobert Mustacchi pLM->params.l2_tx_bd_page_cnt[LM_CLI_IDX_FWD] = 0;
197d14abf15SRobert Mustacchi pLM->params.l2_tx_coal_buf_cnt[LM_CLI_IDX_FWD] = 0;
198d14abf15SRobert Mustacchi
199d14abf15SRobert Mustacchi pLM->params.l2_rx_desc_cnt[LM_CLI_IDX_ISCSI] = 0;
200d14abf15SRobert Mustacchi pLM->params.l2_tx_bd_page_cnt[LM_CLI_IDX_ISCSI] = 0;
201d14abf15SRobert Mustacchi pLM->params.l2_tx_coal_buf_cnt[LM_CLI_IDX_ISCSI] = 0;
202d14abf15SRobert Mustacchi
203d14abf15SRobert Mustacchi pLM->params.l2_rx_desc_cnt[LM_CLI_IDX_FCOE] = 0;
204d14abf15SRobert Mustacchi pLM->params.l2_tx_bd_page_cnt[LM_CLI_IDX_FCOE] = 0;
205d14abf15SRobert Mustacchi pLM->params.l2_tx_coal_buf_cnt[LM_CLI_IDX_FCOE] = 0;
206d14abf15SRobert Mustacchi
207d14abf15SRobert Mustacchi pLM->params.max_func_toe_cons = 0;
208d14abf15SRobert Mustacchi pLM->params.max_func_iscsi_cons = 0;
209d14abf15SRobert Mustacchi pLM->params.max_func_rdma_cons = 0;
210d14abf15SRobert Mustacchi pLM->params.max_func_fcoe_cons = pUM->lm_dev.hw_info.max_port_fcoe_conn;
211d14abf15SRobert Mustacchi pLM->params.max_func_connections =
212d14abf15SRobert Mustacchi log2_align(pLM->params.max_func_toe_cons +
213d14abf15SRobert Mustacchi pLM->params.max_func_rdma_cons +
214d14abf15SRobert Mustacchi pLM->params.max_func_iscsi_cons +
215d14abf15SRobert Mustacchi pLM->params.max_func_fcoe_cons +
216d14abf15SRobert Mustacchi MAX_ETH_CONS);
217d14abf15SRobert Mustacchi
218d14abf15SRobert Mustacchi /* determine: 1. itl_client_page_size, #context in page*/
219d14abf15SRobert Mustacchi
220d14abf15SRobert Mustacchi /* based on PCIe block INIT document */
221d14abf15SRobert Mustacchi
222d14abf15SRobert Mustacchi /* We now need to calculate the page size based on the maximum number of
223d14abf15SRobert Mustacchi * connections supported. Since this property is identical to all ports, and
224d14abf15SRobert Mustacchi * is configured in COMMON registers, we need to use the maximum number of
225d14abf15SRobert Mustacchi * connections in all ports. */
226d14abf15SRobert Mustacchi
227d14abf15SRobert Mustacchi /* The L2P table is used to map logical addresses to physical ones. There
228d14abf15SRobert Mustacchi * are four clients that use this table. We want to use only the ILT
229d14abf15SRobert Mustacchi * (Internal), we need to calculate the total size required for all clients,
230d14abf15SRobert Mustacchi * divide it by the number of entries in the ILT table and that will give us
231d14abf15SRobert Mustacchi * the page size we want. The following table describes the needs of each of
232d14abf15SRobert Mustacchi * these clients:
233d14abf15SRobert Mustacchi *
234d14abf15SRobert Mustacchi * HW block(L2P client) Area name Size [B]
235d14abf15SRobert Mustacchi * Searcher T1 ROUNDUP(LOG2(N)) * 64
236d14abf15SRobert Mustacchi * Timers Linear Array N * 8
237d14abf15SRobert Mustacchi * QM Queues N * 32 * 4
238d14abf15SRobert Mustacchi * CDU Context N * S + W * ROUNDUP (N/m) (W=0)
239d14abf15SRobert Mustacchi *
240d14abf15SRobert Mustacchi * N: Number of connections
241d14abf15SRobert Mustacchi * S: Context Size
242d14abf15SRobert Mustacchi * W: Block Waste (not really interesting) we configure the context size to
243d14abf15SRobert Mustacchi * be a power of 2.
244d14abf15SRobert Mustacchi * m: Number of cids in a block (not really interesting, since W will always
245d14abf15SRobert Mustacchi * be 0)
246d14abf15SRobert Mustacchi */
247d14abf15SRobert Mustacchi total_size = (pLM->hw_info.max_common_conns *
248d14abf15SRobert Mustacchi (SEARCHER_TOTAL_MEM_REQUIRED_PER_CON +
249d14abf15SRobert Mustacchi TIMERS_TOTAL_MEM_REQUIRED_PER_CON +
250d14abf15SRobert Mustacchi QM_TOTAL_MEM_REQUIRED_PER_CON +
251d14abf15SRobert Mustacchi pLM->params.context_line_size));
252d14abf15SRobert Mustacchi
253d14abf15SRobert Mustacchi required_page_size = (total_size / ILT_NUM_PAGE_ENTRIES_PER_FUNC);
254d14abf15SRobert Mustacchi required_page_size = (2 << LOG2(required_page_size));
255d14abf15SRobert Mustacchi
256d14abf15SRobert Mustacchi if (required_page_size < LM_PAGE_SIZE)
257d14abf15SRobert Mustacchi {
258d14abf15SRobert Mustacchi required_page_size = LM_PAGE_SIZE;
259d14abf15SRobert Mustacchi }
260d14abf15SRobert Mustacchi
261d14abf15SRobert Mustacchi pLM->params.ilt_client_page_size = required_page_size;
262d14abf15SRobert Mustacchi pLM->params.num_context_in_page = (pLM->params.ilt_client_page_size /
263d14abf15SRobert Mustacchi pLM->params.context_line_size);
264d14abf15SRobert Mustacchi
265d14abf15SRobert Mustacchi if (pUM->devParams.intrCoalesce)
266d14abf15SRobert Mustacchi {
267d14abf15SRobert Mustacchi pLM->params.int_coalesing_mode = LM_INT_COAL_PERIODIC_SYNC;
268d14abf15SRobert Mustacchi pLM->params.int_per_sec_rx_override = pUM->devParams.intrRxPerSec;
269d14abf15SRobert Mustacchi pLM->params.int_per_sec_tx_override = pUM->devParams.intrTxPerSec;
270d14abf15SRobert Mustacchi }
271d14abf15SRobert Mustacchi else
272d14abf15SRobert Mustacchi {
273d14abf15SRobert Mustacchi pLM->params.int_coalesing_mode = LM_INT_COAL_NONE;
274d14abf15SRobert Mustacchi }
275d14abf15SRobert Mustacchi
276d14abf15SRobert Mustacchi pLM->params.enable_dynamic_hc[0] = 0;
277d14abf15SRobert Mustacchi pLM->params.enable_dynamic_hc[1] = 0;
278d14abf15SRobert Mustacchi pLM->params.enable_dynamic_hc[2] = 0;
279d14abf15SRobert Mustacchi pLM->params.enable_dynamic_hc[3] = 0;
280d14abf15SRobert Mustacchi
281d14abf15SRobert Mustacchi /*
282d14abf15SRobert Mustacchi * l2_fw_flow_ctrl is read from the shmem in MF mode in E2 and above. In
283d14abf15SRobert Mustacchi * all other cases this parameter is read from the driver conf. We also
284d14abf15SRobert Mustacchi * read this parameter from the driver conf in E1.5 MF mode since 57711
285d14abf15SRobert Mustacchi * boot code does not have the struct func_ext_cfg.
286d14abf15SRobert Mustacchi */
287d14abf15SRobert Mustacchi if (((pLM->hw_info.mf_info.mf_mode != MULTI_FUNCTION_SI) &&
288d14abf15SRobert Mustacchi (pLM->hw_info.mf_info.mf_mode != MULTI_FUNCTION_AFEX)) ||
289d14abf15SRobert Mustacchi (CHIP_IS_E1x(pLM)))
290d14abf15SRobert Mustacchi {
291d14abf15SRobert Mustacchi pLM->params.l2_fw_flow_ctrl = (pUM->devParams.l2_fw_flow_ctrl) ? 1 : 0;
292d14abf15SRobert Mustacchi }
293d14abf15SRobert Mustacchi
294*55fea89dSDan Cross pLM->params.rcv_buffer_offset = BNXE_DMA_RX_OFFSET;
295d14abf15SRobert Mustacchi
296d14abf15SRobert Mustacchi pLM->params.debug_cap_flags = DEFAULT_DEBUG_CAP_FLAGS_VAL;
297d14abf15SRobert Mustacchi
298d14abf15SRobert Mustacchi pLM->params.max_fcoe_task = lm_fc_max_fcoe_task_sup(pLM);
299d14abf15SRobert Mustacchi
300d14abf15SRobert Mustacchi /* enable rate shaping */
301d14abf15SRobert Mustacchi pLM->params.cmng_enable = 1;
302d14abf15SRobert Mustacchi
303d14abf15SRobert Mustacchi pLM->params.validate_sq_complete = 1;
304d14abf15SRobert Mustacchi
305d14abf15SRobert Mustacchi return LM_STATUS_SUCCESS;
306d14abf15SRobert Mustacchi }
307d14abf15SRobert Mustacchi
308d14abf15SRobert Mustacchi
BnxeIsBarUsed(um_device_t * pUM,int regNumber,offset_t offset,u32_t size)309d14abf15SRobert Mustacchi static boolean_t BnxeIsBarUsed(um_device_t * pUM,
310d14abf15SRobert Mustacchi int regNumber,
311d14abf15SRobert Mustacchi offset_t offset,
312d14abf15SRobert Mustacchi u32_t size)
313d14abf15SRobert Mustacchi {
314d14abf15SRobert Mustacchi BnxeMemRegion * pMem;
315d14abf15SRobert Mustacchi
316d14abf15SRobert Mustacchi BNXE_LOCK_ENTER_MEM(pUM);
317d14abf15SRobert Mustacchi
318d14abf15SRobert Mustacchi pMem = (BnxeMemRegion *)d_list_peek_head(&pUM->memRegionList);
319d14abf15SRobert Mustacchi
320d14abf15SRobert Mustacchi while (pMem)
321d14abf15SRobert Mustacchi {
322d14abf15SRobert Mustacchi if ((pMem->regNumber == regNumber) &&
323d14abf15SRobert Mustacchi (pMem->offset == offset) &&
324d14abf15SRobert Mustacchi (pMem->size == size))
325d14abf15SRobert Mustacchi {
326d14abf15SRobert Mustacchi BNXE_LOCK_EXIT_MEM(pUM);
327d14abf15SRobert Mustacchi return B_TRUE;
328d14abf15SRobert Mustacchi }
329d14abf15SRobert Mustacchi
330d14abf15SRobert Mustacchi pMem = (BnxeMemRegion *)d_list_next_entry(D_LINK_CAST(pMem));
331d14abf15SRobert Mustacchi }
332d14abf15SRobert Mustacchi
333d14abf15SRobert Mustacchi BNXE_LOCK_EXIT_MEM(pUM);
334d14abf15SRobert Mustacchi return B_FALSE;
335d14abf15SRobert Mustacchi }
336d14abf15SRobert Mustacchi
337d14abf15SRobert Mustacchi
mm_map_io_base(lm_device_t * pLM,lm_address_t baseAddr,u32_t size,u8_t bar)338d14abf15SRobert Mustacchi void * mm_map_io_base(lm_device_t * pLM,
339d14abf15SRobert Mustacchi lm_address_t baseAddr,
340d14abf15SRobert Mustacchi u32_t size,
341d14abf15SRobert Mustacchi u8_t bar)
342d14abf15SRobert Mustacchi {
343d14abf15SRobert Mustacchi um_device_t * pUM = (um_device_t *)pLM;
344d14abf15SRobert Mustacchi BnxeMemRegion * pMem;
345d14abf15SRobert Mustacchi //int numRegs;
346d14abf15SRobert Mustacchi off_t regSize;
347d14abf15SRobert Mustacchi int rc;
348d14abf15SRobert Mustacchi
349d14abf15SRobert Mustacchi /*
350d14abf15SRobert Mustacchi * Solaris identifies:
351d14abf15SRobert Mustacchi * BAR 0 - size 0 (pci config regs?)
352d14abf15SRobert Mustacchi * BAR 1 - size 0x800000 (Everest 1/2 LM BAR 0)
353d14abf15SRobert Mustacchi * BAR 2 - size 0x4000000 (Everest 1 LM BAR 1)
354d14abf15SRobert Mustacchi * 0x800000 (Everest 2 LM BAR 1)
355d14abf15SRobert Mustacchi * BAR 3 - size 0x10000 (Everest 2 LM BAR 2)
356d14abf15SRobert Mustacchi */
357d14abf15SRobert Mustacchi bar++;
358d14abf15SRobert Mustacchi
359d14abf15SRobert Mustacchi //ddi_dev_nregs(pUM->pDev, &numRegs);
360d14abf15SRobert Mustacchi
361d14abf15SRobert Mustacchi ddi_dev_regsize(pUM->pDev, bar, ®Size);
362d14abf15SRobert Mustacchi
363d14abf15SRobert Mustacchi if ((size > regSize) || BnxeIsBarUsed(pUM, bar, 0, size))
364d14abf15SRobert Mustacchi {
365d14abf15SRobert Mustacchi BnxeLogWarn(pUM, "BAR %d at offset %d and size %d is already being used!",
366d14abf15SRobert Mustacchi bar, 0, (int)regSize);
367d14abf15SRobert Mustacchi return NULL;
368d14abf15SRobert Mustacchi }
369d14abf15SRobert Mustacchi
370d14abf15SRobert Mustacchi if ((pMem = kmem_zalloc(sizeof(BnxeMemRegion), KM_NOSLEEP)) == NULL)
371d14abf15SRobert Mustacchi {
372d14abf15SRobert Mustacchi BnxeLogWarn(pUM, "Memory allocation for BAR %d at offset %d and size %d failed!",
373d14abf15SRobert Mustacchi bar, 0, (int)regSize);
374d14abf15SRobert Mustacchi return NULL;
375d14abf15SRobert Mustacchi }
376d14abf15SRobert Mustacchi
377d14abf15SRobert Mustacchi if ((rc = ddi_regs_map_setup(pUM->pDev,
378d14abf15SRobert Mustacchi bar, // bar number
379d14abf15SRobert Mustacchi &pMem->pRegAddr,
380d14abf15SRobert Mustacchi 0, // region map offset,
381d14abf15SRobert Mustacchi size, // region memory window size (0=all)
382d14abf15SRobert Mustacchi &bnxeAccessAttribBAR,
383d14abf15SRobert Mustacchi &pMem->regAccess)) != DDI_SUCCESS)
384d14abf15SRobert Mustacchi {
385d14abf15SRobert Mustacchi BnxeLogWarn(pUM, "Failed to memory map device (BAR=%d, offset=%d, size=%d) (%d)",
386d14abf15SRobert Mustacchi bar, 0, size, rc);
387d14abf15SRobert Mustacchi kmem_free(pMem, sizeof(BnxeMemRegion));
388d14abf15SRobert Mustacchi return NULL;
389d14abf15SRobert Mustacchi }
390d14abf15SRobert Mustacchi
391d14abf15SRobert Mustacchi pMem->baseAddr = baseAddr;
392d14abf15SRobert Mustacchi pMem->regNumber = bar;
393d14abf15SRobert Mustacchi pMem->offset = 0;
394d14abf15SRobert Mustacchi pMem->size = size;
395d14abf15SRobert Mustacchi
396d14abf15SRobert Mustacchi BNXE_LOCK_ENTER_MEM(pUM);
397d14abf15SRobert Mustacchi d_list_push_head(&pUM->memRegionList, D_LINK_CAST(pMem));
398d14abf15SRobert Mustacchi BNXE_LOCK_EXIT_MEM(pUM);
399d14abf15SRobert Mustacchi
400d14abf15SRobert Mustacchi bar--;
401d14abf15SRobert Mustacchi pLM->vars.reg_handle[bar] = pMem->regAccess;
402d14abf15SRobert Mustacchi
403d14abf15SRobert Mustacchi return pMem->pRegAddr;
404d14abf15SRobert Mustacchi }
405d14abf15SRobert Mustacchi
406d14abf15SRobert Mustacchi
mm_map_io_space_solaris(lm_device_t * pLM,lm_address_t physAddr,u8_t bar,u32_t offset,u32_t size,ddi_acc_handle_t * pRegAccHandle)407d14abf15SRobert Mustacchi void * mm_map_io_space_solaris(lm_device_t * pLM,
408d14abf15SRobert Mustacchi lm_address_t physAddr,
409d14abf15SRobert Mustacchi u8_t bar,
410d14abf15SRobert Mustacchi u32_t offset,
411d14abf15SRobert Mustacchi u32_t size,
412d14abf15SRobert Mustacchi ddi_acc_handle_t * pRegAccHandle)
413d14abf15SRobert Mustacchi {
414d14abf15SRobert Mustacchi um_device_t * pUM = (um_device_t *)pLM;
415d14abf15SRobert Mustacchi BnxeMemRegion * pMem;
416d14abf15SRobert Mustacchi off_t regSize;
417d14abf15SRobert Mustacchi int rc;
418d14abf15SRobert Mustacchi
419d14abf15SRobert Mustacchi /* see bar mapping described in mm_map_io_base above */
420d14abf15SRobert Mustacchi bar++;
421d14abf15SRobert Mustacchi
422d14abf15SRobert Mustacchi ddi_dev_regsize(pUM->pDev, bar, ®Size);
423d14abf15SRobert Mustacchi
424d14abf15SRobert Mustacchi if ((size > regSize) || BnxeIsBarUsed(pUM, bar, offset, size))
425d14abf15SRobert Mustacchi {
426d14abf15SRobert Mustacchi BnxeLogWarn(pUM, "BAR %d at offset %d and size %d is already being used!",
427d14abf15SRobert Mustacchi bar, offset, (int)regSize);
428d14abf15SRobert Mustacchi return NULL;
429d14abf15SRobert Mustacchi }
430d14abf15SRobert Mustacchi
431d14abf15SRobert Mustacchi if ((pMem = kmem_zalloc(sizeof(BnxeMemRegion), KM_NOSLEEP)) == NULL)
432d14abf15SRobert Mustacchi {
433d14abf15SRobert Mustacchi BnxeLogWarn(pUM, "Memory allocation for BAR %d at offset %d and size %d failed!",
434d14abf15SRobert Mustacchi bar, offset, (int)regSize);
435d14abf15SRobert Mustacchi return NULL;
436d14abf15SRobert Mustacchi }
437d14abf15SRobert Mustacchi
438d14abf15SRobert Mustacchi if ((rc = ddi_regs_map_setup(pUM->pDev,
439d14abf15SRobert Mustacchi bar, // bar number
440d14abf15SRobert Mustacchi &pMem->pRegAddr,
441d14abf15SRobert Mustacchi offset, // region map offset,
442d14abf15SRobert Mustacchi size, // region memory window size (0=all)
443d14abf15SRobert Mustacchi &bnxeAccessAttribBAR,
444d14abf15SRobert Mustacchi pRegAccHandle)) != DDI_SUCCESS)
445d14abf15SRobert Mustacchi {
446d14abf15SRobert Mustacchi BnxeLogWarn(pUM, "Failed to memory map device (BAR=%d, offset=%d, size=%d) (%d)",
447d14abf15SRobert Mustacchi bar, offset, size, rc);
448d14abf15SRobert Mustacchi kmem_free(pMem, sizeof(BnxeMemRegion));
449d14abf15SRobert Mustacchi return NULL;
450d14abf15SRobert Mustacchi }
451d14abf15SRobert Mustacchi
452d14abf15SRobert Mustacchi pMem->baseAddr = physAddr;
453d14abf15SRobert Mustacchi pMem->regNumber = bar;
454d14abf15SRobert Mustacchi pMem->offset = offset;
455d14abf15SRobert Mustacchi pMem->size = size;
456d14abf15SRobert Mustacchi pMem->regAccess = *pRegAccHandle;
457d14abf15SRobert Mustacchi
458d14abf15SRobert Mustacchi BNXE_LOCK_ENTER_MEM(pUM);
459d14abf15SRobert Mustacchi d_list_push_head(&pUM->memRegionList, D_LINK_CAST(pMem));
460d14abf15SRobert Mustacchi BNXE_LOCK_EXIT_MEM(pUM);
461d14abf15SRobert Mustacchi
462d14abf15SRobert Mustacchi return pMem->pRegAddr;
463d14abf15SRobert Mustacchi }
464d14abf15SRobert Mustacchi
465d14abf15SRobert Mustacchi
mm_unmap_io_space(lm_device_t * pLM,void * pVirtAddr,u32_t size)466d14abf15SRobert Mustacchi void mm_unmap_io_space(lm_device_t * pLM,
467d14abf15SRobert Mustacchi void * pVirtAddr,
468d14abf15SRobert Mustacchi u32_t size)
469d14abf15SRobert Mustacchi {
470d14abf15SRobert Mustacchi um_device_t * pUM = (um_device_t *)pLM;
471d14abf15SRobert Mustacchi BnxeMemRegion * pMemRegion;
472d14abf15SRobert Mustacchi
473d14abf15SRobert Mustacchi BNXE_LOCK_ENTER_MEM(pUM);
474d14abf15SRobert Mustacchi
475d14abf15SRobert Mustacchi pMemRegion = (BnxeMemRegion *)d_list_peek_head(&pUM->memRegionList);
476d14abf15SRobert Mustacchi
477d14abf15SRobert Mustacchi while (pMemRegion)
478d14abf15SRobert Mustacchi {
479d14abf15SRobert Mustacchi if ((pMemRegion->pRegAddr == pVirtAddr) &&
480d14abf15SRobert Mustacchi (pMemRegion->size == size))
481d14abf15SRobert Mustacchi {
482d14abf15SRobert Mustacchi d_list_remove_entry(&pUM->memRegionList, D_LINK_CAST(pMemRegion));
483d14abf15SRobert Mustacchi ddi_regs_map_free(&pMemRegion->regAccess);
484d14abf15SRobert Mustacchi kmem_free(pMemRegion, sizeof(BnxeMemRegion));
485d14abf15SRobert Mustacchi break;
486d14abf15SRobert Mustacchi }
487d14abf15SRobert Mustacchi
488d14abf15SRobert Mustacchi pMemRegion = (BnxeMemRegion *)d_list_next_entry(D_LINK_CAST(pMemRegion));
489d14abf15SRobert Mustacchi }
490d14abf15SRobert Mustacchi
491d14abf15SRobert Mustacchi BNXE_LOCK_EXIT_MEM(pUM);
492d14abf15SRobert Mustacchi }
493d14abf15SRobert Mustacchi
494d14abf15SRobert Mustacchi
mm_alloc_mem_imp(lm_device_t * pLM,u32_t memSize,const char * sz_file,const unsigned long line,u8_t cli_idx)495d14abf15SRobert Mustacchi void * mm_alloc_mem_imp(lm_device_t * pLM,
496d14abf15SRobert Mustacchi u32_t memSize,
497d14abf15SRobert Mustacchi const char * sz_file,
498d14abf15SRobert Mustacchi const unsigned long line,
499d14abf15SRobert Mustacchi u8_t cli_idx)
500d14abf15SRobert Mustacchi {
501d14abf15SRobert Mustacchi um_device_t * pUM = (um_device_t *)pLM;
502d14abf15SRobert Mustacchi BnxeMemBlock * pMem;
503d14abf15SRobert Mustacchi void * pBuf;
504d14abf15SRobert Mustacchi u32_t * pTmp;
505d14abf15SRobert Mustacchi int i;
506d14abf15SRobert Mustacchi
507d14abf15SRobert Mustacchi (void)cli_idx;
508d14abf15SRobert Mustacchi
509d14abf15SRobert Mustacchi if ((pMem = kmem_zalloc(sizeof(BnxeMemBlock), KM_NOSLEEP)) == NULL)
510d14abf15SRobert Mustacchi {
511d14abf15SRobert Mustacchi return NULL;
512d14abf15SRobert Mustacchi }
513d14abf15SRobert Mustacchi
514d14abf15SRobert Mustacchi /* allocated space for header/trailer checks */
515d14abf15SRobert Mustacchi memSize += (BNXE_MEM_CHECK_LEN * 2);
516d14abf15SRobert Mustacchi
517d14abf15SRobert Mustacchi MEM_LOG(pUM, "*** MEM: %8u", memSize);
518d14abf15SRobert Mustacchi
519d14abf15SRobert Mustacchi if ((pBuf = kmem_zalloc(memSize, KM_NOSLEEP)) == NULL)
520d14abf15SRobert Mustacchi {
521d14abf15SRobert Mustacchi BnxeLogWarn(pUM, "Failed to allocate memory");
522d14abf15SRobert Mustacchi kmem_free(pMem, sizeof(BnxeMemBlock));
523d14abf15SRobert Mustacchi return NULL;
524d14abf15SRobert Mustacchi }
525d14abf15SRobert Mustacchi
526d14abf15SRobert Mustacchi /* fill in the header check */
527d14abf15SRobert Mustacchi for (i = 0, pTmp = (u32_t *)pBuf;
528d14abf15SRobert Mustacchi i < BNXE_MEM_CHECK_LEN;
529d14abf15SRobert Mustacchi i += 4, pTmp++)
530d14abf15SRobert Mustacchi {
531d14abf15SRobert Mustacchi *pTmp = BNXE_MAGIC;
532d14abf15SRobert Mustacchi }
533d14abf15SRobert Mustacchi
534d14abf15SRobert Mustacchi /* fill in the trailer check */
535d14abf15SRobert Mustacchi for (i = 0, pTmp = (u32_t *)((char *)pBuf + memSize - BNXE_MEM_CHECK_LEN);
536d14abf15SRobert Mustacchi i < BNXE_MEM_CHECK_LEN;
537d14abf15SRobert Mustacchi i += 4, pTmp++)
538d14abf15SRobert Mustacchi {
539d14abf15SRobert Mustacchi *pTmp = BNXE_MAGIC;
540d14abf15SRobert Mustacchi }
541d14abf15SRobert Mustacchi
542d14abf15SRobert Mustacchi pMem->size = memSize;
543d14abf15SRobert Mustacchi pMem->pBuf = pBuf;
544d14abf15SRobert Mustacchi snprintf(pMem->fileName, sizeof(pMem->fileName), "%s", sz_file);
545d14abf15SRobert Mustacchi pMem->fileLine = line;
546d14abf15SRobert Mustacchi
547d14abf15SRobert Mustacchi BNXE_LOCK_ENTER_MEM(pUM);
548d14abf15SRobert Mustacchi d_list_push_head(&pUM->memBlockList, D_LINK_CAST(pMem));
549d14abf15SRobert Mustacchi BNXE_LOCK_EXIT_MEM(pUM);
550d14abf15SRobert Mustacchi
551d14abf15SRobert Mustacchi MEM_LOG(pUM, "Allocated %d byte block virt:%p",
552d14abf15SRobert Mustacchi memSize, ((char *)pBuf + BNXE_MEM_CHECK_LEN));
553d14abf15SRobert Mustacchi
554d14abf15SRobert Mustacchi return ((char *)pBuf + BNXE_MEM_CHECK_LEN);
555d14abf15SRobert Mustacchi }
556d14abf15SRobert Mustacchi
557d14abf15SRobert Mustacchi
mm_alloc_phys_mem_align_imp(lm_device_t * pLM,u32_t memSize,lm_address_t * pPhysAddr,u32_t alignment,u8_t memType,const char * sz_file,const unsigned long line,u8_t cli_idx)558d14abf15SRobert Mustacchi void * mm_alloc_phys_mem_align_imp(lm_device_t * pLM,
559d14abf15SRobert Mustacchi u32_t memSize,
560d14abf15SRobert Mustacchi lm_address_t * pPhysAddr,
561d14abf15SRobert Mustacchi u32_t alignment,
562d14abf15SRobert Mustacchi u8_t memType,
563d14abf15SRobert Mustacchi const char * sz_file,
564d14abf15SRobert Mustacchi const unsigned long line,
565d14abf15SRobert Mustacchi u8_t cli_idx)
566d14abf15SRobert Mustacchi {
567d14abf15SRobert Mustacchi um_device_t * pUM = (um_device_t *)pLM;
568d14abf15SRobert Mustacchi int rc;
569d14abf15SRobert Mustacchi caddr_t pBuf;
570d14abf15SRobert Mustacchi size_t length;
571d14abf15SRobert Mustacchi unsigned int count;
572d14abf15SRobert Mustacchi ddi_dma_attr_t dmaAttrib;
573d14abf15SRobert Mustacchi ddi_dma_handle_t * pDmaHandle;
574d14abf15SRobert Mustacchi ddi_acc_handle_t * pDmaAccHandle;
575d14abf15SRobert Mustacchi ddi_dma_cookie_t cookie;
576d14abf15SRobert Mustacchi BnxeMemDma * pMem;
577d14abf15SRobert Mustacchi size_t size;
578d14abf15SRobert Mustacchi
579d14abf15SRobert Mustacchi (void)memType;
580d14abf15SRobert Mustacchi (void)cli_idx;
581d14abf15SRobert Mustacchi
582d14abf15SRobert Mustacchi if (memSize == 0)
583d14abf15SRobert Mustacchi {
584d14abf15SRobert Mustacchi return NULL;
585d14abf15SRobert Mustacchi }
586d14abf15SRobert Mustacchi
587d14abf15SRobert Mustacchi if ((pMem = kmem_zalloc(sizeof(BnxeMemDma), KM_NOSLEEP)) == NULL)
588d14abf15SRobert Mustacchi {
589d14abf15SRobert Mustacchi return NULL;
590d14abf15SRobert Mustacchi }
591d14abf15SRobert Mustacchi
592d14abf15SRobert Mustacchi dmaAttrib = bnxeDmaPageAttrib;
593d14abf15SRobert Mustacchi dmaAttrib.dma_attr_align = alignment;
594d14abf15SRobert Mustacchi
595d14abf15SRobert Mustacchi pDmaHandle = &pMem->dmaHandle;
596d14abf15SRobert Mustacchi pDmaAccHandle = &pMem->dmaAccHandle;
597d14abf15SRobert Mustacchi
598d14abf15SRobert Mustacchi size = memSize;
599d14abf15SRobert Mustacchi size += (alignment - 1);
600d14abf15SRobert Mustacchi size &= ~((u32_t)(alignment - 1));
601d14abf15SRobert Mustacchi
602d14abf15SRobert Mustacchi MEM_LOG(pUM, "*** DMA: %8u (%4d) - %8u", memSize, alignment, size);
603d14abf15SRobert Mustacchi
604d14abf15SRobert Mustacchi if ((rc = ddi_dma_alloc_handle(pUM->pDev,
605d14abf15SRobert Mustacchi &dmaAttrib,
606d14abf15SRobert Mustacchi DDI_DMA_DONTWAIT,
607d14abf15SRobert Mustacchi (void *)0,
608d14abf15SRobert Mustacchi pDmaHandle)) != DDI_SUCCESS)
609d14abf15SRobert Mustacchi {
610d14abf15SRobert Mustacchi BnxeLogWarn(pUM, "Failed to alloc DMA handle");
611d14abf15SRobert Mustacchi kmem_free(pMem, sizeof(BnxeMemDma));
612d14abf15SRobert Mustacchi return NULL;
613d14abf15SRobert Mustacchi }
614d14abf15SRobert Mustacchi
615d14abf15SRobert Mustacchi if ((rc = ddi_dma_mem_alloc(*pDmaHandle,
616d14abf15SRobert Mustacchi size,
617d14abf15SRobert Mustacchi &bnxeAccessAttribBUF,
618d14abf15SRobert Mustacchi DDI_DMA_CONSISTENT,
619d14abf15SRobert Mustacchi DDI_DMA_DONTWAIT,
620d14abf15SRobert Mustacchi (void *)0,
621d14abf15SRobert Mustacchi &pBuf,
622d14abf15SRobert Mustacchi &length,
623d14abf15SRobert Mustacchi pDmaAccHandle)) != DDI_SUCCESS)
624d14abf15SRobert Mustacchi {
625d14abf15SRobert Mustacchi BnxeLogWarn(pUM, "Failed to alloc DMA memory");
626d14abf15SRobert Mustacchi ddi_dma_free_handle(pDmaHandle);
627d14abf15SRobert Mustacchi kmem_free(pMem, sizeof(BnxeMemDma));
628d14abf15SRobert Mustacchi return NULL;
629d14abf15SRobert Mustacchi }
630d14abf15SRobert Mustacchi
631d14abf15SRobert Mustacchi if ((rc = ddi_dma_addr_bind_handle(*pDmaHandle,
632d14abf15SRobert Mustacchi (struct as *)0,
633d14abf15SRobert Mustacchi pBuf,
634d14abf15SRobert Mustacchi length,
635d14abf15SRobert Mustacchi DDI_DMA_RDWR | DDI_DMA_CONSISTENT,
636d14abf15SRobert Mustacchi DDI_DMA_DONTWAIT,
637d14abf15SRobert Mustacchi (void *)0,
638d14abf15SRobert Mustacchi &cookie,
639d14abf15SRobert Mustacchi &count)) != DDI_DMA_MAPPED)
640d14abf15SRobert Mustacchi {
641d14abf15SRobert Mustacchi BnxeLogWarn(pUM, "Failed to bind DMA address");
642d14abf15SRobert Mustacchi ddi_dma_mem_free(pDmaAccHandle);
643d14abf15SRobert Mustacchi ddi_dma_free_handle(pDmaHandle);
644d14abf15SRobert Mustacchi kmem_free(pMem, sizeof(BnxeMemDma));
645d14abf15SRobert Mustacchi return NULL;
646d14abf15SRobert Mustacchi }
647d14abf15SRobert Mustacchi
648d14abf15SRobert Mustacchi pPhysAddr->as_u64 = cookie.dmac_laddress;
649d14abf15SRobert Mustacchi
650d14abf15SRobert Mustacchi /* save the virtual memory address so we can get the dma_handle later */
651d14abf15SRobert Mustacchi pMem->size = memSize;
652d14abf15SRobert Mustacchi pMem->pDmaVirt = pBuf;
653d14abf15SRobert Mustacchi pMem->physAddr = *pPhysAddr;
654d14abf15SRobert Mustacchi snprintf(pMem->fileName, sizeof(pMem->fileName), "%s", sz_file);
655d14abf15SRobert Mustacchi pMem->fileLine = line;
656d14abf15SRobert Mustacchi
657d14abf15SRobert Mustacchi #if 0
658d14abf15SRobert Mustacchi MEM_LOG(pUM, "*** DMA: virt %p / phys 0x%0llx (%d/%d)",
659d14abf15SRobert Mustacchi pBuf, pPhysAddr->as_u64,
660d14abf15SRobert Mustacchi (!((u32_t)pBuf % (u32_t)alignment)) ? 1 : 0,
661d14abf15SRobert Mustacchi (!((u32_t)pPhysAddr->as_ptr % (u32_t)alignment) ? 1 : 0));
662d14abf15SRobert Mustacchi #endif
663d14abf15SRobert Mustacchi
664d14abf15SRobert Mustacchi BNXE_LOCK_ENTER_MEM(pUM);
665d14abf15SRobert Mustacchi d_list_push_head(&pUM->memDmaList, D_LINK_CAST(pMem));
666d14abf15SRobert Mustacchi BNXE_LOCK_EXIT_MEM(pUM);
667d14abf15SRobert Mustacchi
668d14abf15SRobert Mustacchi MEM_LOG(pUM, "Allocated %d sized DMA block phys:%p virt:%p",
669d14abf15SRobert Mustacchi memSize, pMem->physAddr.as_ptr, pMem->pDmaVirt);
670d14abf15SRobert Mustacchi
671d14abf15SRobert Mustacchi /* Zero memory! */
672d14abf15SRobert Mustacchi bzero(pBuf, length);
673d14abf15SRobert Mustacchi
674d14abf15SRobert Mustacchi /* make sure the new contents are flushed back to main memory */
675d14abf15SRobert Mustacchi ddi_dma_sync(*pDmaHandle, 0, length, DDI_DMA_SYNC_FORDEV);
676d14abf15SRobert Mustacchi
677d14abf15SRobert Mustacchi return pBuf;
678d14abf15SRobert Mustacchi }
679d14abf15SRobert Mustacchi
680d14abf15SRobert Mustacchi
mm_alloc_phys_mem_imp(lm_device_t * pLM,u32_t memSize,lm_address_t * pPhysAddr,u8_t memType,const char * sz_file,const unsigned long line,u8_t cli_idx)681d14abf15SRobert Mustacchi void * mm_alloc_phys_mem_imp(lm_device_t * pLM,
682d14abf15SRobert Mustacchi u32_t memSize,
683d14abf15SRobert Mustacchi lm_address_t * pPhysAddr,
684d14abf15SRobert Mustacchi u8_t memType,
685d14abf15SRobert Mustacchi const char * sz_file,
686d14abf15SRobert Mustacchi const unsigned long line,
687d14abf15SRobert Mustacchi u8_t cli_idx)
688d14abf15SRobert Mustacchi {
689d14abf15SRobert Mustacchi return mm_alloc_phys_mem_align_imp(pLM, memSize, pPhysAddr,
690d14abf15SRobert Mustacchi BNXE_DMA_ALIGNMENT, memType,
691d14abf15SRobert Mustacchi sz_file, line, cli_idx);
692d14abf15SRobert Mustacchi }
693d14abf15SRobert Mustacchi
694d14abf15SRobert Mustacchi
mm_rt_alloc_mem_imp(lm_device_t * pDev,u32_t memSize,const char * sz_file,const unsigned long line,u8_t cli_idx)695d14abf15SRobert Mustacchi void * mm_rt_alloc_mem_imp(lm_device_t * pDev,
696d14abf15SRobert Mustacchi u32_t memSize,
697d14abf15SRobert Mustacchi const char * sz_file,
698d14abf15SRobert Mustacchi const unsigned long line,
699d14abf15SRobert Mustacchi u8_t cli_idx)
700d14abf15SRobert Mustacchi {
701d14abf15SRobert Mustacchi return mm_alloc_mem_imp(pDev, memSize, sz_file, line, cli_idx);
702d14abf15SRobert Mustacchi }
703d14abf15SRobert Mustacchi
704d14abf15SRobert Mustacchi
mm_rt_alloc_phys_mem_imp(lm_device_t * pDev,u32_t memSize,lm_address_t * pPhysAddr,u8_t flushType,const char * sz_file,const unsigned long line,u8_t cli_idx)705d14abf15SRobert Mustacchi void * mm_rt_alloc_phys_mem_imp(lm_device_t * pDev,
706d14abf15SRobert Mustacchi u32_t memSize,
707d14abf15SRobert Mustacchi lm_address_t * pPhysAddr,
708d14abf15SRobert Mustacchi u8_t flushType,
709d14abf15SRobert Mustacchi const char * sz_file,
710d14abf15SRobert Mustacchi const unsigned long line,
711d14abf15SRobert Mustacchi u8_t cli_idx)
712d14abf15SRobert Mustacchi {
713d14abf15SRobert Mustacchi return mm_alloc_phys_mem_imp(pDev, memSize, pPhysAddr, flushType,
714d14abf15SRobert Mustacchi sz_file, line, cli_idx);
715d14abf15SRobert Mustacchi }
716d14abf15SRobert Mustacchi
717d14abf15SRobert Mustacchi
mm_get_current_time(lm_device_t * pDev)718d14abf15SRobert Mustacchi u64_t mm_get_current_time(lm_device_t * pDev)
719d14abf15SRobert Mustacchi {
720d14abf15SRobert Mustacchi um_device_t * pUM = (um_device_t *)pDev;
721d14abf15SRobert Mustacchi BnxeDbgBreakMsg(pUM, "MM_GET_CURRENT_TIME");
722d14abf15SRobert Mustacchi return 0;
723d14abf15SRobert Mustacchi }
724d14abf15SRobert Mustacchi
725d14abf15SRobert Mustacchi
mm_rt_free_mem(lm_device_t * pDev,void * pBuf,u32_t memSize,u8_t cli_idx)726d14abf15SRobert Mustacchi void mm_rt_free_mem(lm_device_t * pDev,
727d14abf15SRobert Mustacchi void * pBuf,
728d14abf15SRobert Mustacchi u32_t memSize,
729d14abf15SRobert Mustacchi u8_t cli_idx)
730d14abf15SRobert Mustacchi {
731d14abf15SRobert Mustacchi um_device_t * pUM = (um_device_t *)pDev;
732d14abf15SRobert Mustacchi BnxeMemBlock * pMem;
733d14abf15SRobert Mustacchi u32_t * pTmp;
734d14abf15SRobert Mustacchi int i;
735d14abf15SRobert Mustacchi
736d14abf15SRobert Mustacchi (void)cli_idx;
737d14abf15SRobert Mustacchi
738d14abf15SRobert Mustacchi BNXE_LOCK_ENTER_MEM(pUM);
739d14abf15SRobert Mustacchi
740d14abf15SRobert Mustacchi pMem = (BnxeMemBlock *)d_list_peek_head(&pUM->memBlockList);
741d14abf15SRobert Mustacchi
742d14abf15SRobert Mustacchi /* adjuest for header/trailer checks */
743d14abf15SRobert Mustacchi pBuf = ((char *)pBuf - BNXE_MEM_CHECK_LEN);
744d14abf15SRobert Mustacchi memSize += (BNXE_MEM_CHECK_LEN * 2);
745d14abf15SRobert Mustacchi
746d14abf15SRobert Mustacchi /* verify header check */
747d14abf15SRobert Mustacchi for (i = 0, pTmp = (u32_t *)pBuf;
748d14abf15SRobert Mustacchi i < BNXE_MEM_CHECK_LEN;
749d14abf15SRobert Mustacchi i += 4, pTmp++)
750d14abf15SRobert Mustacchi {
751d14abf15SRobert Mustacchi if (*pTmp != BNXE_MAGIC)
752d14abf15SRobert Mustacchi {
753d14abf15SRobert Mustacchi BnxeLogWarn(pUM, "Header overflow! (%p/%u)", pBuf, memSize);
754d14abf15SRobert Mustacchi BnxeDbgBreak(pUM);
755d14abf15SRobert Mustacchi }
756d14abf15SRobert Mustacchi }
757d14abf15SRobert Mustacchi
758d14abf15SRobert Mustacchi /* verify trailer check */
759d14abf15SRobert Mustacchi for (i = 0, pTmp = (u32_t *)((char *)pBuf + memSize - BNXE_MEM_CHECK_LEN);
760d14abf15SRobert Mustacchi i < BNXE_MEM_CHECK_LEN;
761d14abf15SRobert Mustacchi i += 4, pTmp++)
762d14abf15SRobert Mustacchi {
763d14abf15SRobert Mustacchi if (*pTmp != BNXE_MAGIC)
764d14abf15SRobert Mustacchi {
765d14abf15SRobert Mustacchi BnxeLogWarn(pUM, "Trailer overflow! (%p/%u)", pBuf, memSize);
766d14abf15SRobert Mustacchi BnxeDbgBreak(pUM);
767d14abf15SRobert Mustacchi }
768d14abf15SRobert Mustacchi }
769d14abf15SRobert Mustacchi
770d14abf15SRobert Mustacchi while (pMem)
771d14abf15SRobert Mustacchi {
772d14abf15SRobert Mustacchi if (pBuf == pMem->pBuf)
773d14abf15SRobert Mustacchi {
774d14abf15SRobert Mustacchi if (memSize != pMem->size)
775d14abf15SRobert Mustacchi {
776d14abf15SRobert Mustacchi /* Uh-Oh! */
777d14abf15SRobert Mustacchi BnxeLogWarn(pUM, "Attempt to free memory block with invalid size (%d/%d)",
778d14abf15SRobert Mustacchi memSize, pMem->size);
779d14abf15SRobert Mustacchi BnxeDbgBreak(pUM);
780d14abf15SRobert Mustacchi
781d14abf15SRobert Mustacchi BNXE_LOCK_EXIT_MEM(pUM);
782d14abf15SRobert Mustacchi return;
783d14abf15SRobert Mustacchi }
784d14abf15SRobert Mustacchi
785d14abf15SRobert Mustacchi d_list_remove_entry(&pUM->memBlockList, D_LINK_CAST(pMem));
786d14abf15SRobert Mustacchi
787d14abf15SRobert Mustacchi kmem_free(pBuf, memSize);
788d14abf15SRobert Mustacchi kmem_free(pMem, sizeof(BnxeMemBlock));
789d14abf15SRobert Mustacchi
790d14abf15SRobert Mustacchi BNXE_LOCK_EXIT_MEM(pUM);
791d14abf15SRobert Mustacchi return;
792d14abf15SRobert Mustacchi }
793d14abf15SRobert Mustacchi
794d14abf15SRobert Mustacchi pMem = (BnxeMemBlock *)d_list_next_entry(D_LINK_CAST(pMem));
795d14abf15SRobert Mustacchi }
796d14abf15SRobert Mustacchi
797d14abf15SRobert Mustacchi BNXE_LOCK_EXIT_MEM(pUM);
798d14abf15SRobert Mustacchi }
799d14abf15SRobert Mustacchi
800d14abf15SRobert Mustacchi
mm_rt_free_phys_mem(lm_device_t * pDev,u32_t memSize,void * pBuf,lm_address_t pPhysAddr,u8_t cli_idx)801d14abf15SRobert Mustacchi void mm_rt_free_phys_mem(lm_device_t * pDev,
802d14abf15SRobert Mustacchi u32_t memSize,
803d14abf15SRobert Mustacchi void * pBuf,
804d14abf15SRobert Mustacchi lm_address_t pPhysAddr,
805d14abf15SRobert Mustacchi u8_t cli_idx)
806d14abf15SRobert Mustacchi {
807d14abf15SRobert Mustacchi um_device_t * pUM = (um_device_t *)pDev;
808d14abf15SRobert Mustacchi BnxeMemDma * pMem;
809d14abf15SRobert Mustacchi
810d14abf15SRobert Mustacchi (void)pPhysAddr;
811d14abf15SRobert Mustacchi (void)cli_idx;
812d14abf15SRobert Mustacchi
813d14abf15SRobert Mustacchi BNXE_LOCK_ENTER_MEM(pUM);
814d14abf15SRobert Mustacchi
815d14abf15SRobert Mustacchi pMem = (BnxeMemDma *)d_list_peek_head(&pUM->memDmaList);
816d14abf15SRobert Mustacchi
817d14abf15SRobert Mustacchi while (pMem)
818d14abf15SRobert Mustacchi {
819d14abf15SRobert Mustacchi if (pBuf == pMem->pDmaVirt)
820d14abf15SRobert Mustacchi {
821d14abf15SRobert Mustacchi if (memSize != pMem->size)
822d14abf15SRobert Mustacchi {
823d14abf15SRobert Mustacchi /* Uh-Oh! */
824d14abf15SRobert Mustacchi BnxeLogWarn(pUM, "Attempt to free DMA memory with invalid size (%d/%d)",
825d14abf15SRobert Mustacchi memSize, pMem->size);
826d14abf15SRobert Mustacchi BnxeDbgBreak(pUM);
827d14abf15SRobert Mustacchi
828d14abf15SRobert Mustacchi BNXE_LOCK_EXIT_MEM(pUM);
829d14abf15SRobert Mustacchi return;
830d14abf15SRobert Mustacchi }
831d14abf15SRobert Mustacchi
832d14abf15SRobert Mustacchi d_list_remove_entry(&pUM->memDmaList, D_LINK_CAST(pMem));
833d14abf15SRobert Mustacchi
834d14abf15SRobert Mustacchi ddi_dma_unbind_handle(pMem->dmaHandle);
835d14abf15SRobert Mustacchi ddi_dma_mem_free(&pMem->dmaAccHandle);
836d14abf15SRobert Mustacchi ddi_dma_free_handle(&pMem->dmaHandle);
837d14abf15SRobert Mustacchi kmem_free(pMem, sizeof(BnxeMemDma));
838d14abf15SRobert Mustacchi
839d14abf15SRobert Mustacchi BNXE_LOCK_EXIT_MEM(pUM);
840d14abf15SRobert Mustacchi return;
841d14abf15SRobert Mustacchi }
842d14abf15SRobert Mustacchi
843d14abf15SRobert Mustacchi pMem = (BnxeMemDma *)d_list_next_entry(D_LINK_CAST(pMem));
844d14abf15SRobert Mustacchi }
845d14abf15SRobert Mustacchi
846d14abf15SRobert Mustacchi BNXE_LOCK_EXIT_MEM(pUM);
847d14abf15SRobert Mustacchi }
848d14abf15SRobert Mustacchi
849d14abf15SRobert Mustacchi
mm_memset(void * pBuf,u8_t val,u32_t memSize)850d14abf15SRobert Mustacchi void mm_memset(void * pBuf,
851d14abf15SRobert Mustacchi u8_t val,
852d14abf15SRobert Mustacchi u32_t memSize)
853d14abf15SRobert Mustacchi {
854d14abf15SRobert Mustacchi memset(pBuf, val, memSize);
855d14abf15SRobert Mustacchi }
856d14abf15SRobert Mustacchi
857d14abf15SRobert Mustacchi
mm_memcpy(void * pDest,const void * pSrc,u32_t memSize)858d14abf15SRobert Mustacchi void mm_memcpy(void * pDest,
859d14abf15SRobert Mustacchi const void * pSrc,
860d14abf15SRobert Mustacchi u32_t memSize)
861d14abf15SRobert Mustacchi {
862d14abf15SRobert Mustacchi memcpy(pDest, pSrc, memSize);
863d14abf15SRobert Mustacchi }
864d14abf15SRobert Mustacchi
865d14abf15SRobert Mustacchi
mm_memcmp(void * pBuf1,void * pBuf2,u32_t count)866d14abf15SRobert Mustacchi u8_t mm_memcmp(void * pBuf1,
867d14abf15SRobert Mustacchi void * pBuf2,
868d14abf15SRobert Mustacchi u32_t count)
869d14abf15SRobert Mustacchi {
870d14abf15SRobert Mustacchi return (memcmp(pBuf1, pBuf2, count) == 0) ? 1 : 0;
871d14abf15SRobert Mustacchi }
872d14abf15SRobert Mustacchi
873d14abf15SRobert Mustacchi
mm_indicate_tx(lm_device_t * pLM,u32_t idx,s_list_t * packet_list)874d14abf15SRobert Mustacchi void mm_indicate_tx(lm_device_t * pLM,
875d14abf15SRobert Mustacchi u32_t idx,
876d14abf15SRobert Mustacchi s_list_t * packet_list)
877d14abf15SRobert Mustacchi {
878d14abf15SRobert Mustacchi BnxeTxPktsReclaim((um_device_t *)pLM, idx, packet_list);
879d14abf15SRobert Mustacchi }
880d14abf15SRobert Mustacchi
881d14abf15SRobert Mustacchi
mm_set_done(lm_device_t * pDev,u32_t cid,void * cookie)882d14abf15SRobert Mustacchi void mm_set_done(lm_device_t * pDev,
883d14abf15SRobert Mustacchi u32_t cid,
884d14abf15SRobert Mustacchi void * cookie)
885d14abf15SRobert Mustacchi {
886d14abf15SRobert Mustacchi #if 0
887d14abf15SRobert Mustacchi um_device_t * pUM = (um_device_t *)pDev;
888d14abf15SRobert Mustacchi BnxeLogInfo(pUM, "RAMROD on cid %d cmd is done", cid);
889d14abf15SRobert Mustacchi #else
890d14abf15SRobert Mustacchi (void)pDev;
891d14abf15SRobert Mustacchi (void)cid;
892d14abf15SRobert Mustacchi #endif
893d14abf15SRobert Mustacchi }
894d14abf15SRobert Mustacchi
895d14abf15SRobert Mustacchi
mm_return_sq_pending_command(lm_device_t * pDev,struct sq_pending_command * pPending)896d14abf15SRobert Mustacchi void mm_return_sq_pending_command(lm_device_t * pDev,
897d14abf15SRobert Mustacchi struct sq_pending_command * pPending)
898d14abf15SRobert Mustacchi {
899d14abf15SRobert Mustacchi /* XXX probably need a memory pool to pull from... */
900d14abf15SRobert Mustacchi mm_rt_free_mem(pDev, pPending, sizeof(struct sq_pending_command),
901d14abf15SRobert Mustacchi LM_CLI_IDX_NDIS);
902d14abf15SRobert Mustacchi }
903d14abf15SRobert Mustacchi
904d14abf15SRobert Mustacchi
mm_get_sq_pending_command(lm_device_t * pDev)905d14abf15SRobert Mustacchi struct sq_pending_command * mm_get_sq_pending_command(lm_device_t * pDev)
906d14abf15SRobert Mustacchi {
907d14abf15SRobert Mustacchi /* XXX probably need a memory pool to pull from... */
908d14abf15SRobert Mustacchi return mm_rt_alloc_mem(pDev, sizeof(struct sq_pending_command),
909d14abf15SRobert Mustacchi LM_CLI_IDX_NDIS);
910d14abf15SRobert Mustacchi }
911d14abf15SRobert Mustacchi
912d14abf15SRobert Mustacchi
mm_copy_packet_buf(lm_device_t * pDev,lm_packet_t * pLMPkt,u8_t * pMemBuf,u32_t size)913d14abf15SRobert Mustacchi u32_t mm_copy_packet_buf(lm_device_t * pDev,
914d14abf15SRobert Mustacchi lm_packet_t * pLMPkt,
915d14abf15SRobert Mustacchi u8_t * pMemBuf,
916d14abf15SRobert Mustacchi u32_t size)
917d14abf15SRobert Mustacchi {
918d14abf15SRobert Mustacchi //um_device_t * pUM = (um_device_t *)pDev;
919d14abf15SRobert Mustacchi um_txpacket_t * pTxPkt = (um_txpacket_t *)pLMPkt;
920d14abf15SRobert Mustacchi mblk_t * pMblk;
921d14abf15SRobert Mustacchi u32_t copied;
922d14abf15SRobert Mustacchi u32_t mblkDataLen;
923d14abf15SRobert Mustacchi u32_t toCopy;
924d14abf15SRobert Mustacchi
925d14abf15SRobert Mustacchi pMblk = pTxPkt->pMblk;
926d14abf15SRobert Mustacchi copied = 0;
927d14abf15SRobert Mustacchi
928d14abf15SRobert Mustacchi while (size && pMblk)
929d14abf15SRobert Mustacchi {
930d14abf15SRobert Mustacchi mblkDataLen = (pMblk->b_wptr - pMblk->b_rptr);
931d14abf15SRobert Mustacchi toCopy = (mblkDataLen <= size) ? mblkDataLen : size;
932d14abf15SRobert Mustacchi
933d14abf15SRobert Mustacchi bcopy(pMblk->b_rptr, pMemBuf, toCopy);
934d14abf15SRobert Mustacchi
935d14abf15SRobert Mustacchi pMemBuf += toCopy;
936d14abf15SRobert Mustacchi copied += toCopy;
937d14abf15SRobert Mustacchi size -= toCopy;
938d14abf15SRobert Mustacchi
939d14abf15SRobert Mustacchi pMblk = pMblk->b_cont;
940d14abf15SRobert Mustacchi }
941d14abf15SRobert Mustacchi
942d14abf15SRobert Mustacchi return copied;
943d14abf15SRobert Mustacchi }
944d14abf15SRobert Mustacchi
945d14abf15SRobert Mustacchi
mm_fan_failure(lm_device_t * pDev)946d14abf15SRobert Mustacchi lm_status_t mm_fan_failure(lm_device_t * pDev)
947d14abf15SRobert Mustacchi {
948d14abf15SRobert Mustacchi um_device_t * pUM = (um_device_t *)pDev;
949d14abf15SRobert Mustacchi BnxeLogWarn(pUM, "FAN FAILURE!");
950d14abf15SRobert Mustacchi return LM_STATUS_SUCCESS;
951d14abf15SRobert Mustacchi }
952d14abf15SRobert Mustacchi
953d14abf15SRobert Mustacchi
BnxeLinkStatus(um_device_t * pUM,lm_status_t link,lm_medium_t medium)954d14abf15SRobert Mustacchi static void BnxeLinkStatus(um_device_t * pUM,
955d14abf15SRobert Mustacchi lm_status_t link,
956d14abf15SRobert Mustacchi lm_medium_t medium)
957d14abf15SRobert Mustacchi {
958d14abf15SRobert Mustacchi #define TBUF_SIZE 64
959d14abf15SRobert Mustacchi char tbuf[TBUF_SIZE];
960d14abf15SRobert Mustacchi char * pDuplex;
961d14abf15SRobert Mustacchi char * pRxFlow;
962d14abf15SRobert Mustacchi char * pTxFlow;
963d14abf15SRobert Mustacchi char * pSpeed;
964d14abf15SRobert Mustacchi
965d14abf15SRobert Mustacchi if (link != LM_STATUS_LINK_ACTIVE)
966d14abf15SRobert Mustacchi {
967d14abf15SRobert Mustacchi /* reset the link status */
968d14abf15SRobert Mustacchi pUM->props.link_speed = 0;
969d14abf15SRobert Mustacchi pUM->props.link_duplex = B_FALSE;
970d14abf15SRobert Mustacchi pUM->props.link_txpause = B_FALSE;
971d14abf15SRobert Mustacchi pUM->props.link_rxpause = B_FALSE;
972d14abf15SRobert Mustacchi pUM->props.uptime = 0;
973d14abf15SRobert Mustacchi
974d14abf15SRobert Mustacchi /* reset the link partner status */
975d14abf15SRobert Mustacchi pUM->remote.link_autoneg = B_FALSE;
976d14abf15SRobert Mustacchi pUM->remote.param_20000fdx = B_FALSE;
977d14abf15SRobert Mustacchi pUM->remote.param_10000fdx = B_FALSE;
978d14abf15SRobert Mustacchi pUM->remote.param_2500fdx = B_FALSE;
979d14abf15SRobert Mustacchi pUM->remote.param_1000fdx = B_FALSE;
980d14abf15SRobert Mustacchi pUM->remote.param_100fdx = B_FALSE;
981d14abf15SRobert Mustacchi pUM->remote.param_100hdx = B_FALSE;
982d14abf15SRobert Mustacchi pUM->remote.param_10fdx = B_FALSE;
983d14abf15SRobert Mustacchi pUM->remote.param_10hdx = B_FALSE;
984d14abf15SRobert Mustacchi pUM->remote.param_txpause = B_FALSE;
985d14abf15SRobert Mustacchi pUM->remote.param_rxpause = B_FALSE;
986d14abf15SRobert Mustacchi
987d14abf15SRobert Mustacchi BnxeLogInfo(pUM, "Link Down");
988d14abf15SRobert Mustacchi return;
989d14abf15SRobert Mustacchi }
990d14abf15SRobert Mustacchi
991d14abf15SRobert Mustacchi pUM->props.uptime = ddi_get_time();
992d14abf15SRobert Mustacchi
993d14abf15SRobert Mustacchi if (GET_MEDIUM_DUPLEX(medium) == LM_MEDIUM_HALF_DUPLEX)
994d14abf15SRobert Mustacchi {
995d14abf15SRobert Mustacchi pDuplex = "Half";
996d14abf15SRobert Mustacchi pUM->props.link_duplex = B_FALSE;
997d14abf15SRobert Mustacchi }
998d14abf15SRobert Mustacchi else
999d14abf15SRobert Mustacchi {
1000d14abf15SRobert Mustacchi pDuplex = "Full";
1001d14abf15SRobert Mustacchi pUM->props.link_duplex = B_TRUE;
1002d14abf15SRobert Mustacchi }
1003d14abf15SRobert Mustacchi
1004d14abf15SRobert Mustacchi if (pUM->lm_dev.vars.flow_control & LM_FLOW_CONTROL_RECEIVE_PAUSE)
1005d14abf15SRobert Mustacchi {
1006d14abf15SRobert Mustacchi pRxFlow = "ON";
1007d14abf15SRobert Mustacchi pUM->props.link_rxpause = B_TRUE;
1008d14abf15SRobert Mustacchi }
1009d14abf15SRobert Mustacchi else
1010d14abf15SRobert Mustacchi {
1011d14abf15SRobert Mustacchi pRxFlow = "OFF";
1012d14abf15SRobert Mustacchi pUM->props.link_rxpause = B_FALSE;
1013d14abf15SRobert Mustacchi }
1014d14abf15SRobert Mustacchi
1015d14abf15SRobert Mustacchi if (pUM->lm_dev.vars.flow_control & LM_FLOW_CONTROL_TRANSMIT_PAUSE)
1016d14abf15SRobert Mustacchi {
1017d14abf15SRobert Mustacchi pTxFlow = "ON";
1018d14abf15SRobert Mustacchi pUM->props.link_txpause = B_TRUE;
1019d14abf15SRobert Mustacchi }
1020d14abf15SRobert Mustacchi else
1021d14abf15SRobert Mustacchi {
1022d14abf15SRobert Mustacchi pTxFlow = "OFF";
1023d14abf15SRobert Mustacchi pUM->props.link_txpause = B_FALSE;
1024d14abf15SRobert Mustacchi }
1025d14abf15SRobert Mustacchi
1026d14abf15SRobert Mustacchi #if 0
1027d14abf15SRobert Mustacchi if (pUM->curcfg.lnkcfg.link_autoneg == B_TRUE)
1028d14abf15SRobert Mustacchi {
1029d14abf15SRobert Mustacchi BnxeUpdateLpCap(pUM);
1030d14abf15SRobert Mustacchi }
1031d14abf15SRobert Mustacchi #endif
1032d14abf15SRobert Mustacchi
1033d14abf15SRobert Mustacchi switch (GET_MEDIUM_SPEED(medium))
1034d14abf15SRobert Mustacchi {
1035d14abf15SRobert Mustacchi case LM_MEDIUM_SPEED_10MBPS:
1036d14abf15SRobert Mustacchi
1037d14abf15SRobert Mustacchi pUM->props.link_speed = 10;
1038d14abf15SRobert Mustacchi pSpeed = "10Mb";
1039d14abf15SRobert Mustacchi break;
1040d14abf15SRobert Mustacchi
1041d14abf15SRobert Mustacchi case LM_MEDIUM_SPEED_100MBPS:
1042d14abf15SRobert Mustacchi
1043d14abf15SRobert Mustacchi pUM->props.link_speed = 100;
1044d14abf15SRobert Mustacchi pSpeed = "100Mb";
1045d14abf15SRobert Mustacchi break;
1046d14abf15SRobert Mustacchi
1047d14abf15SRobert Mustacchi case LM_MEDIUM_SPEED_1000MBPS:
1048d14abf15SRobert Mustacchi
1049d14abf15SRobert Mustacchi pUM->props.link_speed = 1000;
1050d14abf15SRobert Mustacchi pSpeed = "1Gb";
1051d14abf15SRobert Mustacchi break;
1052d14abf15SRobert Mustacchi
1053d14abf15SRobert Mustacchi case LM_MEDIUM_SPEED_2500MBPS:
1054d14abf15SRobert Mustacchi
1055d14abf15SRobert Mustacchi pUM->props.link_speed = 2500;
1056d14abf15SRobert Mustacchi pSpeed = "2.5Gb";
1057d14abf15SRobert Mustacchi break;
1058d14abf15SRobert Mustacchi
1059d14abf15SRobert Mustacchi case LM_MEDIUM_SPEED_10GBPS:
1060d14abf15SRobert Mustacchi
1061d14abf15SRobert Mustacchi pUM->props.link_speed = 10000;
1062d14abf15SRobert Mustacchi pSpeed = "10Gb";
1063d14abf15SRobert Mustacchi break;
1064d14abf15SRobert Mustacchi
1065d14abf15SRobert Mustacchi case LM_MEDIUM_SPEED_12GBPS:
1066d14abf15SRobert Mustacchi
1067d14abf15SRobert Mustacchi pUM->props.link_speed = 12000;
1068d14abf15SRobert Mustacchi pSpeed = "12Gb";
1069d14abf15SRobert Mustacchi break;
1070d14abf15SRobert Mustacchi
1071d14abf15SRobert Mustacchi case LM_MEDIUM_SPEED_12_5GBPS:
1072d14abf15SRobert Mustacchi
1073d14abf15SRobert Mustacchi pUM->props.link_speed = 12500;
1074d14abf15SRobert Mustacchi pSpeed = "12.5Gb";
1075d14abf15SRobert Mustacchi break;
1076d14abf15SRobert Mustacchi
1077d14abf15SRobert Mustacchi case LM_MEDIUM_SPEED_13GBPS:
1078d14abf15SRobert Mustacchi
1079d14abf15SRobert Mustacchi pUM->props.link_speed = 13000;
1080d14abf15SRobert Mustacchi pSpeed = "13Gb";
1081d14abf15SRobert Mustacchi break;
1082d14abf15SRobert Mustacchi
1083d14abf15SRobert Mustacchi case LM_MEDIUM_SPEED_15GBPS:
1084d14abf15SRobert Mustacchi
1085d14abf15SRobert Mustacchi pUM->props.link_speed = 15000;
1086d14abf15SRobert Mustacchi pSpeed = "15Gb";
1087d14abf15SRobert Mustacchi break;
1088d14abf15SRobert Mustacchi
1089d14abf15SRobert Mustacchi case LM_MEDIUM_SPEED_16GBPS:
1090d14abf15SRobert Mustacchi
1091d14abf15SRobert Mustacchi pUM->props.link_speed = 16000;
1092d14abf15SRobert Mustacchi pSpeed = "16Gb";
1093d14abf15SRobert Mustacchi break;
1094d14abf15SRobert Mustacchi
1095d14abf15SRobert Mustacchi case LM_MEDIUM_SPEED_20GBPS:
1096d14abf15SRobert Mustacchi
1097d14abf15SRobert Mustacchi pUM->props.link_speed = 20000;
1098d14abf15SRobert Mustacchi pSpeed = "20Gb";
1099d14abf15SRobert Mustacchi break;
1100d14abf15SRobert Mustacchi
1101d14abf15SRobert Mustacchi default:
1102d14abf15SRobert Mustacchi
1103d14abf15SRobert Mustacchi if ((GET_MEDIUM_SPEED(medium) >= LM_MEDIUM_SPEED_SEQ_START) &&
1104d14abf15SRobert Mustacchi (GET_MEDIUM_SPEED(medium) <= LM_MEDIUM_SPEED_SEQ_END))
1105d14abf15SRobert Mustacchi {
1106d14abf15SRobert Mustacchi pUM->props.link_speed = (((GET_MEDIUM_SPEED(medium) >> 8) -
1107d14abf15SRobert Mustacchi (LM_MEDIUM_SPEED_SEQ_START >> 8) +
1108d14abf15SRobert Mustacchi 1) * 100);
1109d14abf15SRobert Mustacchi snprintf(tbuf, TBUF_SIZE, "%u", pUM->props.link_speed);
1110d14abf15SRobert Mustacchi pSpeed = tbuf;
1111d14abf15SRobert Mustacchi break;
1112d14abf15SRobert Mustacchi }
1113d14abf15SRobert Mustacchi
1114d14abf15SRobert Mustacchi pUM->props.link_speed = 0;
1115d14abf15SRobert Mustacchi pSpeed = "";
1116d14abf15SRobert Mustacchi
1117d14abf15SRobert Mustacchi break;
1118d14abf15SRobert Mustacchi }
1119d14abf15SRobert Mustacchi
1120d14abf15SRobert Mustacchi if (*pSpeed == 0)
1121d14abf15SRobert Mustacchi {
1122d14abf15SRobert Mustacchi BnxeLogInfo(pUM, "%s Duplex Rx Flow %s Tx Flow %s Link Up",
1123d14abf15SRobert Mustacchi pDuplex, pRxFlow, pTxFlow);
1124d14abf15SRobert Mustacchi }
1125d14abf15SRobert Mustacchi else
1126d14abf15SRobert Mustacchi {
1127d14abf15SRobert Mustacchi BnxeLogInfo(pUM, "%s %s Duplex Rx Flow %s Tx Flow %s Link Up",
1128d14abf15SRobert Mustacchi pSpeed, pDuplex, pRxFlow, pTxFlow);
1129d14abf15SRobert Mustacchi }
1130d14abf15SRobert Mustacchi }
1131d14abf15SRobert Mustacchi
1132d14abf15SRobert Mustacchi
mm_indicate_link(lm_device_t * pLM,lm_status_t link,lm_medium_t medium)1133d14abf15SRobert Mustacchi void mm_indicate_link(lm_device_t * pLM,
1134d14abf15SRobert Mustacchi lm_status_t link,
1135d14abf15SRobert Mustacchi lm_medium_t medium)
1136d14abf15SRobert Mustacchi {
1137d14abf15SRobert Mustacchi um_device_t * pUM = (um_device_t *)pLM;
1138d14abf15SRobert Mustacchi
1139d14abf15SRobert Mustacchi /* ignore link status if it has not changed since the last indicate */
1140d14abf15SRobert Mustacchi if ((pUM->devParams.lastIndLink == link) &&
1141d14abf15SRobert Mustacchi (pUM->devParams.lastIndMedium == medium))
1142d14abf15SRobert Mustacchi {
1143d14abf15SRobert Mustacchi return;
1144d14abf15SRobert Mustacchi }
1145d14abf15SRobert Mustacchi
1146d14abf15SRobert Mustacchi pUM->devParams.lastIndLink = link;
1147d14abf15SRobert Mustacchi pUM->devParams.lastIndMedium = medium;
1148d14abf15SRobert Mustacchi
1149d14abf15SRobert Mustacchi BnxeLinkStatus(pUM, link, medium);
1150d14abf15SRobert Mustacchi
1151d14abf15SRobert Mustacchi if (CLIENT_BOUND(pUM, LM_CLI_IDX_NDIS))
1152d14abf15SRobert Mustacchi {
1153d14abf15SRobert Mustacchi BnxeGldLink(pUM, (link == LM_STATUS_LINK_ACTIVE) ?
1154d14abf15SRobert Mustacchi LINK_STATE_UP : LINK_STATE_DOWN);
1155d14abf15SRobert Mustacchi }
1156d14abf15SRobert Mustacchi
1157d14abf15SRobert Mustacchi if (CLIENT_BOUND(pUM, LM_CLI_IDX_FCOE))
1158d14abf15SRobert Mustacchi {
1159d14abf15SRobert Mustacchi if (pUM->fcoe.pDev == NULL)
1160d14abf15SRobert Mustacchi {
1161d14abf15SRobert Mustacchi BnxeLogWarn(pUM, "FCoE Client bound and pDev is NULL (LINK STATUS failed!) %s@%s",
1162d14abf15SRobert Mustacchi BNXEF_NAME, ddi_get_name_addr(pUM->pDev));
1163d14abf15SRobert Mustacchi }
1164d14abf15SRobert Mustacchi else if (pUM->fcoe.bind.cliCtl == NULL)
1165d14abf15SRobert Mustacchi {
1166d14abf15SRobert Mustacchi BnxeLogWarn(pUM, "FCoE Client bound and cliCtl is NULL (LINK STATUS failed!) %s@%s",
1167d14abf15SRobert Mustacchi BNXEF_NAME, ddi_get_name_addr(pUM->pDev));
1168d14abf15SRobert Mustacchi }
1169d14abf15SRobert Mustacchi else
1170d14abf15SRobert Mustacchi {
1171d14abf15SRobert Mustacchi pUM->fcoe.bind.cliCtl(pUM->fcoe.pDev,
1172d14abf15SRobert Mustacchi (link == LM_STATUS_LINK_ACTIVE) ?
1173d14abf15SRobert Mustacchi CLI_CTL_LINK_UP : CLI_CTL_LINK_DOWN,
1174d14abf15SRobert Mustacchi NULL,
1175d14abf15SRobert Mustacchi 0);
1176d14abf15SRobert Mustacchi }
1177d14abf15SRobert Mustacchi }
1178d14abf15SRobert Mustacchi }
1179d14abf15SRobert Mustacchi
1180d14abf15SRobert Mustacchi
mm_schedule_task(lm_device_t * pDev,u32_t delay_ms,lm_task_cb_t task,void * param)1181d14abf15SRobert Mustacchi lm_status_t mm_schedule_task(lm_device_t * pDev,
1182d14abf15SRobert Mustacchi u32_t delay_ms,
1183d14abf15SRobert Mustacchi lm_task_cb_t task,
1184d14abf15SRobert Mustacchi void * param)
1185d14abf15SRobert Mustacchi {
1186d14abf15SRobert Mustacchi um_device_t * pUM = (um_device_t *)pDev;
1187d14abf15SRobert Mustacchi
1188d14abf15SRobert Mustacchi BnxeWorkQueueAddDelayNoCopy(pUM, (void (*)(um_device_t *, void *))task, param, delay_ms);
1189d14abf15SRobert Mustacchi
1190d14abf15SRobert Mustacchi return LM_STATUS_SUCCESS;
1191d14abf15SRobert Mustacchi }
1192d14abf15SRobert Mustacchi
1193d14abf15SRobert Mustacchi
mm_register_lpme(lm_device_t * pDev,lm_generic_workitem_function * func,u8_t b_fw_access,u8_t b_queue_for_fw)1194d14abf15SRobert Mustacchi lm_status_t mm_register_lpme(lm_device_t * pDev,
1195d14abf15SRobert Mustacchi lm_generic_workitem_function * func,
1196d14abf15SRobert Mustacchi u8_t b_fw_access,
1197d14abf15SRobert Mustacchi u8_t b_queue_for_fw)
1198d14abf15SRobert Mustacchi {
1199d14abf15SRobert Mustacchi um_device_t * pUM = (um_device_t *)pDev;
1200d14abf15SRobert Mustacchi
1201d14abf15SRobert Mustacchi (void)b_fw_access;
1202d14abf15SRobert Mustacchi (void)b_queue_for_fw;
1203d14abf15SRobert Mustacchi
1204d14abf15SRobert Mustacchi BnxeWorkQueueAddGeneric(pUM, (void (*)(um_device_t *))func);
1205d14abf15SRobert Mustacchi
1206d14abf15SRobert Mustacchi return LM_STATUS_SUCCESS;
1207d14abf15SRobert Mustacchi }
1208d14abf15SRobert Mustacchi
1209d14abf15SRobert Mustacchi
MM_ACQUIRE_SPQ_LOCK_IMP(lm_device_t * pDev)1210d14abf15SRobert Mustacchi void MM_ACQUIRE_SPQ_LOCK_IMP(lm_device_t * pDev)
1211d14abf15SRobert Mustacchi {
1212d14abf15SRobert Mustacchi BNXE_LOCK_ENTER_SPQ((um_device_t *)pDev);
1213d14abf15SRobert Mustacchi }
1214d14abf15SRobert Mustacchi
1215d14abf15SRobert Mustacchi
MM_RELEASE_SPQ_LOCK_IMP(lm_device_t * pDev)1216d14abf15SRobert Mustacchi void MM_RELEASE_SPQ_LOCK_IMP(lm_device_t * pDev)
1217d14abf15SRobert Mustacchi {
1218d14abf15SRobert Mustacchi BNXE_LOCK_EXIT_SPQ((um_device_t *)pDev);
1219d14abf15SRobert Mustacchi }
1220d14abf15SRobert Mustacchi
1221d14abf15SRobert Mustacchi
MM_ACQUIRE_SPQ_LOCK_DPC_IMP(lm_device_t * pDev)1222d14abf15SRobert Mustacchi void MM_ACQUIRE_SPQ_LOCK_DPC_IMP(lm_device_t * pDev)
1223d14abf15SRobert Mustacchi {
1224d14abf15SRobert Mustacchi BNXE_LOCK_ENTER_SPQ((um_device_t *)pDev);
1225d14abf15SRobert Mustacchi }
1226d14abf15SRobert Mustacchi
1227d14abf15SRobert Mustacchi
MM_RELEASE_SPQ_LOCK_DPC_IMP(lm_device_t * pDev)1228d14abf15SRobert Mustacchi void MM_RELEASE_SPQ_LOCK_DPC_IMP(lm_device_t * pDev)
1229d14abf15SRobert Mustacchi {
1230d14abf15SRobert Mustacchi BNXE_LOCK_EXIT_SPQ((um_device_t *)pDev);
1231d14abf15SRobert Mustacchi }
1232d14abf15SRobert Mustacchi
1233d14abf15SRobert Mustacchi
MM_ACQUIRE_CID_LOCK_IMP(lm_device_t * pDev)1234d14abf15SRobert Mustacchi void MM_ACQUIRE_CID_LOCK_IMP(lm_device_t * pDev)
1235d14abf15SRobert Mustacchi {
1236d14abf15SRobert Mustacchi BNXE_LOCK_ENTER_CID((um_device_t *)pDev);
1237d14abf15SRobert Mustacchi }
1238d14abf15SRobert Mustacchi
1239d14abf15SRobert Mustacchi
MM_RELEASE_CID_LOCK_IMP(lm_device_t * pDev)1240d14abf15SRobert Mustacchi void MM_RELEASE_CID_LOCK_IMP(lm_device_t * pDev)
1241d14abf15SRobert Mustacchi {
1242d14abf15SRobert Mustacchi BNXE_LOCK_EXIT_CID((um_device_t *)pDev);
1243d14abf15SRobert Mustacchi }
1244d14abf15SRobert Mustacchi
1245d14abf15SRobert Mustacchi
MM_ACQUIRE_REQUEST_LOCK_IMP(lm_device_t * pDev)1246d14abf15SRobert Mustacchi void MM_ACQUIRE_REQUEST_LOCK_IMP(lm_device_t * pDev)
1247d14abf15SRobert Mustacchi {
1248d14abf15SRobert Mustacchi BNXE_LOCK_ENTER_RRREQ((um_device_t *)pDev);
1249d14abf15SRobert Mustacchi }
1250d14abf15SRobert Mustacchi
1251d14abf15SRobert Mustacchi
MM_RELEASE_REQUEST_LOCK_IMP(lm_device_t * pDev)1252d14abf15SRobert Mustacchi void MM_RELEASE_REQUEST_LOCK_IMP(lm_device_t * pDev)
1253d14abf15SRobert Mustacchi {
1254d14abf15SRobert Mustacchi BNXE_LOCK_EXIT_RRREQ((um_device_t *)pDev);
1255d14abf15SRobert Mustacchi }
1256d14abf15SRobert Mustacchi
1257d14abf15SRobert Mustacchi
MM_ACQUIRE_PHY_LOCK_IMP(lm_device_t * pDev)1258d14abf15SRobert Mustacchi void MM_ACQUIRE_PHY_LOCK_IMP(lm_device_t * pDev)
1259d14abf15SRobert Mustacchi {
1260d14abf15SRobert Mustacchi BNXE_LOCK_ENTER_PHY((um_device_t *)pDev);
1261d14abf15SRobert Mustacchi }
1262d14abf15SRobert Mustacchi
1263d14abf15SRobert Mustacchi
MM_RELEASE_PHY_LOCK_IMP(lm_device_t * pDev)1264d14abf15SRobert Mustacchi void MM_RELEASE_PHY_LOCK_IMP(lm_device_t * pDev)
1265d14abf15SRobert Mustacchi {
1266d14abf15SRobert Mustacchi BNXE_LOCK_EXIT_PHY((um_device_t *)pDev);
1267d14abf15SRobert Mustacchi }
1268d14abf15SRobert Mustacchi
1269d14abf15SRobert Mustacchi
MM_ACQUIRE_PHY_LOCK_DPC_IMP(lm_device_t * pDev)1270d14abf15SRobert Mustacchi void MM_ACQUIRE_PHY_LOCK_DPC_IMP(lm_device_t * pDev)
1271d14abf15SRobert Mustacchi {
1272d14abf15SRobert Mustacchi BNXE_LOCK_ENTER_PHY((um_device_t *)pDev);
1273d14abf15SRobert Mustacchi }
1274d14abf15SRobert Mustacchi
1275d14abf15SRobert Mustacchi
MM_RELEASE_PHY_LOCK_DPC_IMP(lm_device_t * pDev)1276d14abf15SRobert Mustacchi void MM_RELEASE_PHY_LOCK_DPC_IMP(lm_device_t * pDev)
1277d14abf15SRobert Mustacchi {
1278d14abf15SRobert Mustacchi BNXE_LOCK_EXIT_PHY((um_device_t *)pDev);
1279d14abf15SRobert Mustacchi }
1280d14abf15SRobert Mustacchi
1281d14abf15SRobert Mustacchi
mm_init_lock(lm_device_t * pDev,mm_spin_lock_t * spinlock)1282d14abf15SRobert Mustacchi void mm_init_lock(lm_device_t * pDev,
1283d14abf15SRobert Mustacchi mm_spin_lock_t * spinlock)
1284d14abf15SRobert Mustacchi {
1285d14abf15SRobert Mustacchi um_device_t * pUM = (um_device_t *)pDev;
1286d14abf15SRobert Mustacchi
1287d14abf15SRobert Mustacchi mutex_init(spinlock, NULL,
1288d14abf15SRobert Mustacchi MUTEX_DRIVER, DDI_INTR_PRI(pUM->intrPriority));
1289d14abf15SRobert Mustacchi }
1290d14abf15SRobert Mustacchi
1291d14abf15SRobert Mustacchi
mm_acquire_lock(mm_spin_lock_t * spinlock)1292d14abf15SRobert Mustacchi lm_status_t mm_acquire_lock(mm_spin_lock_t * spinlock)
1293d14abf15SRobert Mustacchi {
1294d14abf15SRobert Mustacchi if (spinlock == NULL)
1295d14abf15SRobert Mustacchi {
1296d14abf15SRobert Mustacchi return LM_STATUS_INVALID_PARAMETER;
1297d14abf15SRobert Mustacchi }
1298d14abf15SRobert Mustacchi
1299d14abf15SRobert Mustacchi mutex_enter(spinlock);
1300d14abf15SRobert Mustacchi
1301d14abf15SRobert Mustacchi return LM_STATUS_SUCCESS;
1302d14abf15SRobert Mustacchi }
1303d14abf15SRobert Mustacchi
1304d14abf15SRobert Mustacchi
mm_release_lock(mm_spin_lock_t * spinlock)1305d14abf15SRobert Mustacchi lm_status_t mm_release_lock(mm_spin_lock_t * spinlock)
1306d14abf15SRobert Mustacchi {
1307d14abf15SRobert Mustacchi if (spinlock == NULL)
1308d14abf15SRobert Mustacchi {
1309d14abf15SRobert Mustacchi return LM_STATUS_INVALID_PARAMETER;
1310d14abf15SRobert Mustacchi }
1311d14abf15SRobert Mustacchi
1312d14abf15SRobert Mustacchi mutex_exit(spinlock);
1313d14abf15SRobert Mustacchi
1314d14abf15SRobert Mustacchi return LM_STATUS_SUCCESS;
1315d14abf15SRobert Mustacchi }
1316d14abf15SRobert Mustacchi
1317d14abf15SRobert Mustacchi
MM_ACQUIRE_MCP_LOCK_IMP(lm_device_t * pDev)1318d14abf15SRobert Mustacchi void MM_ACQUIRE_MCP_LOCK_IMP(lm_device_t * pDev)
1319d14abf15SRobert Mustacchi {
1320d14abf15SRobert Mustacchi BNXE_LOCK_ENTER_MCP((um_device_t *)pDev);
1321d14abf15SRobert Mustacchi }
1322d14abf15SRobert Mustacchi
1323d14abf15SRobert Mustacchi
MM_RELEASE_MCP_LOCK_IMP(lm_device_t * pDev)1324d14abf15SRobert Mustacchi void MM_RELEASE_MCP_LOCK_IMP(lm_device_t * pDev)
1325d14abf15SRobert Mustacchi {
1326d14abf15SRobert Mustacchi BNXE_LOCK_EXIT_MCP((um_device_t *)pDev);
1327d14abf15SRobert Mustacchi }
1328d14abf15SRobert Mustacchi
1329d14abf15SRobert Mustacchi
MM_ACQUIRE_ISLES_CONTROL_LOCK_IMP(lm_device_t * pDev)1330d14abf15SRobert Mustacchi void MM_ACQUIRE_ISLES_CONTROL_LOCK_IMP(lm_device_t * pDev)
1331d14abf15SRobert Mustacchi {
1332d14abf15SRobert Mustacchi BNXE_LOCK_ENTER_ISLES_CONTROL((um_device_t *)pDev);
1333d14abf15SRobert Mustacchi }
1334d14abf15SRobert Mustacchi
1335d14abf15SRobert Mustacchi
MM_RELEASE_ISLES_CONTROL_LOCK_IMP(lm_device_t * pDev)1336d14abf15SRobert Mustacchi void MM_RELEASE_ISLES_CONTROL_LOCK_IMP(lm_device_t * pDev)
1337d14abf15SRobert Mustacchi {
1338d14abf15SRobert Mustacchi BNXE_LOCK_EXIT_ISLES_CONTROL((um_device_t *)pDev);
1339d14abf15SRobert Mustacchi }
1340d14abf15SRobert Mustacchi
1341d14abf15SRobert Mustacchi
MM_ACQUIRE_ISLES_CONTROL_LOCK_DPC_IMP(lm_device_t * pDev)1342d14abf15SRobert Mustacchi void MM_ACQUIRE_ISLES_CONTROL_LOCK_DPC_IMP(lm_device_t * pDev)
1343d14abf15SRobert Mustacchi {
1344d14abf15SRobert Mustacchi BNXE_LOCK_ENTER_ISLES_CONTROL((um_device_t *)pDev);
1345d14abf15SRobert Mustacchi }
1346d14abf15SRobert Mustacchi
1347d14abf15SRobert Mustacchi
MM_RELEASE_ISLES_CONTROL_LOCK_DPC_IMP(lm_device_t * pDev)1348d14abf15SRobert Mustacchi void MM_RELEASE_ISLES_CONTROL_LOCK_DPC_IMP(lm_device_t * pDev)
1349d14abf15SRobert Mustacchi {
1350d14abf15SRobert Mustacchi BNXE_LOCK_EXIT_ISLES_CONTROL((um_device_t *)pDev);
1351d14abf15SRobert Mustacchi }
1352d14abf15SRobert Mustacchi
1353d14abf15SRobert Mustacchi
MM_ACQUIRE_IND_REG_LOCK_IMP(lm_device_t * pDev)1354d14abf15SRobert Mustacchi void MM_ACQUIRE_IND_REG_LOCK_IMP(lm_device_t * pDev)
1355d14abf15SRobert Mustacchi {
1356d14abf15SRobert Mustacchi BNXE_LOCK_ENTER_IND((um_device_t *)pDev);
1357d14abf15SRobert Mustacchi }
1358d14abf15SRobert Mustacchi
1359d14abf15SRobert Mustacchi
MM_RELEASE_IND_REG_LOCK_IMP(lm_device_t * pDev)1360d14abf15SRobert Mustacchi void MM_RELEASE_IND_REG_LOCK_IMP(lm_device_t * pDev)
1361d14abf15SRobert Mustacchi {
1362d14abf15SRobert Mustacchi BNXE_LOCK_EXIT_IND((um_device_t *)pDev);
1363d14abf15SRobert Mustacchi }
1364d14abf15SRobert Mustacchi
1365d14abf15SRobert Mustacchi
MM_ACQUIRE_LOADER_LOCK_IMP()1366d14abf15SRobert Mustacchi void MM_ACQUIRE_LOADER_LOCK_IMP()
1367d14abf15SRobert Mustacchi {
1368d14abf15SRobert Mustacchi mutex_enter(&bnxeLoaderMutex);
1369d14abf15SRobert Mustacchi }
1370d14abf15SRobert Mustacchi
1371d14abf15SRobert Mustacchi
MM_RELEASE_LOADER_LOCK_IMP()1372d14abf15SRobert Mustacchi void MM_RELEASE_LOADER_LOCK_IMP()
1373d14abf15SRobert Mustacchi {
1374d14abf15SRobert Mustacchi mutex_exit(&bnxeLoaderMutex);
1375d14abf15SRobert Mustacchi }
1376d14abf15SRobert Mustacchi
1377d14abf15SRobert Mustacchi
MM_ACQUIRE_SP_REQ_MGR_LOCK_IMP(lm_device_t * pDev)1378d14abf15SRobert Mustacchi void MM_ACQUIRE_SP_REQ_MGR_LOCK_IMP(lm_device_t * pDev)
1379d14abf15SRobert Mustacchi {
1380d14abf15SRobert Mustacchi BNXE_LOCK_ENTER_SPREQ((um_device_t *)pDev);
1381d14abf15SRobert Mustacchi }
1382d14abf15SRobert Mustacchi
1383d14abf15SRobert Mustacchi
MM_RELEASE_SP_REQ_MGR_LOCK_IMP(lm_device_t * pDev)1384d14abf15SRobert Mustacchi void MM_RELEASE_SP_REQ_MGR_LOCK_IMP(lm_device_t * pDev)
1385d14abf15SRobert Mustacchi {
1386d14abf15SRobert Mustacchi BNXE_LOCK_EXIT_SPREQ((um_device_t *)pDev);
1387d14abf15SRobert Mustacchi }
1388d14abf15SRobert Mustacchi
1389d14abf15SRobert Mustacchi
MM_ACQUIRE_SB_LOCK_IMP(lm_device_t * pDev,u8_t sb_idx)1390d14abf15SRobert Mustacchi void MM_ACQUIRE_SB_LOCK_IMP(lm_device_t * pDev, u8_t sb_idx)
1391d14abf15SRobert Mustacchi {
1392d14abf15SRobert Mustacchi BNXE_LOCK_ENTER_SB((um_device_t *)pDev, sb_idx);
1393d14abf15SRobert Mustacchi }
1394d14abf15SRobert Mustacchi
1395d14abf15SRobert Mustacchi
MM_RELEASE_SB_LOCK_IMP(lm_device_t * pDev,u8_t sb_idx)1396d14abf15SRobert Mustacchi void MM_RELEASE_SB_LOCK_IMP(lm_device_t * pDev, u8_t sb_idx)
1397d14abf15SRobert Mustacchi {
1398d14abf15SRobert Mustacchi BNXE_LOCK_EXIT_SB((um_device_t *)pDev, sb_idx);
1399d14abf15SRobert Mustacchi }
1400d14abf15SRobert Mustacchi
1401d14abf15SRobert Mustacchi
MM_ACQUIRE_ETH_CON_LOCK_IMP(lm_device_t * pDev)1402d14abf15SRobert Mustacchi void MM_ACQUIRE_ETH_CON_LOCK_IMP(lm_device_t * pDev)
1403d14abf15SRobert Mustacchi {
1404d14abf15SRobert Mustacchi BNXE_LOCK_ENTER_ETH_CON((um_device_t *)pDev);
1405d14abf15SRobert Mustacchi }
1406d14abf15SRobert Mustacchi
1407d14abf15SRobert Mustacchi
MM_RELEASE_ETH_CON_LOCK_IMP(lm_device_t * pDev)1408d14abf15SRobert Mustacchi void MM_RELEASE_ETH_CON_LOCK_IMP(lm_device_t * pDev)
1409d14abf15SRobert Mustacchi {
1410d14abf15SRobert Mustacchi BNXE_LOCK_EXIT_ETH_CON((um_device_t *)pDev);
1411d14abf15SRobert Mustacchi }
1412d14abf15SRobert Mustacchi
1413d14abf15SRobert Mustacchi
mm_crc32(unsigned char * address,unsigned int size,unsigned int crc)1414d14abf15SRobert Mustacchi unsigned int mm_crc32(unsigned char * address,
1415d14abf15SRobert Mustacchi unsigned int size,
1416d14abf15SRobert Mustacchi unsigned int crc)
1417d14abf15SRobert Mustacchi {
1418d14abf15SRobert Mustacchi return 0;
1419d14abf15SRobert Mustacchi }
1420d14abf15SRobert Mustacchi
1421d14abf15SRobert Mustacchi
mm_crc16(unsigned char * address,unsigned int size,unsigned short crc)1422d14abf15SRobert Mustacchi unsigned short mm_crc16(unsigned char * address,
1423d14abf15SRobert Mustacchi unsigned int size,
1424d14abf15SRobert Mustacchi unsigned short crc)
1425d14abf15SRobert Mustacchi {
1426d14abf15SRobert Mustacchi return 0;
1427d14abf15SRobert Mustacchi }
1428d14abf15SRobert Mustacchi
1429d14abf15SRobert Mustacchi
mm_event_log_generic_arg_fwd(lm_device_t * pDev,const lm_log_id_t lm_log_id,va_list argp)1430d14abf15SRobert Mustacchi lm_status_t mm_event_log_generic_arg_fwd(lm_device_t * pDev,
1431d14abf15SRobert Mustacchi const lm_log_id_t lm_log_id,
1432d14abf15SRobert Mustacchi va_list argp)
1433d14abf15SRobert Mustacchi {
1434d14abf15SRobert Mustacchi um_device_t * pUM = (um_device_t *)pDev;
1435d14abf15SRobert Mustacchi u8_t port = 0 ;
1436d14abf15SRobert Mustacchi char * sz_vendor_name = NULL;
1437d14abf15SRobert Mustacchi char * sz_vendor_pn = NULL;
1438d14abf15SRobert Mustacchi
1439d14abf15SRobert Mustacchi switch (lm_log_id)
1440d14abf15SRobert Mustacchi {
1441d14abf15SRobert Mustacchi case LM_LOG_ID_FAN_FAILURE: // fan failure detected
1442d14abf15SRobert Mustacchi
1443d14abf15SRobert Mustacchi BnxeLogWarn(pUM, "FAN FAILURE!");
1444d14abf15SRobert Mustacchi break;
1445d14abf15SRobert Mustacchi
1446d14abf15SRobert Mustacchi case LM_LOG_ID_UNQUAL_IO_MODULE: // SFP+ unqualified io module
1447d14abf15SRobert Mustacchi /*
1448d14abf15SRobert Mustacchi * expected parameters:
1449d14abf15SRobert Mustacchi * u8 port, const char * vendor_name, const char * vendor_pn
1450d14abf15SRobert Mustacchi */
1451d14abf15SRobert Mustacchi port = va_arg(argp, int);
1452d14abf15SRobert Mustacchi sz_vendor_name = va_arg(argp, char*);
1453d14abf15SRobert Mustacchi sz_vendor_pn = va_arg(argp, char*);
1454d14abf15SRobert Mustacchi
1455d14abf15SRobert Mustacchi BnxeLogInfo(pUM, "Unqualified IO Module: %s %s (port=%d)",
1456d14abf15SRobert Mustacchi sz_vendor_name, sz_vendor_pn, port);
1457d14abf15SRobert Mustacchi break;
1458d14abf15SRobert Mustacchi
1459d14abf15SRobert Mustacchi case LM_LOG_ID_OVER_CURRENT: // SFP+ over current power
1460d14abf15SRobert Mustacchi /*
1461d14abf15SRobert Mustacchi * expected parametrs:
1462d14abf15SRobert Mustacchi * u8 port
1463*55fea89dSDan Cross */
1464d14abf15SRobert Mustacchi port = va_arg(argp, int);
1465d14abf15SRobert Mustacchi
1466d14abf15SRobert Mustacchi BnxeLogWarn(pUM, "SFP+ over current, power failure! (port=%d)", port);
1467d14abf15SRobert Mustacchi break;
1468d14abf15SRobert Mustacchi
1469d14abf15SRobert Mustacchi case LM_LOG_ID_NO_10G_SUPPORT: // 10g speed is requested but not supported
1470d14abf15SRobert Mustacchi /*
1471d14abf15SRobert Mustacchi * expected parametrs:
1472d14abf15SRobert Mustacchi * u8 port
1473d14abf15SRobert Mustacchi */
1474d14abf15SRobert Mustacchi port = va_arg(argp, int);
1475d14abf15SRobert Mustacchi
1476d14abf15SRobert Mustacchi BnxeLogWarn(pUM, "10Gb speed not supported! (port=%d)", port);
1477d14abf15SRobert Mustacchi break;
1478d14abf15SRobert Mustacchi
1479d14abf15SRobert Mustacchi case LM_LOG_ID_PHY_UNINITIALIZED:
1480d14abf15SRobert Mustacchi /*
1481d14abf15SRobert Mustacchi * expected parametrs:
1482d14abf15SRobert Mustacchi * u8 port
1483d14abf15SRobert Mustacchi */
1484d14abf15SRobert Mustacchi port = va_arg(argp, int);
1485d14abf15SRobert Mustacchi
1486d14abf15SRobert Mustacchi BnxeLogWarn(pUM, "PHY uninitialized! (port=%d)", port);
1487d14abf15SRobert Mustacchi break;
1488d14abf15SRobert Mustacchi
1489d14abf15SRobert Mustacchi case LM_LOG_ID_MDIO_ACCESS_TIMEOUT:
1490d14abf15SRobert Mustacchi
1491d14abf15SRobert Mustacchi #define MM_PORT_NUM(pdev) \
1492d14abf15SRobert Mustacchi (CHIP_PORT_MODE(pdev) == LM_CHIP_PORT_MODE_4) ? \
1493d14abf15SRobert Mustacchi (PATH_ID(pdev) + (2 * PORT_ID(pdev))) : \
1494d14abf15SRobert Mustacchi (PATH_ID(pdev) + PORT_ID(pdev))
1495d14abf15SRobert Mustacchi
1496d14abf15SRobert Mustacchi port = MM_PORT_NUM(&pUM->lm_dev);
1497d14abf15SRobert Mustacchi
1498d14abf15SRobert Mustacchi BnxeLogWarn(pUM, "MDIO access timeout! (port=%d)", port);
1499d14abf15SRobert Mustacchi break;
1500d14abf15SRobert Mustacchi
1501d14abf15SRobert Mustacchi default:
1502d14abf15SRobert Mustacchi
1503d14abf15SRobert Mustacchi BnxeLogWarn(pUM, "Unknown MM event log! (type=%d)", lm_log_id);
1504d14abf15SRobert Mustacchi break;
1505d14abf15SRobert Mustacchi }
1506d14abf15SRobert Mustacchi
1507d14abf15SRobert Mustacchi return LM_STATUS_SUCCESS;
1508d14abf15SRobert Mustacchi }
1509d14abf15SRobert Mustacchi
1510d14abf15SRobert Mustacchi
mm_event_log_generic(lm_device_t * pDev,const lm_log_id_t lm_log_id,...)1511d14abf15SRobert Mustacchi lm_status_t mm_event_log_generic(lm_device_t * pDev,
1512d14abf15SRobert Mustacchi const lm_log_id_t lm_log_id,
1513d14abf15SRobert Mustacchi ...)
1514d14abf15SRobert Mustacchi {
1515d14abf15SRobert Mustacchi lm_status_t lm_status = LM_STATUS_SUCCESS;
1516d14abf15SRobert Mustacchi va_list argp;
1517d14abf15SRobert Mustacchi
1518d14abf15SRobert Mustacchi va_start(argp, lm_log_id);
1519d14abf15SRobert Mustacchi lm_status = mm_event_log_generic_arg_fwd(pDev, lm_log_id, argp);
1520d14abf15SRobert Mustacchi va_end(argp);
1521d14abf15SRobert Mustacchi
1522d14abf15SRobert Mustacchi return lm_status;
1523d14abf15SRobert Mustacchi }
1524d14abf15SRobert Mustacchi
1525d14abf15SRobert Mustacchi
mm_build_ver_string(lm_device_t * pDev)1526d14abf15SRobert Mustacchi u32_t mm_build_ver_string(lm_device_t * pDev)
1527d14abf15SRobert Mustacchi {
1528d14abf15SRobert Mustacchi um_device_t * pUM = (um_device_t *)pDev;
1529d14abf15SRobert Mustacchi
1530d14abf15SRobert Mustacchi snprintf((char *)pDev->ver_str,
1531d14abf15SRobert Mustacchi sizeof(pDev->ver_str),
1532d14abf15SRobert Mustacchi "%s",
1533d14abf15SRobert Mustacchi pUM->version);
1534d14abf15SRobert Mustacchi
1535d14abf15SRobert Mustacchi return min(strlen((char *)pDev->ver_str), strlen(pUM->version));
1536d14abf15SRobert Mustacchi }
1537d14abf15SRobert Mustacchi
1538d14abf15SRobert Mustacchi
mm_indicate_hw_failure(lm_device_t * pDev)1539d14abf15SRobert Mustacchi void mm_indicate_hw_failure(lm_device_t * pDev)
1540d14abf15SRobert Mustacchi {
1541d14abf15SRobert Mustacchi um_device_t * pUM = (um_device_t *)pDev;
1542d14abf15SRobert Mustacchi
1543d14abf15SRobert Mustacchi BnxeLogWarn(pUM, "HW failure indicated!");
1544d14abf15SRobert Mustacchi }
1545d14abf15SRobert Mustacchi
1546d14abf15SRobert Mustacchi
mm_bar_read_byte(struct _lm_device_t * pdev,u8_t bar,u32_t offset,u8_t * ret)1547d14abf15SRobert Mustacchi void mm_bar_read_byte(struct _lm_device_t *pdev,
1548d14abf15SRobert Mustacchi u8_t bar,
1549d14abf15SRobert Mustacchi u32_t offset,
1550d14abf15SRobert Mustacchi u8_t *ret)
1551d14abf15SRobert Mustacchi {
1552d14abf15SRobert Mustacchi mm_read_barrier();
1553d14abf15SRobert Mustacchi *ret = ddi_get8(pdev->vars.reg_handle[bar],
1554d14abf15SRobert Mustacchi (uint8_t *)((caddr_t)pdev->vars.mapped_bar_addr[bar] +
1555d14abf15SRobert Mustacchi offset));
1556d14abf15SRobert Mustacchi }
1557d14abf15SRobert Mustacchi
1558d14abf15SRobert Mustacchi
mm_bar_read_word(struct _lm_device_t * pdev,u8_t bar,u32_t offset,u16_t * ret)1559d14abf15SRobert Mustacchi void mm_bar_read_word(struct _lm_device_t *pdev,
1560d14abf15SRobert Mustacchi u8_t bar,
1561d14abf15SRobert Mustacchi u32_t offset,
1562d14abf15SRobert Mustacchi u16_t *ret)
1563d14abf15SRobert Mustacchi {
1564d14abf15SRobert Mustacchi mm_read_barrier();
1565d14abf15SRobert Mustacchi *ret = ddi_get16(pdev->vars.reg_handle[bar],
1566d14abf15SRobert Mustacchi (uint16_t *)((caddr_t)pdev->vars.mapped_bar_addr[bar] +
1567d14abf15SRobert Mustacchi offset));
1568d14abf15SRobert Mustacchi }
1569d14abf15SRobert Mustacchi
1570d14abf15SRobert Mustacchi
mm_bar_read_dword(struct _lm_device_t * pdev,u8_t bar,u32_t offset,u32_t * ret)1571d14abf15SRobert Mustacchi void mm_bar_read_dword(struct _lm_device_t *pdev,
1572d14abf15SRobert Mustacchi u8_t bar,
1573d14abf15SRobert Mustacchi u32_t offset,
1574d14abf15SRobert Mustacchi u32_t *ret)
1575d14abf15SRobert Mustacchi {
1576d14abf15SRobert Mustacchi mm_read_barrier();
1577d14abf15SRobert Mustacchi *ret = ddi_get32(pdev->vars.reg_handle[bar],
1578d14abf15SRobert Mustacchi (uint32_t *)((caddr_t)pdev->vars.mapped_bar_addr[bar] +
1579d14abf15SRobert Mustacchi offset));
1580d14abf15SRobert Mustacchi }
1581d14abf15SRobert Mustacchi
1582d14abf15SRobert Mustacchi
mm_bar_read_ddword(struct _lm_device_t * pdev,u8_t bar,u32_t offset,u64_t * ret)1583d14abf15SRobert Mustacchi void mm_bar_read_ddword(struct _lm_device_t *pdev,
1584d14abf15SRobert Mustacchi u8_t bar,
1585d14abf15SRobert Mustacchi u32_t offset,
1586d14abf15SRobert Mustacchi u64_t *ret)
1587d14abf15SRobert Mustacchi {
1588d14abf15SRobert Mustacchi mm_read_barrier();
1589d14abf15SRobert Mustacchi *ret = ddi_get64(pdev->vars.reg_handle[bar],
1590d14abf15SRobert Mustacchi (uint64_t *)((caddr_t)pdev->vars.mapped_bar_addr[bar] +
1591d14abf15SRobert Mustacchi offset));
1592d14abf15SRobert Mustacchi }
1593d14abf15SRobert Mustacchi
1594d14abf15SRobert Mustacchi
mm_bar_write_byte(struct _lm_device_t * pdev,u8_t bar,u32_t offset,u8_t val)1595d14abf15SRobert Mustacchi void mm_bar_write_byte(struct _lm_device_t *pdev,
1596d14abf15SRobert Mustacchi u8_t bar,
1597d14abf15SRobert Mustacchi u32_t offset,
1598d14abf15SRobert Mustacchi u8_t val)
1599d14abf15SRobert Mustacchi {
1600d14abf15SRobert Mustacchi ddi_put8(pdev->vars.reg_handle[bar],
1601d14abf15SRobert Mustacchi (uint8_t *)((caddr_t)pdev->vars.mapped_bar_addr[bar] + offset),
1602d14abf15SRobert Mustacchi val);
1603d14abf15SRobert Mustacchi mm_write_barrier();
1604d14abf15SRobert Mustacchi }
1605d14abf15SRobert Mustacchi
1606d14abf15SRobert Mustacchi
mm_bar_write_word(struct _lm_device_t * pdev,u8_t bar,u32_t offset,u16_t val)1607d14abf15SRobert Mustacchi void mm_bar_write_word(struct _lm_device_t *pdev,
1608d14abf15SRobert Mustacchi u8_t bar,
1609d14abf15SRobert Mustacchi u32_t offset,
1610d14abf15SRobert Mustacchi u16_t val)
1611d14abf15SRobert Mustacchi {
1612d14abf15SRobert Mustacchi ddi_put16(pdev->vars.reg_handle[bar],
1613d14abf15SRobert Mustacchi (uint16_t *)((caddr_t)pdev->vars.mapped_bar_addr[bar] + offset),
1614d14abf15SRobert Mustacchi val);
1615d14abf15SRobert Mustacchi mm_write_barrier();
1616d14abf15SRobert Mustacchi }
1617d14abf15SRobert Mustacchi
1618d14abf15SRobert Mustacchi
mm_bar_write_dword(struct _lm_device_t * pdev,u8_t bar,u32_t offset,u32_t val)1619d14abf15SRobert Mustacchi void mm_bar_write_dword(struct _lm_device_t *pdev,
1620d14abf15SRobert Mustacchi u8_t bar,
1621d14abf15SRobert Mustacchi u32_t offset,
1622d14abf15SRobert Mustacchi u32_t val)
1623d14abf15SRobert Mustacchi {
1624d14abf15SRobert Mustacchi ddi_put32(pdev->vars.reg_handle[bar],
1625d14abf15SRobert Mustacchi (uint32_t *)((caddr_t)pdev->vars.mapped_bar_addr[bar] + offset),
1626d14abf15SRobert Mustacchi val);
1627d14abf15SRobert Mustacchi mm_write_barrier();
1628d14abf15SRobert Mustacchi }
1629d14abf15SRobert Mustacchi
1630d14abf15SRobert Mustacchi
mm_bar_write_ddword(struct _lm_device_t * pdev,u8_t bar,u32_t offset,u64_t val)1631d14abf15SRobert Mustacchi void mm_bar_write_ddword(struct _lm_device_t *pdev,
1632d14abf15SRobert Mustacchi u8_t bar,
1633d14abf15SRobert Mustacchi u32_t offset,
1634d14abf15SRobert Mustacchi u64_t val)
1635d14abf15SRobert Mustacchi {
1636d14abf15SRobert Mustacchi ddi_put64(pdev->vars.reg_handle[bar],
1637d14abf15SRobert Mustacchi (uint64_t *)((caddr_t)pdev->vars.mapped_bar_addr[bar] + offset),
1638d14abf15SRobert Mustacchi val);
1639d14abf15SRobert Mustacchi mm_write_barrier();
1640d14abf15SRobert Mustacchi }
1641d14abf15SRobert Mustacchi
1642d14abf15SRobert Mustacchi
mm_bar_copy_buffer(struct _lm_device_t * pdev,u8_t bar,u32_t offset,u32_t size,u32_t * buf_ptr)1643d14abf15SRobert Mustacchi void mm_bar_copy_buffer(struct _lm_device_t * pdev,
1644d14abf15SRobert Mustacchi u8_t bar,
1645d14abf15SRobert Mustacchi u32_t offset,
1646d14abf15SRobert Mustacchi u32_t size,
1647d14abf15SRobert Mustacchi u32_t *buf_ptr)
1648d14abf15SRobert Mustacchi {
1649d14abf15SRobert Mustacchi u32_t i;
1650d14abf15SRobert Mustacchi
1651d14abf15SRobert Mustacchi for (i = 0; i < size; i++)
1652d14abf15SRobert Mustacchi {
1653d14abf15SRobert Mustacchi ddi_put32(pdev->vars.reg_handle[bar],
1654d14abf15SRobert Mustacchi (uint32_t *)((caddr_t)pdev->vars.mapped_bar_addr[bar] +
1655d14abf15SRobert Mustacchi offset + (i * 4)),
1656d14abf15SRobert Mustacchi *(buf_ptr + i));
1657d14abf15SRobert Mustacchi }
1658d14abf15SRobert Mustacchi }
1659d14abf15SRobert Mustacchi
1660d14abf15SRobert Mustacchi
mm_get_cap_offset(struct _lm_device_t * pdev,u32_t capabilityID)1661d14abf15SRobert Mustacchi u32_t mm_get_cap_offset(struct _lm_device_t * pdev,
1662d14abf15SRobert Mustacchi u32_t capabilityID)
1663d14abf15SRobert Mustacchi {
1664d14abf15SRobert Mustacchi u32_t cap_offset = PCI_CAPABILITY_LIST; //CapPtr ofset
1665d14abf15SRobert Mustacchi u8_t cap_id;
1666d14abf15SRobert Mustacchi u32_t reg_value = 0;
1667d14abf15SRobert Mustacchi
1668d14abf15SRobert Mustacchi lm_status_t lm_status = mm_read_pci(pdev, cap_offset, ®_value);
1669d14abf15SRobert Mustacchi if ((lm_status == LM_STATUS_SUCCESS) && (reg_value != 0xFFFFFFFF)) {
1670d14abf15SRobert Mustacchi cap_offset = (u8_t)(reg_value & 0x000000FF);
1671d14abf15SRobert Mustacchi if ((cap_offset == 0) || (cap_offset >= 0x100)) {
1672d14abf15SRobert Mustacchi return 0xFFFFFFFF;
1673d14abf15SRobert Mustacchi }
1674d14abf15SRobert Mustacchi } else {
1675d14abf15SRobert Mustacchi return 0xFFFFFFFF;
1676d14abf15SRobert Mustacchi }
1677d14abf15SRobert Mustacchi do {
1678d14abf15SRobert Mustacchi reg_value = 0;
1679d14abf15SRobert Mustacchi lm_status = mm_read_pci(pdev, cap_offset, ®_value);
1680d14abf15SRobert Mustacchi if ((lm_status == LM_STATUS_SUCCESS) && (reg_value != 0xFFFFFFFF)) {
1681d14abf15SRobert Mustacchi cap_id = (u8_t)(reg_value & 0x000000FF);
1682d14abf15SRobert Mustacchi if (cap_id == capabilityID) {
1683d14abf15SRobert Mustacchi break;
1684d14abf15SRobert Mustacchi }
1685d14abf15SRobert Mustacchi cap_offset = (reg_value & 0x0000FF00) >> 8;
1686d14abf15SRobert Mustacchi if (cap_offset == 0) {
1687d14abf15SRobert Mustacchi break;
1688d14abf15SRobert Mustacchi }
1689d14abf15SRobert Mustacchi } else {
1690d14abf15SRobert Mustacchi cap_offset = 0xFFFFFFFF;
1691d14abf15SRobert Mustacchi break;
1692d14abf15SRobert Mustacchi }
1693d14abf15SRobert Mustacchi } while ((lm_status == LM_STATUS_SUCCESS));
1694d14abf15SRobert Mustacchi
1695d14abf15SRobert Mustacchi return cap_offset;
1696d14abf15SRobert Mustacchi }
1697d14abf15SRobert Mustacchi
mm_get_wol_flags(struct _lm_device_t * pdev)1698d14abf15SRobert Mustacchi u32_t mm_get_wol_flags(struct _lm_device_t * pdev)
1699d14abf15SRobert Mustacchi {
1700d14abf15SRobert Mustacchi return LM_WAKE_UP_MODE_NONE;
1701d14abf15SRobert Mustacchi }
1702d14abf15SRobert Mustacchi
mm_get_feature_flags(struct _lm_device_t * pdev)1703d14abf15SRobert Mustacchi u32_t mm_get_feature_flags(struct _lm_device_t * pdev)
1704d14abf15SRobert Mustacchi {
1705d14abf15SRobert Mustacchi return 0;
1706d14abf15SRobert Mustacchi }
1707d14abf15SRobert Mustacchi
mm_get_vmq_cnt(struct _lm_device_t * pdev)1708d14abf15SRobert Mustacchi u32_t mm_get_vmq_cnt(struct _lm_device_t * pdev)
1709d14abf15SRobert Mustacchi {
1710d14abf15SRobert Mustacchi return 0;
1711d14abf15SRobert Mustacchi }
1712d14abf15SRobert Mustacchi
mm_i2c_update(struct _lm_device_t * pdev)1713d14abf15SRobert Mustacchi lm_status_t mm_i2c_update(struct _lm_device_t * pdev)
1714d14abf15SRobert Mustacchi {
1715d14abf15SRobert Mustacchi return LM_STATUS_SUCCESS;
1716d14abf15SRobert Mustacchi }
1717d14abf15SRobert Mustacchi
mm_query_system_time(void)1718d14abf15SRobert Mustacchi u64_t mm_query_system_time(void)
1719d14abf15SRobert Mustacchi {
1720d14abf15SRobert Mustacchi return 0;
1721d14abf15SRobert Mustacchi }
1722d14abf15SRobert Mustacchi
1723