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