[DAPL2] sync with WinOF 2.1 branch
[mirror/winof/.git] / inc / complib / cl_ioctl.h
1 /*\r
2  * Copyright (c) 2005 SilverStorm Technologies.  All rights reserved.\r
3  *\r
4  * This software is available to you under the OpenIB.org BSD license\r
5  * below:\r
6  *\r
7  *     Redistribution and use in source and binary forms, with or\r
8  *     without modification, are permitted provided that the following\r
9  *     conditions are met:\r
10  *\r
11  *      - Redistributions of source code must retain the above\r
12  *        copyright notice, this list of conditions and the following\r
13  *        disclaimer.\r
14  *\r
15  *      - Redistributions in binary form must reproduce the above\r
16  *        copyright notice, this list of conditions and the following\r
17  *        disclaimer in the documentation and/or other materials\r
18  *        provided with the distribution.\r
19  *\r
20  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,\r
21  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\r
22  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\r
23  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS\r
24  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN\r
25  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
26  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r
27  * SOFTWARE.\r
28  *\r
29  * $Id$\r
30  */\r
31 \r
32 \r
33 /*\r
34  * Abstract:\r
35  *      Declaration of IOCTL object\r
36  *\r
37  * Environment:\r
38  *      All\r
39  */\r
40 \r
41 \r
42 #ifndef _CL_IOCTL_H_\r
43 #define _CL_IOCTL_H_\r
44 \r
45 \r
46 #include <complib/cl_types.h>\r
47 #include <complib/cl_ioctl_osd.h>\r
48 \r
49 \r
50 /****h* Component Library/IOCTL Object\r
51 * NAME\r
52 *       IOCTL Object\r
53 *\r
54 * DESCRIPTION\r
55 *       The IOCTL object provides functionality for handling IOCTL requests.\r
56 *\r
57 *       The IOCTL object is only available in kernel mode and provides\r
58 *       functionality for accessing information about IO requests initiated\r
59 *       by a user-mode application.  The IOCTL_CODE macro is used in both\r
60 *       user and kernel mode to initiate and dispatch IOCTL requests, respectively.\r
61 *\r
62 *       In Linux, in order for the IOCTL object to be used, requests must be\r
63 *       initiated and handled using the Device Framework abstraction.\r
64 *\r
65 * SEE ALSO\r
66 *       Structures:\r
67 *               cl_ioctl_handle_t\r
68 *\r
69 *       Callbacks:\r
70 *               cl_pfn_ioctl_handler_t\r
71 *\r
72 *       Control Code Generation\r
73 *               IOCTL_CODE\r
74 *\r
75 *       Kernel Mode Access\r
76 *               cl_ioctl_process\r
77 *               cl_ioctl_complete\r
78 *               cl_ioctl_type\r
79 *               cl_ioctl_cmd\r
80 *               cl_ioctl_ctl_code\r
81 *               cl_ioctl_in_buf\r
82 *               cl_ioctl_in_size\r
83 *               cl_ioctl_out_buf\r
84 *               cl_ioctl_out_size\r
85 *\r
86 *       User Mode Access\r
87 *               cl_ioctl_request\r
88 *               cl_ioctl_result\r
89 *********/\r
90 \r
91 \r
92 /****d* Component Library: IOCTL Object/IOCTL_CODE\r
93 * NAME\r
94 *       IOCTL_CODE\r
95 *\r
96 * DESCRIPTION\r
97 *       Macro for defining IO control command codes.\r
98 *\r
99 * SYNOPSIS\r
100 *       uint32_t IOCTL_CODE( uint16_t type, uint16_t cmd )\r
101 *\r
102 * PARAMETERS\r
103 *       type\r
104 *               [in] user-defined type representing the type of command.  For Linux,\r
105 *               the type is truncated to 8-bits.  For Windows, the type is a 16-bit\r
106 *               value, as described in "Specifying Device Types" in the DDK docs.\r
107 *\r
108 *       cmd\r
109 *               [in] User-defined command.  For Linux, the command field is truncated\r
110 *               to 8-bits.  For Windows, the command can be 12-bits, with values\r
111 *               below 0x800 reserved by Microsoft for system defined commands.\r
112 *\r
113 * RETURN VALUE\r
114 *       A 32-bit control code.  User-mode clients use the control code to initiate\r
115 *       requests.  Kernel-mode clients use the control code to distinguish between\r
116 *       different requests.\r
117 *\r
118 * NOTE\r
119 *       In Windows, all IOCTL command codes defined with the IOCTL_CODE command\r
120 *       result in FILE_ANY_ACCESS and METHOD_BUFFERED being specified.\r
121 *\r
122 * SEE ALSO\r
123 *       IOCTL Object, cl_dev_ioctl, cl_ioctl_type, cl_ioctl_cmd\r
124 *********/\r
125 \r
126 \r
127 #ifdef CL_KERNEL\r
128 \r
129 /****d* Component Library: IOCTL Object/cl_ioctl_handle_t\r
130 * NAME\r
131 *       cl_ioctl_handle_t\r
132 *\r
133 * DESCRIPTION\r
134 *       Opaque handle representing an IO request.\r
135 *\r
136 * NOTES\r
137 *       The cl_ioctl_handle_t type is only available in the kernel.\r
138 *       The cl_ioctl_handle_t type should be treated as opaque, as it\r
139 *       varies from environment to environment.\r
140 *\r
141 * SEE ALSO\r
142 *       IOCTL Object, cl_ioctl_type, cl_ioctl_cmd, cl_ioctl_in_buf,\r
143 *       cl_ioctl_in_size, cl_ioctl_out_buf, cl_ioctl_out_size,\r
144 *       cl_ioctl_set_status, cl_ioctl_set_ret_bytes\r
145 *********/\r
146 \r
147 \r
148 /****d* Component Library: IOCTL Object/cl_pfn_ioctl_handler_t\r
149 * NAME\r
150 *       cl_pfn_ioctl_handler_t\r
151 *\r
152 * DESCRIPTION\r
153 *       The cl_pfn_ioctl_handler_t function type defines the prototype for\r
154 *       IOCTL handlers used when handling IOCTL requests initiated by\r
155 *       cl_ioctl_request.\r
156 *\r
157 * SYNOPSIS\r
158 */\r
159 typedef cl_status_t\r
160 (CL_API *cl_pfn_ioctl_handler_t)(\r
161         IN      cl_ioctl_handle_t       h_ioctl,\r
162         IN      void                            *context_1,\r
163         IN      void                            *context_2 );\r
164 /*\r
165 * PARAMETERS\r
166 *       h_ioctl\r
167 *               [in] Handle to the IOCTL request.\r
168 *\r
169 *       context_1\r
170 *               [in] First context parameters, as provided to cl_ioctl_process.\r
171 *\r
172 *       context_2\r
173 *               [in] Second context parameters, as provided to cl_ioctl_process.\r
174 *\r
175 * RETURN VALUES\r
176 *       CL_SUCCESS if the IOCTL was completed successfully.\r
177 *\r
178 *       CL_PENDING if the IOCTL is being processed asynchronously.\r
179 *\r
180 *       Other return values in case of errors.\r
181 *\r
182 * NOTES\r
183 *       It is acceptable to complete the IOCTL successfully to report an error\r
184 *       status in the output buffer.\r
185 *\r
186 * SEE ALSO\r
187 *       IOCTL Object, cl_ioctl_handle_t, cl_ioctl_process\r
188 *********/\r
189 \r
190 \r
191 #ifdef __cplusplus\r
192 extern "C"\r
193 {\r
194 #endif  /* __cplusplus */\r
195 \r
196 \r
197 /****f* Component Library: IOCTL Object/cl_ioctl_process\r
198 * NAME\r
199 *       cl_ioctl_process\r
200 *\r
201 * DESCRIPTION\r
202 *       The cl_ioctl_process function unpacks information initiated by a call to\r
203 *       cl_ioctl_request function and invokes a user-supplied callback.\r
204 *\r
205 * SYNOPSIS\r
206 */\r
207 CL_EXPORT cl_status_t CL_API\r
208 cl_ioctl_process(\r
209         IN      void                                    *p_ioctl,\r
210         IN      cl_pfn_ioctl_handler_t  pfn_ioctl_handler,\r
211         IN      void                                    *context_1,\r
212         IN      void                                    *context_2 );\r
213 /*\r
214 * PARAMETERS\r
215 *       p_ioctl\r
216 *               [in] Pointer to an OS specific IOCTL information.  In Linux,\r
217 *               this parameter depends on whether the IOCTL is handled synchronously\r
218 *               or asynchronously.  See the notes for further detail.\r
219 *               In Windows, this is a pointer to an IRP.\r
220 *\r
221 *       pfn_ioctl_handler\r
222 *               [in] Pointer to the callback function to invoke for handling the IOCTL.\r
223 *               This callback is independent of the IOCTL command.\r
224 *\r
225 *       context_1\r
226 *               [in] First of two context parameters to pass to the handler.\r
227 *\r
228 *       context_2\r
229 *               [in] Second of two context parameters to pass to the handler.\r
230 *\r
231 * RETURN VALUES\r
232 *       CL_SUCCESS if the IOCTL was processed successfully.\r
233 *\r
234 *       Other values to indicate various failures.\r
235 *\r
236 * NOTES\r
237 *       Users must call cl_ioctl_complete from within the handler if completing\r
238 *       the IOCTL request synchronously.  If the IOCTL request's control code is\r
239 *       invalid, the handler should return CL_INVALID_REQUEST.\r
240 *\r
241 *       In Linux, the p_ioctl parameter is a copy of the argp parameter on input,\r
242 *       and on output points to the IOCTL request object passed to the IOCTL\r
243 *       handler if and only if the IOCTL handler returned CL_PENDING.\r
244 *       This allows the user to cancel the request by passing the same\r
245 *       handle to the cancel routine that was passed to the IOCTL handler.\r
246 *       If all IOCTLs are handled synchronously, it is acceptable to pass the argp\r
247 *       parameter of the IOCTL entry point instead of a copy.\r
248 *\r
249 * SEE ALSO\r
250 *       IOCTL Object, cl_ioctl_handle_t, cl_pfn_ioctl_handler_t, cl_ioctl_complete\r
251 *********/\r
252 \r
253 \r
254 /****f* Component Library: IOCTL Object/cl_ioctl_complete\r
255 * NAME\r
256 *       cl_ioctl_complete\r
257 *\r
258 * DESCRIPTION\r
259 *       Fills in completion information for an IOCTL and releases the IOCTL request\r
260 *       for completion.\r
261 *\r
262 * SYNOPSIS\r
263 */\r
264 CL_EXPORT void CL_API\r
265 cl_ioctl_complete(\r
266         IN      cl_ioctl_handle_t       h_ioctl,\r
267         IN      cl_status_t                     io_status,\r
268         IN      size_t                          ret_bytes );\r
269 /*\r
270 * PARAMETERS\r
271 *       h_ioctl\r
272 *               Handle to the IOCTL being completed.  This handle was provided to\r
273 *               the IOCTL handler.\r
274 *\r
275 *       io_status\r
276 *               Status of the IOCTL request.\r
277 *\r
278 *       ret_bytes\r
279 *               Number of bytes written to the output buffer.\r
280 *\r
281 * RETURN VALUES\r
282 *       This function does not return a value.\r
283 *\r
284 * SEE ALSO\r
285 *       IOCTL Object, cl_ioctl_handle_t, cl_ioctl_process\r
286 *********/\r
287 \r
288 \r
289 /****f* Component Library: IOCTL Object/cl_ioctl_type\r
290 * NAME\r
291 *       cl_ioctl_type\r
292 *\r
293 * DESCRIPTION\r
294 *       Returns the type of an IOCTL.\r
295 *\r
296 * SYNOPSIS\r
297 */\r
298 CL_EXPORT uint16_t CL_API\r
299 cl_ioctl_type(\r
300         IN      cl_ioctl_handle_t       h_ioctl );\r
301 /*\r
302 * PARAMETERS\r
303 *       h_ioctl\r
304 *               [in] Handle to an IOCTL\r
305 *\r
306 * RETURN VALUE\r
307 *       Returns the type of the specified IOCTL request, as defined using\r
308 *       the IOCTL_CMD macro.\r
309 *\r
310 * NOTES\r
311 *       The cl_ioctl_type function is only available in the kernel.\r
312 *\r
313 * SEE ALSO\r
314 *       IOCTL Object, cl_ioctl_handle_t, cl_ioctl_cmd, cl_ioctl_ctl_code\r
315 ********/\r
316 \r
317 \r
318 /****f* Component Library: IOCTL Object/cl_ioctl_cmd\r
319 * NAME\r
320 *       cl_ioctl_cmd\r
321 *\r
322 * DESCRIPTION\r
323 *       Returns the command of an IOCTL\r
324 *\r
325 * SYNOPSIS\r
326 */\r
327 CL_EXPORT uint16_t CL_API\r
328 cl_ioctl_cmd(\r
329         IN      cl_ioctl_handle_t       h_ioctl );\r
330 /*\r
331 * PARAMETERS\r
332 *       h_ioctl\r
333 *               [in] Handle to an IOCTL\r
334 *\r
335 * RETURN VALUE\r
336 *       Returns the command of the specified IOCTL request, as defined using\r
337 *       the IOCTL_CMD macro.\r
338 *\r
339 * NOTES\r
340 *       The cl_ioctl_cmd function is only available in the kernel.\r
341 *\r
342 * SEE ALSO\r
343 *       IOCTL Object, cl_ioctl_handle_t, cl_ioctl_type, cl_ioctl_ctl_code\r
344 ********/\r
345 \r
346 \r
347 /****f* Component Library: IOCTL Object/cl_ioctl_ctl_code\r
348 * NAME\r
349 *       cl_ioctl_ctl_code\r
350 *\r
351 * DESCRIPTION\r
352 *       Returns the 32-bit control code of an IOCTL\r
353 *\r
354 * SYNOPSIS\r
355 */\r
356 CL_EXPORT uint32_t CL_API\r
357 cl_ioctl_ctl_code(\r
358         IN      cl_ioctl_handle_t       h_ioctl );\r
359 /*\r
360 * PARAMETERS\r
361 *       h_ioctl\r
362 *               [in] Handle to an IOCTL\r
363 *\r
364 * RETURN VALUE\r
365 *       Returns the 32-bit control code of the specified IOCTL request,\r
366 *       as defined using the IOCTL_CMD macro.\r
367 *\r
368 * NOTES\r
369 *       The cl_ioctl_ctl_code function is only available in the kernel.\r
370 *\r
371 * SEE ALSO\r
372 *       IOCTL Object, cl_ioctl_handle_t, cl_ioctl_type, cl_ioctl_cmd\r
373 ********/\r
374 \r
375 \r
376 /****f* Component Library: IOCTL Object/cl_ioctl_in_buf\r
377 * NAME\r
378 *       cl_ioctl_in_buf\r
379 *\r
380 * DESCRIPTION\r
381 *       Returns a pointer to the input buffer of an IOCTL.\r
382 *\r
383 * SYNOPSIS\r
384 */\r
385 CL_EXPORT void* CL_API\r
386 cl_ioctl_in_buf(\r
387         IN      cl_ioctl_handle_t       h_ioctl );\r
388 /*\r
389 * PARAMETERS\r
390 *       h_ioctl\r
391 *               [in] Handle to an IOCTL\r
392 *\r
393 * RETURN VALUE\r
394 *       Returns the input buffer of the specified IOCTL request.\r
395 *\r
396 * NOTES\r
397 *       The cl_ioctl_in_buf function is only available in the kernel.\r
398 *\r
399 *       In Windows, for IOCTL operations defined as METHOD_IN_DIRECT, the\r
400 *       returned pointer points to the MDL describing the input buffer.\r
401 *\r
402 * SEE ALSO\r
403 *       IOCTL Object, cl_ioctl_handle_t, cl_ioctl_in_size,\r
404 *       cl_ioctl_out_buf, cl_ioctl_out_size\r
405 ********/\r
406 \r
407 \r
408 /****f* Component Library: IOCTL Object/cl_ioctl_in_size\r
409 * NAME\r
410 *       cl_ioctl_in_size\r
411 *\r
412 * DESCRIPTION\r
413 *       Returns the size of the input buffer of an IOCTL.\r
414 *\r
415 * SYNOPSIS\r
416 */\r
417 CL_EXPORT ULONG CL_API\r
418 cl_ioctl_in_size(\r
419         IN      cl_ioctl_handle_t       h_ioctl );\r
420 /*\r
421 * PARAMETERS\r
422 *       h_ioctl\r
423 *               [in] Handle to an IOCTL\r
424 *\r
425 * RETURN VALUE\r
426 *       Returns the size, in bytes, of the input buffer of the specified\r
427 *       IOCTL request.\r
428 *\r
429 * NOTES\r
430 *       The cl_ioctl_in_size function is only available in the kernel.\r
431 *\r
432 * SEE ALSO\r
433 *       IOCTL Object, cl_ioctl_handle_t, cl_ioctl_in_buf,\r
434 *       cl_ioctl_out_buf, cl_ioctl_out_size\r
435 ********/\r
436 \r
437 \r
438 /****f* Component Library: IOCTL Object/cl_ioctl_out_buf\r
439 * NAME\r
440 *       cl_ioctl_out_buf\r
441 *\r
442 * DESCRIPTION\r
443 *       Returns a pointer to the output buffer of an IOCTL.\r
444 *\r
445 * SYNOPSIS\r
446 */\r
447 CL_EXPORT void* CL_API\r
448 cl_ioctl_out_buf(\r
449         IN      cl_ioctl_handle_t       h_ioctl );\r
450 /*\r
451 * PARAMETERS\r
452 *       h_ioctl\r
453 *               [in] Handle to an IOCTL\r
454 *\r
455 * RETURN VALUE\r
456 *       Returns a pointer to the output buffer of the specified IOCTL request.\r
457 *\r
458 * NOTES\r
459 *       The cl_ioctl_out_buf function is only available in the kernel.\r
460 *\r
461 *       In Windows, for IOCTL operations defined as METHOD_IN_DIRECT or\r
462 *       METHOD_OUT_DIRECT, the returned pointer points to the MDL describing\r
463 *       the input buffer.\r
464 *\r
465 * SEE ALSO\r
466 *       IOCTL Object, cl_ioctl_handle_t, cl_ioctl_out_size,\r
467 *       cl_ioctl_in_buf, cl_ioctl_in_size\r
468 ********/\r
469 \r
470 \r
471 /****f* Component Library: IOCTL Object/cl_ioctl_out_size\r
472 * NAME\r
473 *       cl_ioctl_out_size\r
474 *\r
475 * DESCRIPTION\r
476 *       Returns the size of the output buffer of an IOCTL.\r
477 *\r
478 * SYNOPSIS\r
479 */\r
480 CL_EXPORT ULONG CL_API\r
481 cl_ioctl_out_size(\r
482         IN      cl_ioctl_handle_t       h_ioctl );\r
483 /*\r
484 * PARAMETERS\r
485 *       h_ioctl\r
486 *               [in] Handle to an IOCTL\r
487 *\r
488 * RETURN VALUE\r
489 *       Returns the size, in bytes, of the input buffer of the specified\r
490 *       IOCTL request.\r
491 *\r
492 * NOTES\r
493 *       The cl_ioctl_out_size function is only available in the kernel.\r
494 *\r
495 * SEE ALSO\r
496 *       IOCTL Object, cl_ioctl_handle_t, cl_ioctl_out_buf,\r
497 *       cl_ioctl_in_buf, cl_ioctl_in_size\r
498 ********/\r
499 \r
500 \r
501 #ifdef __cplusplus\r
502 }\r
503 #endif  /* __cplusplus */\r
504 \r
505 \r
506 #else   /* CL_KERNEL */\r
507 \r
508 \r
509 #ifdef __cplusplus\r
510 extern "C"\r
511 {\r
512 #endif  /* __cplusplus */\r
513 \r
514 \r
515 /****f* Component Library: IOCTL Object/cl_ioctl_request\r
516 * NAME\r
517 *       cl_ioctl_request\r
518 *\r
519 * DESCRIPTION\r
520 *       The cl_ioctl_request is used by user-mode clients to initiate IOCTL\r
521 *       requests to a device.\r
522 *\r
523 * SYNOPSIS\r
524 */\r
525 CL_EXPORT cl_status_t CL_API\r
526 cl_ioctl_request(\r
527         IN              void                    *h_dev,\r
528         IN              uint32_t                ioctl_code,\r
529         IN              void                    *p_in_buf,\r
530         IN              size_t                  in_size,\r
531                 OUT     void                    *p_out_buf,\r
532         IN              size_t                  out_size,\r
533                 OUT     size_t                  *p_ret_bytes OPTIONAL,\r
534         IN              void                    *p_async_info OPTIONAL );\r
535 /*\r
536 * PARAMETERS\r
537 *       h_dev\r
538 *               [in] Handle to the device to which the IOCTL request is targetted.\r
539 *               In Linux, this is a file descriptor.  In Windows, this is a file\r
540 *               handle.\r
541 *\r
542 *       ioctl_code\r
543 *               [in] Control code for the IOCTL request.\r
544 *\r
545 *       p_in_buf\r
546 *               [in] Pointer to the input buffer.\r
547 *\r
548 *       in_size\r
549 *               [in] Size, in bytes, of the input buffer.\r
550 *\r
551 *       p_out_buf\r
552 *               [out] Pointer to the output buffer.\r
553 *\r
554 *       out_size\r
555 *               [in] Size, in bytes, of the output buffer.\r
556 *\r
557 *       p_ret_bytes\r
558 *               [out] Number of bytes written to the output buffer.  This parameter is\r
559 *               mutually exclusive of the p_async_info parameter.\r
560 *\r
561 *       p_async_info\r
562 *               [in] For platforms that support asynchronous I/O, supplies a pointer\r
563 *               to that platform's async I/O structure, if any.  For Windows, this\r
564 *               is a pointer to an OVERLAPPED structure.  This parameter is mutually\r
565 *               exclusive of the p_ret_bytes parameter.\r
566 *\r
567 * SEE ALSO\r
568 *       IOCTL Object, cl_ioctl_result\r
569 *********/\r
570 \r
571 \r
572 /****f* Component Library: IOCTL Object/cl_ioctl_result\r
573 * NAME\r
574 *       cl_ioctl_result\r
575 *\r
576 * DESCRIPTION\r
577 *       Checks the status of an asynchronous IOCTL request.\r
578 *\r
579 * SYNOPSIS\r
580 */\r
581 CL_EXPORT cl_status_t CL_API\r
582 cl_ioctl_result(\r
583         IN      void            *h_dev,\r
584         IN      void            *p_async_info,\r
585         OUT     size_t          *p_ret_bytes,\r
586         IN      boolean_t       blocking );\r
587 /*\r
588 * PARAMETERS\r
589 *       h_dev\r
590 *               [in] Handle to the device to which the IOCTL request is targetted.\r
591 *               In Linux, this is a file descriptor.  In Windows, this is a file\r
592 *               handle.\r
593 *\r
594 *       p_async_info\r
595 *               [in] For platforms that support asynchronous I/O, supplies a pointer\r
596 *               to that platform's async I/O structure, if any.  For Windows, this\r
597 *               is a pointer to an OVERLAPPED structure.  This must be the same\r
598 *               as that provided in the cl_ioctl_request function.\r
599 *\r
600 *       p_ret_bytes\r
601 *               [out] Number of bytes written to the output buffer.\r
602 *\r
603 *       blocking\r
604 *               [in] If TRUE, indicates that the call should wait until the\r
605 *               specified IOCTL request is complete.\r
606 *\r
607 * RETURN VALUES\r
608 *       CL_SUCCESS if the IOCTL request was successful.  p_ret_bytes contains\r
609 *       the number bytes written to the output buffer.\r
610 *\r
611 *       CL_PENDING if the IOCTL request is not yet complete.\r
612 *\r
613 *       Other status values to indicate errors.\r
614 *\r
615 * SEE ALSO\r
616 *       IOCTL Object, cl_ioctl_request\r
617 *********/\r
618 \r
619 #ifdef __cplusplus\r
620 }\r
621 #endif  /* __cplusplus */\r
622 \r
623 \r
624 #endif  /* CL_KERNEL */\r
625 \r
626 #endif  /* _CL_IOCTL_H_ */\r