467dc371bc8c6d2ecdcd34aae3acf379ecc9ad68
[mirror/winof/.git] / core / al / al_common.h
1 /*\r
2  * Copyright (c) 2005 SilverStorm Technologies.  All rights reserved.\r
3  * Copyright (c) 1996-2003 Intel Corporation. All rights reserved. \r
4  *\r
5  * This software is available to you under the OpenIB.org BSD license\r
6  * below:\r
7  *\r
8  *     Redistribution and use in source and binary forms, with or\r
9  *     without modification, are permitted provided that the following\r
10  *     conditions are met:\r
11  *\r
12  *      - Redistributions of source code must retain the above\r
13  *        copyright notice, this list of conditions and the following\r
14  *        disclaimer.\r
15  *\r
16  *      - Redistributions in binary form must reproduce the above\r
17  *        copyright notice, this list of conditions and the following\r
18  *        disclaimer in the documentation and/or other materials\r
19  *        provided with the distribution.\r
20  *\r
21  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,\r
22  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\r
23  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\r
24  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS\r
25  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN\r
26  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
27  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r
28  * SOFTWARE.\r
29  *\r
30  * $Id$\r
31  */\r
32 \r
33 #if !defined(__AL_COMMON_H__)\r
34 #define __AL_COMMON_H__\r
35 \r
36 #include <iba/ib_al.h>\r
37 \r
38 #include <complib/cl_atomic.h>\r
39 #include <complib/cl_async_proc.h>\r
40 #include <complib/cl_event.h>\r
41 #include <complib/cl_qlist.h>\r
42 #include <complib/cl_spinlock.h>\r
43 #include <complib/cl_obj.h>\r
44 \r
45 \r
46 /* Driver parameters */\r
47 extern uint32_t         g_smi_poll_interval;\r
48 extern uint32_t         g_ioc_query_timeout;\r
49 extern uint32_t         g_ioc_query_retries;\r
50 extern uint32_t         g_ioc_poll_interval;\r
51 \r
52 \r
53 /* Wait operations performed in user-mode must be alertable. */\r
54 #ifdef CL_KERNEL\r
55 #define AL_WAIT_ALERTABLE       FALSE\r
56 #else   /* CL_KERNEL */\r
57 #define AL_WAIT_ALERTABLE       TRUE\r
58 #endif  /* CL_KERNEL */\r
59 \r
60 /*\r
61  * Controls whether the al_objects use their own private\r
62  * thread pool for destruction.\r
63  */\r
64 #define AL_OBJ_PRIVATE_ASYNC_PROC       1\r
65 \r
66 #if AL_OBJ_PRIVATE_ASYNC_PROC\r
67 extern cl_async_proc_t          *gp_async_obj_mgr;\r
68 #endif\r
69 \r
70 \r
71 /*\r
72  * Macro to verify a AL object handle.  We ignore the upper byte of the type\r
73  * when making the type comparison.  The upper byte specifies a subtype.\r
74  */\r
75 #define AL_BASE_TYPE( t )               ( (t) & 0x00FFFFFF )\r
76 #define AL_SUBTYPE( t )                 ( (t) & 0xFF000000 )\r
77 \r
78 #define AL_OBJ_BASE_TYPE( h )   ( AL_BASE_TYPE( (h)->obj.type ) )\r
79 #define AL_OBJ_SUBTYPE( h )             ( AL_SUBTYPE( (h)->obj.type ) )\r
80 \r
81 #define AL_OBJ_IS_TYPE( h, t ) \\r
82         ( AL_OBJ_BASE_TYPE( h ) == AL_BASE_TYPE( t ) )\r
83 \r
84 #define AL_OBJ_IS_SUBTYPE( h, t ) \\r
85         ( AL_OBJ_SUBTYPE( h ) == AL_SUBTYPE( t ) )\r
86 \r
87 #define AL_OBJ_INVALID_HANDLE( h, t )   \\r
88         ( !(h) || !AL_OBJ_IS_TYPE( h, t ) || ((h)->obj.state != CL_INITIALIZED) )\r
89 \r
90 \r
91 typedef struct _al_obj __p_al_obj_t;\r
92 \r
93 \r
94 /* Function used to release AL items created by the object. */\r
95 typedef void\r
96 (*al_pfn_destroying_t)(\r
97         IN                              struct _al_obj                          *p_obj );\r
98 \r
99 \r
100 /* Function used to cleanup any HW resources used by the object. */\r
101 typedef void\r
102 (*al_pfn_cleanup_t)(\r
103         IN                              struct _al_obj                          *p_obj );\r
104 \r
105 \r
106 /* Function to all resources used by the object. */\r
107 typedef void\r
108 (*al_pfn_free_t)(\r
109         IN                              struct _al_obj                          *p_obj );\r
110 \r
111 \r
112 /* Function invoked to release HW resources. */\r
113 typedef void\r
114 (*al_pfn_destroy_t)(\r
115         IN                              struct _al_obj                          *p_obj,\r
116         IN              const   ib_pfn_destroy_cb_t                     pfn_destroy_cb );\r
117 \r
118 \r
119 \r
120 /*\r
121  * Different types of AL object's.  Note that the upper byte signifies\r
122  * a subtype.\r
123  */\r
124 #define AL_OBJ_TYPE_UNKNOWN                     0\r
125 #define AL_OBJ_TYPE_H_AL                        1\r
126 #define AL_OBJ_TYPE_H_QP                        2\r
127 #define AL_OBJ_TYPE_H_AV                        3\r
128 #define AL_OBJ_TYPE_H_MR                        4\r
129 #define AL_OBJ_TYPE_H_MW                        5\r
130 #define AL_OBJ_TYPE_H_PD                        6\r
131 #define AL_OBJ_TYPE_H_CA                        7\r
132 #define AL_OBJ_TYPE_H_CQ                        8\r
133 #define AL_OBJ_TYPE_H_CONN                      9\r
134 #define AL_OBJ_TYPE_H_LISTEN            10\r
135 #define AL_OBJ_TYPE_H_IOC                       11\r
136 #define AL_OBJ_TYPE_H_SVC_ENTRY         12\r
137 #define AL_OBJ_TYPE_H_PNP                       13\r
138 #define AL_OBJ_TYPE_H_SA_REQ            14\r
139 #define AL_OBJ_TYPE_H_MCAST                     15\r
140 #define AL_OBJ_TYPE_H_ATTACH            16\r
141 #define AL_OBJ_TYPE_H_MAD                       17\r
142 #define AL_OBJ_TYPE_H_MAD_POOL          18\r
143 #define AL_OBJ_TYPE_H_POOL_KEY          19\r
144 #define AL_OBJ_TYPE_H_MAD_SVC           20\r
145 #define AL_OBJ_TYPE_CI_CA                       21\r
146 #define AL_OBJ_TYPE_CM                          22\r
147 #define AL_OBJ_TYPE_SMI                         23\r
148 #define AL_OBJ_TYPE_DM                          24\r
149 #define AL_OBJ_TYPE_IOU                         25\r
150 #define AL_OBJ_TYPE_LOADER                      26\r
151 #define AL_OBJ_TYPE_MAD_POOL            27\r
152 #define AL_OBJ_TYPE_MAD_DISP            28\r
153 #define AL_OBJ_TYPE_AL_MGR                      29\r
154 #define AL_OBJ_TYPE_PNP_MGR                     30\r
155 #define AL_OBJ_TYPE_IOC_PNP_MGR         31\r
156 #define AL_OBJ_TYPE_IOC_PNP_SVC         32\r
157 #define AL_OBJ_TYPE_QUERY_SVC           33\r
158 #define AL_OBJ_TYPE_MCAST_SVC           34\r
159 #define AL_OBJ_TYPE_SA_REQ_SVC          35\r
160 #define AL_OBJ_TYPE_RES_MGR                     36\r
161 #define AL_OBJ_TYPE_H_CA_ATTR           37\r
162 #define AL_OBJ_TYPE_H_PNP_EVENT         38\r
163 #define AL_OBJ_TYPE_H_SA_REG            40\r
164 #define AL_OBJ_TYPE_INVALID                     39      /* Must be last type. */\r
165 \r
166 /* Kernel object for a user-mode app. */\r
167 #define AL_OBJ_SUBTYPE_UM_EXPORT        0x80000000\r
168 \r
169 /* CM related subtypes, used by the CM proxy. */\r
170 #define AL_OBJ_SUBTYPE_REQ                      0x01000000\r
171 #define AL_OBJ_SUBTYPE_REP                      0x02000000\r
172 #define AL_OBJ_SUBTYPE_DREQ                     0x04000000\r
173 #define AL_OBJ_SUBTYPE_LAP                      0x08000000\r
174 \r
175 typedef uint32_t        al_obj_type_t;\r
176 \r
177 \r
178 #define AL_DEFAULT_TIMEOUT_MS   10000           /* 10 seconds */\r
179 #define AL_DEFAULT_TIMEOUT_US   (AL_DEFAULT_TIMEOUT_MS * 1000)\r
180 #define AL_TIMEOUT_PER_DESC_US  10000\r
181 #define AL_MAX_TIMEOUT_MS               (AL_DEFAULT_TIMEOUT_MS * 10)\r
182 #define AL_MAX_TIMEOUT_US               (AL_MAX_TIMEOUT_MS * 1000)\r
183 \r
184 \r
185 #if defined( _DEBUG_ )\r
186 const char* ib_obj_type_str[];\r
187 #endif\r
188 \r
189 \r
190 /*\r
191  * Base object for AL resources.  This must be the first element of\r
192  * AL resources.\r
193  */\r
194 typedef struct _al_obj\r
195 {\r
196         cl_pool_item_t                          pool_item;\r
197 \r
198         struct _al_obj                          *p_parent_obj;\r
199         struct _al_ci_ca                        *p_ci_ca;\r
200 \r
201         const void                                      *context;\r
202 \r
203         /* Asynchronous item used when destroying the object asynchronously. */\r
204         cl_async_proc_item_t            async_item;\r
205 \r
206         /* Event used when destroying the object synchronously. */\r
207         cl_event_t                                      event;\r
208         uint32_t                                        timeout_ms;\r
209         uint32_t                                        desc_cnt;\r
210 \r
211         al_pfn_destroy_t                        pfn_destroy;\r
212         al_pfn_destroying_t                     pfn_destroying;\r
213         al_pfn_cleanup_t                        pfn_cleanup;\r
214         al_pfn_free_t                           pfn_free;\r
215         ib_pfn_destroy_cb_t                     user_destroy_cb;\r
216 \r
217         cl_spinlock_t                           lock;\r
218         cl_qlist_t                                      obj_list;\r
219         atomic32_t                                      ref_cnt;\r
220 \r
221         cl_list_item_t                          list_item;\r
222         al_obj_type_t                           type;\r
223         cl_state_t                                      state;\r
224 \r
225         uint64_t                                        hdl;    /* User Handle. */\r
226         ib_al_handle_t                          h_al;   /* Owning AL instance. */\r
227 \r
228 #ifdef CL_KERNEL\r
229         /*\r
230          * Flag to indicate that UM calls may proceed on the given object.\r
231          * Set by the proxy when creation completes successfully.\r
232          */\r
233         boolean_t                                       hdl_valid;\r
234 #endif\r
235 \r
236 }       al_obj_t;\r
237 \r
238 \r
239 void\r
240 construct_al_obj(\r
241         IN                              al_obj_t * const                        p_obj,\r
242         IN              const   al_obj_type_t                           obj_type );\r
243 \r
244 \r
245 ib_api_status_t\r
246 init_al_obj(\r
247         IN                              al_obj_t * const                        p_obj,\r
248         IN              const   void* const                                     context,\r
249         IN                              boolean_t                                       async_destroy,\r
250         IN              const   al_pfn_destroying_t                     pfn_destroying,\r
251         IN              const   al_pfn_cleanup_t                        pfn_cleanup,\r
252         IN              const   al_pfn_free_t                           pfn_free );\r
253 \r
254 /*\r
255  * Reset an object's state.  This is called after pfn_destroy() has\r
256  * been called on a object, but before destroy_al_obj() has been invoked.\r
257  * It allows an object to be initialized once, then returned to a pool\r
258  * on destruction, and later reused after being removed from the pool.\r
259  */\r
260 void\r
261 reset_al_obj(\r
262         IN                              al_obj_t * const                        p_obj );\r
263 \r
264 void\r
265 set_al_obj_timeout(\r
266         IN                              al_obj_t * const                        p_obj,\r
267         IN              const   uint32_t                                        timeout_ms );\r
268 \r
269 void\r
270 inc_al_obj_desc(\r
271         IN                              al_obj_t * const                        p_obj,\r
272         IN              const   uint32_t                                        desc_cnt );\r
273 \r
274 \r
275 /*\r
276  * Attach to our parent object.  The parent will destroy the child when\r
277  * it is destroyed.  Attaching a child to the parent automatically\r
278  * increments the parent's reference count.\r
279  */\r
280 ib_api_status_t\r
281 attach_al_obj(\r
282         IN                              al_obj_t * const                        p_parent_obj ,\r
283         IN                              al_obj_t * const                        p_child_obj );\r
284 \r
285 \r
286 /*\r
287  * Increment the reference count on an AL object.\r
288  */\r
289 void\r
290 ref_al_obj(\r
291         IN                              al_obj_t * const                        p_obj );\r
292 \r
293 \r
294 /*\r
295  * Called to release a child object from its parent.  The child's\r
296  * reference to its parent is still held.\r
297  */\r
298 void\r
299 detach_al_obj(\r
300         IN                              al_obj_t * const                        p_obj );\r
301 \r
302 /*\r
303  * Decrement the reference count on an AL object.\r
304  */\r
305 AL_EXPORT int32_t AL_API\r
306 deref_al_obj(\r
307         IN                              al_obj_t * const                        p_obj );\r
308 \r
309 /*\r
310  * Called to cleanup all resources allocated by an object.\r
311  */\r
312 void\r
313 destroy_al_obj(\r
314         IN                              al_obj_t * const                        p_obj );\r
315 \r
316 \r
317 \r
318 #if defined( _DEBUG_ )  \r
319 extern const char* ib_obj_type_str[];\r
320 \r
321 static inline const char*\r
322 ib_get_obj_type(\r
323         IN                              al_obj_t * const                        p_obj )\r
324 {\r
325         if( AL_BASE_TYPE( p_obj->type ) > AL_OBJ_TYPE_INVALID )\r
326                 return( ib_obj_type_str[AL_OBJ_TYPE_UNKNOWN] );\r
327 \r
328         return( ib_obj_type_str[ AL_BASE_TYPE( p_obj->type ) ] );\r
329 }\r
330 #endif\r
331 \r
332 \r
333 \r
334 #endif /* __AL_COMMON_H__ */\r