1 
2 /*****************************************************************************
3  * CDDL HEADER START
4  *
5  * The contents of this file are subject to the terms of the
6  * Common Development and Distribution License (the "License").
7  * You may not use this file except in compliance with the License.
8  *
9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10  * or http://www.opensolaris.org/os/licensing.
11  * See the License for the specific language governing permissions
12  * and limitations under the License.
13  *
14  * When distributing Covered Code, include this CDDL HEADER in each
15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16  * If applicable, add the following below this CDDL HEADER, with the
17  * fields enclosed by brackets "[]" replaced with your own identifying
18  * information: Portions Copyright [yyyy] [name of copyright owner]
19  *
20  * CDDL HEADER END
21  *
22  * Copyright 2014 QLogic Corporation
23  * The contents of this file are subject to the terms of the
24  * QLogic End User License (the "License").
25  * You may not use this file except in compliance with the License.
26  *
27  * You can obtain a copy of the License at
28  * http://www.qlogic.com/Resources/Documents/DriverDownloadHelp/
29  * QLogic_End_User_Software_License.txt
30  * See the License for the specific language governing permissions
31  * and limitations under the License.
32  *
33  *****************************************************************************/
34 
35 #ifndef _MM_H
36 #define _MM_H
37 
38 #include <sys/va_list.h>
39 
40 /*
41    This define is relevant for MS compilers.
42    So the main purpose here is to comply with older MS compilers
43    as well as non-MS compilers
44 */
45 #ifndef FORCEINLINE
46 #if defined(_MSC_VER) && (_MSC_VER >= 1200) /* Windows */
47 #define FORCEINLINE __forceinline
48 #else
49 #define FORCEINLINE __inline
50 #endif /* _MSC_VER */
51 #endif /* !FORCEINLINE */
52 
53 /* common lpme callback used by multiple platforms */
54 typedef void lm_generic_workitem_function(struct _lm_device_t *pdev);
55 lm_status_t mm_register_lpme(struct _lm_device_t *_pdev,
56                              lm_generic_workitem_function *func,
57                              const u8_t b_fw_access,
58                              const u8_t b_queue_for_fw);
59 
60 /* mm_i2c for special elink query */
61 lm_status_t mm_i2c_update(struct _lm_device_t *pdev);
62 
63 /* query system time - for time stamps */
64 u64_t       mm_query_system_time(void);
65 
66 #if defined(UEFI)
67 #include "mm_uefi.h"
68 #elif defined(DOS)
69 #include "mm_dos.h"
70 #elif defined(__LINUX) || defined (USER_LINUX)
71 #include "mm_linux.h"
72 #elif defined(__SunOS)
73 #include "mm_solaris.h"
74 #elif defined(__USER_MODE_DEBUG)
75 #include "mm_user_mode_debug.h"
76 #elif defined(_VBD_) || defined(_VBD_CMD_)
77 #include "mm_vbd.h"
78 #elif defined (NDISMONO) // VBD
79 #include "mm_ndismono.h"
80 #endif
81 
82 unsigned int mm_crc32(unsigned char *address, unsigned int size, unsigned int crc);
83 
84 #define mm_read_barrier()  mm_read_barrier_imp()
85 #define mm_write_barrier() mm_write_barrier_imp()
86 #define mm_barrier()       mm_barrier_imp()
87 
88 #define mm_atomic_set(/* u32_t* */_p, /* u32_t */_v) mm_atomic_set_imp(_p, _v)
89 
90 #define mm_atomic_dec(/* u32_t* */_p) mm_atomic_dec_imp(_p)
91 #define mm_atomic_inc(/* u32_t* */_p) mm_atomic_inc_imp(_p)
92 
93 #define mm_atomic_add(/* u32_t* */_p, /* u32_t */_v) mm_atomic_add_imp(_p, _v)
94 
95 #define mm_atomic_sub(/* u32_t* */_p, /* u32_t */_v) mm_atomic_sub_imp(_p, _v)
96 
97 #define mm_atomic_and(/* u32_t* */_p, /* u32_t */_v) mm_atomic_and_imp(_p, _v)
98 #define mm_atomic_long_and(/* unsigned long* */_p, /* unsigned long */_v) \
99     mm_atomic_long_and_imp(_p, _v)
100 
101 #define mm_atomic_or(/* u32_t* */_p, /* u32_t */_v)  mm_atomic_or_imp(_p, _v)
102 #define mm_atomic_long_or(/* unsigned long* */_p, /* unsigned long */_v) \
103     mm_atomic_long_or_imp(_p, _v)
104 
105 #define mm_atomic_read(/* u32_t* */_p) mm_atomic_read_imp(_p)
106 #define mm_atomic_long_read(/* unsigned long* */_p)  \
107     mm_atomic_long_read_imp(_p)
108 
109 #define mm_atomic_cmpxchg(/* u32_t* */_p, /* u32_t */_old_val, /* u32_t */_new_val) \
110     mm_atomic_cmpxchg_imp(_p, _old_val, _new_val)
111 
112 #define MM_WRITE_DOORBELL(/* struct _lm_device_t* */PDEV, /* u32_t */BAR, /* u32_t */CID, /* u32_t */VAL) \
113     MM_WRITE_DOORBELL_IMP(PDEV, BAR, CID, VAL)
114 
115 #define MM_REGISTER_LPME(/* struct _lm_device_t* */_pdev, /* lm_generic_workitem_function */_func, /* u8_t */_b_fw_access, /* u8_t */_b_queue_for_fw) \
116     MM_REGISTER_LPME_IMP(_pdev, _func, _b_fw_access, _b_queue_for_fw)
117 
118 #define MM_ACQUIRE_SPQ_LOCK(/* struct _lm_device_t* */pdev)     MM_ACQUIRE_SPQ_LOCK_IMP(pdev)
119 #define MM_RELEASE_SPQ_LOCK(/* struct _lm_device_t* */pdev)     MM_RELEASE_SPQ_LOCK_IMP(pdev)
120 #define MM_ACQUIRE_SPQ_LOCK_DPC(/* struct _lm_device_t* */pdev) MM_ACQUIRE_SPQ_LOCK_DPC(pdev)
121 #define MM_RELEASE_SPQ_LOCK_DPC(/* struct _lm_device_t* */pdev) MM_RELEASE_SPQ_LOCK_DPC(pdev)
122 
123 #define MM_ACQUIRE_CID_LOCK(/* struct _lm_device_t* */pdev) MM_ACQUIRE_CID_LOCK_IMP(pdev)
124 #define MM_RELEASE_CID_LOCK(/* struct _lm_device_t* */pdev) MM_RELEASE_CID_LOCK_IMP(pdev)
125 
126 #define MM_ACQUIRE_REQUEST_LOCK(/* struct _lm_device_t* */pdev) MM_ACQUIRE_REQUEST_LOCK_IMP(pdev)
127 #define MM_RELEASE_REQUEST_LOCK(/* struct _lm_device_t* */pdev) MM_RELEASE_REQUEST_LOCK_IMP(pdev)
128 
129 #define MM_ACQUIRE_REQUEST_LOCK_DPC(/* struct _lm_device_t* */pdev) MM_ACQUIRE_REQUEST_LOCK_DPC_IMP(pdev)
130 #define MM_RELEASE_REQUEST_LOCK_DPC(/* struct _lm_device_t* */pdev) MM_RELEASE_REQUEST_LOCK_DPC_IMP(pdev)
131 
132 #define MM_ACQUIRE_PHY_LOCK(/* struct _lm_device_t* */pdev)     MM_ACQUIRE_PHY_LOCK_IMP(pdev)
133 #define MM_RELEASE_PHY_LOCK(/* struct _lm_device_t* */pdev)     MM_RELEASE_PHY_LOCK_IMP(pdev)
134 #define MM_ACQUIRE_PHY_LOCK_DPC(/* struct _lm_device_t* */pdev) MM_ACQUIRE_PHY_LOCK_DPC_IMP(pdev)
135 #define MM_RELEASE_PHY_LOCK_DPC(/* struct _lm_device_t* */pdev) MM_RELEASE_PHY_LOCK_DPC_IMP(pdev)
136 
137 #define MM_ACQUIRE_MCP_LOCK(/* struct _lm_device_t* */pdev) MM_ACQUIRE_MCP_LOCK_IMP(pdev)
138 #define MM_RELEASE_MCP_LOCK(/* struct _lm_device_t* */pdev) MM_RELEASE_MCP_LOCK_IMP(pdev)
139 
140 #define MM_ACQUIRE_ISLES_CONTROL_LOCK(/* struct _lm_device_t* */pdev)     MM_ACQUIRE_ISLES_CONTROL_LOCK_IMP(pdev)
141 #define MM_RELEASE_ISLES_CONTROL_LOCK(/* struct _lm_device_t* */pdev)     MM_RELEASE_ISLES_CONTROL_LOCK_IMP(pdev)
142 #define MM_ACQUIRE_ISLES_CONTROL_LOCK_DPC(/* struct _lm_device_t* */pdev) MM_ACQUIRE_ISLES_CONTROL_LOCK_DPC_IMP(pdev)
143 #define MM_RELEASE_ISLES_CONTROL_LOCK_DPC(/* struct _lm_device_t* */pdev) MM_RELEASE_ISLES_CONTROL_LOCK_DPC_IMP(pdev)
144 
145 #define MM_ACQUIRE_RAMROD_COMP_LOCK(/* struct _lm_device_t* */pdev) MM_ACQUIRE_RAMROD_COMP_LOCK_IMP(pdev)
146 #define MM_RELEASE_RAMROD_COMP_LOCK(/* struct _lm_device_t* */pdev) MM_RELEASE_RAMROD_COMP_LOCK_IMP(pdev)
147 
148 #define MM_ACQUIRE_IND_REG_LOCK(/* struct _lm_device_t* */pdev) MM_ACQUIRE_IND_REG_LOCK_IMP(pdev)
149 #define MM_RELEASE_IND_REG_LOCK(/* struct _lm_device_t* */pdev) MM_RELEASE_IND_REG_LOCK_IMP(pdev)
150 
151 #define MM_ACQUIRE_LOADER_LOCK() MM_ACQUIRE_LOADER_LOCK_IMP()
152 #define MM_RELEASE_LOADER_LOCK() MM_RELEASE_LOADER_LOCK_IMP()
153 
154 #define MM_ACQUIRE_SP_REQ_MGR_LOCK(/* struct _lm_device_t* */pdev) MM_ACQUIRE_SP_REQ_MGR_LOCK_IMP(pdev)
155 #define MM_RELEASE_SP_REQ_MGR_LOCK(/* struct _lm_device_t* */pdev) MM_RELEASE_SP_REQ_MGR_LOCK_IMP(pdev)
156 
157 #define MM_ACQUIRE_SB_LOCK(/* struct _lm_device_t* */pdev, /* u8_t */sb_idx) MM_ACQUIRE_SB_LOCK_IMP(pdev, sb_idx)
158 #define MM_RELEASE_SB_LOCK(/* struct _lm_device_t* */pdev, /* u8_t */sb_idx) MM_RELEASE_SB_LOCK_IMP(pdev, sb_idx)
159 
160 void mm_init_lock(struct _lm_device_t *_pdev, mm_spin_lock_t *spinlock);
161 
162 #ifdef _VBD_
163 #if defined(NTDDI_WIN8)
164 __drv_maxIRQL(DISPATCH_LEVEL)
165 __drv_at(lock->irql, __drv_savesIRQL)
166 __drv_setsIRQL(DISPATCH_LEVEL)
167 #endif
168 #endif
169 lm_status_t mm_acquire_lock( mm_spin_lock_t *spinlock);
170 
171 #ifdef _VBD_
172 #if defined(NTDDI_WIN8)
173 _IRQL_requires_(DISPATCH_LEVEL)
174 __drv_at(lock->irql, __drv_restoresIRQL )
175 #endif
176 #endif
177 lm_status_t mm_release_lock( mm_spin_lock_t *spinlock);
178 
179 #define MM_ACQUIRE_ETH_CON_LOCK(/* struct _lm_device_t* */pdev) MM_ACQUIRE_ETH_CON_LOCK_IMP(pdev)
180 #define MM_RELEASE_ETH_CON_LOCK(/* struct _lm_device_t* */pdev) MM_RELEASE_ETH_CON_LOCK_IMP(pdev)
181 
182 #ifdef VF_INVOLVED
183 
184 #define MM_ACQUIRE_PF_LOCK(/* struct _lm_device_t* */pdev) MM_ACQUIRE_PF_LOCK_IMP(pdev)
185 #define MM_RELEASE_PF_LOCK(/* struct _lm_device_t* */pdev) MM_RELEASE_PF_LOCK_IMP(pdev)
186 
187 #define MM_ACQUIRE_VFS_STATS_LOCK(/* struct _lm_device_t* */pdev)     MM_ACQUIRE_VFS_STATS_LOCK_IMP(pdev)
188 #define MM_RELEASE_VFS_STATS_LOCK(/* struct _lm_device_t* */pdev)     MM_RELEASE_VFS_STATS_LOCK_IMP(pdev)
189 #define MM_ACQUIRE_VFS_STATS_LOCK_DPC(/* struct _lm_device_t* */pdev) MM_ACQUIRE_VFS_STATS_LOCK_DPC_IMP(pdev)
190 #define MM_RELEASE_VFS_STATS_LOCK_DPC(/* struct _lm_device_t* */pdev) MM_RELEASE_VFS_STATS_LOCK_DPC_IMP(pdev)
191 
192 #endif /* VF_INVOLVED */
193 
194 
195 #define mm_er_initiate_recovery(/* struct _lm_device_t* */pdev) \
196     mm_er_initiate_recovery_imp(pdev)
197 
198 #define MM_REGISTER_DPC(/* struct _lm_device_t* */_pdev, /* lm_generic_dpc_func */_func) \
199     mm_register_dpc_imp(_pdev, _func)
200 
201 #define MM_EMPTY_RAMROD_RECEIVED(/* struct _lm_device_t* */pdev, /* lm_cli_idx_t */lm_cli_idx) \
202     mm_empty_ramrod_received_imp(pdev, lm_cli_idx)
203 
204 #define mm_dbus_start_if_enable(/* struct _lm_device_t* */pdev) \
205     mm_dbus_start_if_enabled_imp(pdev)
206 #define mm_dbus_stop_if_started(/* struct _lm_device_t* */pdev) \
207     mm_dbus_stop_if_started_imp(pdev)
208 
209 
210 /* Busy delay for the specified microseconds. */
211 void mm_wait(struct _lm_device_t *pdev,
212              u32_t delay_us);
213 
214 /* Read a PCI configuration register (must be 32-bit aligned) */
215 lm_status_t mm_read_pci(struct _lm_device_t *pdev,
216                         u32_t pci_reg,
217                         u32_t *reg_value);
218 
219 /* Write a PCI configuration register (must be 32-bit aligned) */
220 lm_status_t mm_write_pci(struct _lm_device_t *pdev,
221                          u32_t pci_reg,
222                          u32_t reg_value);
223 
224 /*
225  * Map the base address of the device registers to system address space so
226  * that registers are accessible. The base address will be unmapped when the
227  * driver unloads.
228  */
229 void * mm_map_io_base(struct _lm_device_t *pdev,
230                       lm_address_t base_addr,
231                       u32_t size,
232                       u8_t bar);
233 
234 /* Read driver configuration.  It is called from lm_get_dev_info. */
235 lm_status_t mm_get_user_config(struct _lm_device_t *pdev);
236 
237 /* Get the size of a packet descriptor. */
238 u32_t mm_desc_size(struct _lm_device_t *pdev,
239                    u32_t desc_type);
240 #define DESC_TYPE_L2TX_PACKET 0
241 #define DESC_TYPE_L2RX_PACKET 1
242 
243 
244 /* XXX
245 mm_map_io_space(struct _lm_device_t * pLM,
246                 lm_address_t  physAddr,
247                 u8_t          bar,
248                 u32_t         offset,
249                 u32_t         size,
250                 void *        pHandle);
251 */
252 #ifdef __SunOS
253 void *
254 mm_map_io_space_solaris(struct _lm_device_t *      pLM,
255                         lm_address_t       physAddr,
256                         u8_t               bar,
257                         u32_t              offset,
258                         u32_t              size,
259                         ddi_acc_handle_t * pRegAccHandle);
260 #else
261 void *
262 mm_map_io_space(struct _lm_device_t *pdev,
263                 lm_address_t phys_addr,
264                 u32_t size);
265 #endif
266 
267 void mm_unmap_io_space(struct _lm_device_t *pdev,
268                        void *virt_addr,
269                        u32_t size);
270 
271 
272 void * mm_alloc_mem_imp(struct _lm_device_t *pdev,
273                         u32_t mem_size,
274                         const char* sz_file,
275                         const unsigned long line,
276                         u8_t cli_idx);
277 #define mm_alloc_mem(_pdev, _mem_size, cli_idx) \
278     mm_alloc_mem_imp((_pdev), (_mem_size), __FILE_STRIPPED__, __LINE__, (cli_idx));
279 
280 
281 void * mm_alloc_phys_mem_imp(struct _lm_device_t* pdev,
282                              u32_t mem_size,
283                              lm_address_t* phys_mem,
284                              u8_t mem_type,
285                              const char* sz_file,
286                              const unsigned long line,
287                              u8_t cli_idx);
288 #define mm_alloc_phys_mem(_pdev, _mem_size, _phys_mem, _mem_type, cli_idx) \
289     mm_alloc_phys_mem_imp((_pdev), (_mem_size), (_phys_mem), (_mem_type), __FILE_STRIPPED__, __LINE__, (cli_idx));
290 
291 
292 void * mm_rt_alloc_mem_imp(struct _lm_device_t* pdev,
293                            u32_t mem_size,
294                            const char* sz_file,
295                            const unsigned long line,
296                            u8_t cli_idx);
297 #define mm_rt_alloc_mem(_pdev, _mem_size, cli_idx) \
298     mm_rt_alloc_mem_imp((_pdev), (_mem_size), __FILE_STRIPPED__, __LINE__, (cli_idx));
299 
300 
301 void * mm_alloc_phys_mem_align_imp(struct _lm_device_t* pdev,
302                                    u32_t mem_size,
303                                    lm_address_t* phys_mem,
304                                    u32_t alignment,
305                                    u8_t mem_type,
306                                    const char* sz_file,
307                                    const unsigned long line,
308                                    u8_t cli_idx ) ;
309 
310 #define mm_alloc_phys_mem_align(_pdev, _mem_size, _phys_mem, _alignment, _mem_type, cli_idx) \
311     mm_alloc_phys_mem_align_imp((_pdev), (_mem_size), (_phys_mem), (_alignment), (_mem_type), __FILE_STRIPPED__, __LINE__, (cli_idx));
312 
313 
314 void * mm_rt_alloc_phys_mem_imp(struct _lm_device_t* pdev,
315                                 u32_t mem_size,
316                                 lm_address_t* phys_mem,
317                                 u8_t mem_type,
318                                 const char* sz_file,
319                                 const unsigned long line,
320                                 u8_t cli_idx);
321 
322 #define mm_rt_alloc_phys_mem(_pdev, _mem_size, _phys_mem, _flush_type, cli_idx) \
323     mm_rt_alloc_phys_mem_imp((_pdev), (_mem_size), (_phys_mem), (_flush_type), __FILE_STRIPPED__, __LINE__, (cli_idx));
324 
325 
326 #define PHYS_MEM_TYPE_UNSPECIFIED 0
327 #define PHYS_MEM_TYPE_NONCACHED   1
328 
329 
330 void mm_rt_free_mem(struct _lm_device_t *pdev,
331                     void *mem_virt,
332                     u32_t mem_size,
333                     u8_t cli_idx);
334 
335 void mm_rt_free_phys_mem(struct _lm_device_t *pdev,
336                          u32_t mem_size,
337                          void *virt_mem,
338                          lm_address_t phys_mem,
339                          u8_t cli_idx);
340 
341 
342 void mm_memset(void *buf, u8_t val, u32_t mem_size);
343 #define mm_mem_zero(buf, mem_size) mm_memset((buf), 0, (mem_size))
344 
345 void mm_memcpy(void *destenation, const void *source, u32_t mem_size);
346 
347 u8_t mm_memcmp(void *buf1, void *buf2, u32_t count);
348 
349 
350 /* Returns current high-definition time. */
351 u64_t mm_get_current_time(struct _lm_device_t *pdev);
352 
353 
354 /*
355  * This routine is called to indicate completion of a transmit request.
356  * If 'packet' is not NULL, all the packets in the completion queue will
357  * be indicated.  Otherwise, only 'packet' will be indicated.
358  */
359 void mm_indicate_tx(struct _lm_device_t *pdev,
360                     u32_t chain_idx,
361                     s_list_t *packet_list);
362 
363 
364 /**
365  * @brief
366  *      a function that enables lm to indicate rx packets
367  *      directly. In regular rx indication flow, the call is
368  *      made from UM -> Um request the rx packets and then
369  *      indicates them. This function, at time of writing, was
370  *      used just for aborting packets but may be used for any
371  *      kind of indication.
372  *
373  * @param pdev
374  * @param chain_idx
375  * @param packet_list
376  * @param ind_status   - SUCCESS / ABORTED
377  */
378 void mm_indicate_rx(struct _lm_device_t *pdev,
379                     u32_t                chain_idx,
380                     s_list_t            *packet_list,
381                     lm_status_t          ind_status);
382 
383 /* Indicate the current phy link status. */
384 void mm_indicate_link(struct _lm_device_t *pdev,
385                       lm_status_t link,
386                       lm_medium_t medium);
387 
388 /* Indicate a critical HW error that requires to completely
389    stop all access to the device */
390 void mm_indicate_hw_failure(struct _lm_device_t *pdev);
391 
392 /* Call the lm_task_cb_t callback function after the specified delay. */
393 typedef void(*lm_task_cb_t)(struct _lm_device_t *pdev, void *param);
394 lm_status_t mm_schedule_task(struct _lm_device_t *pdev,
395                              u32_t delay_ms,
396                              lm_task_cb_t task,
397                              void *param);
398 
399 
400 /* XXX needs description... */
401 void mm_set_done(struct _lm_device_t *pdev,
402                  u32_t cid,
403                  void *cookie);
404 
405 
406 struct sq_pending_command;
407 
408 void mm_return_sq_pending_command(struct _lm_device_t * pdev,
409                                   struct sq_pending_command * pending);
410 
411 struct sq_pending_command * mm_get_sq_pending_command(struct _lm_device_t * pdev);
412 
413 
414 u32_t mm_copy_packet_buf(struct _lm_device_t *pdev,
415                          struct _lm_packet_t *lmpkt, /* packet to copy from */
416                          u8_t *mem_buf,              /* buffer to copy to */
417                          u32_t size);                /* number of bytes to copy */
418 
419 
420 lm_status_t mm_event_log_generic_arg_fwd(struct _lm_device_t* pdev,
421                                          const lm_log_id_t lm_log_id,
422                                          va_list ap);
423 
424 lm_status_t mm_event_log_generic(struct _lm_device_t* pdev,
425                                  const lm_log_id_t lm_log_id,
426                                  ...);
427 
428 void mm_print_bdf(int, void*);
429 
430 
431 /* common alloc and zero memory routine used for all platforms */
mm_rt_zalloc_mem(struct _lm_device_t * pdev,u32_t size)432 static __inline void * mm_rt_zalloc_mem(struct _lm_device_t * pdev, u32_t size)
433 {
434     void * ptr;
435 
436     ptr = mm_rt_alloc_mem(pdev, size, 0);
437 
438     if (ptr)
439     {
440         mm_mem_zero(ptr, size);
441     }
442 
443     return ptr;
444 }
445 
446 
447 u32_t mm_build_ver_string(struct _lm_device_t * pdev);
448 
449 
450 #ifdef VF_INVOLVED
451 
452 #ifndef VF_TO_PF_STANDARD_BLOCK_ID
453 #define VF_TO_PF_STANDARD_BLOCK_ID 0x100
454 #endif
455 
456 struct _lm_vf_pf_message_t;
457 struct _lm_vf_info_t;
458 struct _lm_sriov_info_t;
459 
460 void mm_vf_pf_arm_trigger(struct _lm_device_t *pdev,
461                           struct _lm_vf_pf_message_t *mess);
462 
463 lm_status_t mm_vf_pf_write_block_to_sw_channel(struct _lm_device_t *pdev,
464                                                u32_t block_id,
465                                                void *buffer,
466                                                u32_t length);
467 
468 lm_status_t mm_vf_pf_read_block_from_sw_channel(struct _lm_device_t *pdev,
469                                                 u32_t block_id,
470                                                 void *buffer,
471                                                 u32_t *length);
472 
473 lm_status_t mm_vf_pf_sw_ch_process_standard_request(struct _lm_device_t *pdev,
474                                                     u16_t relative_vf_id,
475                                                     void *virt_buffer,
476                                                     u32_t length);
477 
478 lm_status_t mm_vf_pf_sw_ch_retrieve_standard_response(struct _lm_device_t *pdev,
479                                                       u16_t relative_vf_id,
480                                                       void *virt_buffer,
481                                                       u32_t length);
482 
483 lm_status_t mm_vf_pf_hw_ch_process_standard_request(struct _lm_device_t *pdev,
484                                                     u8_t vf_id,
485                                                     lm_address_t *vf_pf_message);
486 
487 lm_status_t mm_vf_pf_upload_standard_request(struct _lm_device_t *pdev,
488                                              u8_t vf_id,
489                                              lm_address_t *vf_pf_message);
490 
491 lm_status_t mm_vf_en(struct _lm_device_t* pdev,
492                      u16_t vfs_num);
493 
494 void mm_vf_dis(struct _lm_device_t* pdev);
495 
496 u16_t mm_get_extended_caps(struct _lm_device_t *pdev,
497                            u16_t capabilityID);
498 
499 lm_status_t mm_get_sriov_info(struct _lm_device_t *pdev,
500                               struct _lm_sriov_info_t *info);
501 
502 lm_status_t mm_pf_get_queues_number(struct _lm_device_t *pdev,
503                                     struct _lm_vf_info_t *vf_info,
504                                     u8_t *num_rxqs,
505                                     u8_t *num_txqs);
506 
507 lm_status_t mm_pf_get_filters_number(struct _lm_device_t *pdev,
508                                      struct _lm_vf_info_t *vf_info,
509                                      u8_t *num_mac_filters,
510                                      u8_t *num_vlan_filters,
511                                      u8_t *num_mc_filters);
512 
513 lm_status_t mm_pf_get_macs(struct _lm_device_t *pdev,
514                            struct _lm_vf_info_t *vf_info,
515                            u8_t *permanent_mac_addr,
516                            u8_t *current_mac_addr);
517 
518 void mm_report_malicious_vf(struct _lm_device_t *pdev, struct _lm_vf_info_t *vf_info);
519 
520 #endif /* ifdef VF_INVOLVED */
521 
522 
523 #ifdef BIG_ENDIAN
524 // LE
525 #define mm_le16_to_cpu(val) mm_le16_to_cpu_imp(val)
526 #define mm_cpu_to_le16(val) mm_cpu_to_le16_imp(val)
527 #define mm_le32_to_cpu(val) mm_le32_to_cpu_imp(val)
528 #define mm_cpu_to_le32(val) mm_cpu_to_le32_imp(val)
529 // BE
530 #define mm_be32_to_cpu(val) mm_be32_to_cpu_imp(val)
531 #define mm_cpu_to_be32(val) mm_cpu_to_be32_imp(val)
532 #define mm_be16_to_cpu(val) mm_be16_to_cpu_imp(val)
533 #define mm_cpu_to_be16(val) mm_cpu_to_be16_imp(val)
534 #else /* LITTLE_ENDIAN */
535 // LE
536 #define mm_le16_to_cpu(val) mm_le16_to_cpu_imp(val)
537 #define mm_cpu_to_le16(val) mm_cpu_to_le16_imp(val)
538 #define mm_le32_to_cpu(val) mm_le32_to_cpu_imp(val)
539 #define mm_cpu_to_le32(val) mm_cpu_to_le32_imp(val)
540 // BE
541 #define mm_be32_to_cpu(val) mm_be32_to_cpu_imp(val)
542 #define mm_cpu_to_be32(val) mm_cpu_to_be32_imp(val)
543 #define mm_be16_to_cpu(val) mm_be16_to_cpu_imp(val)
544 #define mm_cpu_to_be16(val) mm_cpu_to_be16_imp(val)
545 #endif /* ifdef BIG_ENDIAN */
546 
547 
548 #define mm_get_bar_offset(/* struct _lm_device_t* */pdev, /* u8_t */bar_num, /* lm_address_t* */bar_addr) \
549     mm_get_bar_offset_imp(pdev, bar_num, bar_addr)
550 
551 #define mm_get_bar_size(/* struct _lm_device_t* */pdev, /* u8_t */bar_num, /* u32_t* */val_p) \
552     mm_get_bar_size_imp(pdev, bar_num, val_p)
553 
554 
555 #endif /* _MM_H */
556 
557