xref: /illumos-gate/usr/src/uts/common/io/bnxe/bnxe_mm.c (revision 55fea89d)
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, &regSize);
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, &regSize);
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, &reg_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, &reg_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