3780b26dd8b00720537baadfec04b80b3c04b125
[mirror/winof/.git] / hw / mlx4 / kernel / bus / core / l2w_debug.c
1 #include "l2w.h"
2 #include "ev_log.h"
3
4 #define MAX_BUFFER_SIZE         256
5
6 VOID
7 WriteEventLogEntryStr(
8         PVOID   pi_pIoObject,
9         ULONG   pi_ErrorCode,
10         ULONG   pi_UniqueErrorCode,
11         ULONG   pi_FinalStatus,
12         PWCHAR  pi_InsertionStr,
13         ULONG   pi_nDataItems,
14         ...
15         )
16 /*++
17
18 Routine Description:
19     Writes an event log entry to the event log.
20
21 Arguments:
22
23         pi_pIoObject......... The IO object ( driver object or device object ).
24         pi_ErrorCode......... The error code.
25         pi_UniqueErrorCode... A specific error code.
26         pi_FinalStatus....... The final status.
27         pi_nDataItems........ Number of data items.
28         .
29         . data items values
30         .
31
32 Return Value:
33
34         None .
35
36 --*/
37 { /* WriteEventLogEntryStr */
38
39         /* Variable argument list */    
40         va_list                                 l_Argptr;
41         /* Pointer to an error log entry */
42         PIO_ERROR_LOG_PACKET    l_pErrorLogEntry; 
43         /* sizeof insertion string */
44         int     l_Size = (int)((pi_InsertionStr) ? ((wcslen(pi_InsertionStr) + 1) * sizeof( WCHAR )) : 0);
45         int l_PktSize =sizeof(IO_ERROR_LOG_PACKET)+pi_nDataItems*sizeof(ULONG);
46         int l_TotalSize =l_PktSize +l_Size;
47
48         if (pi_pIoObject == NULL) {
49                 ASSERT(pi_pIoObject != NULL);
50                 return;
51         }
52
53         /* Init the variable argument list */   
54         va_start(l_Argptr, pi_nDataItems);
55
56         /* Allocate an error log entry */ 
57         if (l_TotalSize >= ERROR_LOG_MAXIMUM_SIZE - 2) 
58                 l_TotalSize = ERROR_LOG_MAXIMUM_SIZE - 2;
59         l_pErrorLogEntry = (PIO_ERROR_LOG_PACKET)IoAllocateErrorLogEntry(
60                 pi_pIoObject,  (UCHAR)l_TotalSize );
61
62         /* Check allocation */
63         if ( l_pErrorLogEntry != NULL) 
64         { /* OK */
65
66                 /* Data item index */
67                 USHORT l_nDataItem ;
68
69                 /* Set the error log entry header */
70                 l_pErrorLogEntry->ErrorCode                     = pi_ErrorCode; 
71                 l_pErrorLogEntry->DumpDataSize          = (USHORT) (pi_nDataItems*sizeof(ULONG)); 
72                 l_pErrorLogEntry->SequenceNumber        = 0; 
73                 l_pErrorLogEntry->MajorFunctionCode = 0; 
74                 l_pErrorLogEntry->IoControlCode         = 0; 
75                 l_pErrorLogEntry->RetryCount            = 0; 
76                 l_pErrorLogEntry->UniqueErrorValue      = pi_UniqueErrorCode; 
77                 l_pErrorLogEntry->FinalStatus           = pi_FinalStatus; 
78
79                 /* Insert the data items */
80                 for (l_nDataItem = 0; l_nDataItem < pi_nDataItems; l_nDataItem++) 
81                 { /* Inset a data item */
82
83                         /* Current data item */
84                         int l_CurDataItem ;
85                                 
86                         /* Get next data item */
87                         l_CurDataItem = va_arg( l_Argptr, int);
88
89                         /* Put it into the data array */
90                         l_pErrorLogEntry->DumpData[l_nDataItem] = l_CurDataItem ;
91
92                 } /* Inset a data item */
93
94                 /* add insertion string */
95                 if (pi_InsertionStr) {
96                         char *ptr; 
97                         int sz = min( l_TotalSize - l_PktSize, l_Size );
98                         l_pErrorLogEntry->NumberOfStrings = 1;
99                         l_pErrorLogEntry->StringOffset = sizeof(IO_ERROR_LOG_PACKET) + l_pErrorLogEntry->DumpDataSize;
100                         ptr = (char*)l_pErrorLogEntry + l_pErrorLogEntry->StringOffset;
101                         memcpy( ptr, pi_InsertionStr, sz );
102                         *(WCHAR*)&ptr[sz - 2] = (WCHAR)0;
103                 }
104                 
105                 /* Write the packet */
106                 IoWriteErrorLogEntry(l_pErrorLogEntry);
107
108         } /* OK */
109
110         /* Term the variable argument list */   
111         va_end(l_Argptr);
112
113 } /* WriteEventLogEntry */
114
115 // bsize is to be a strlen(src)
116 // dest has to have enough place, i.e at least (2*strlen(src) + 2)
117 void __ansi_to_wchar( USHORT *dest, UCHAR *src, int bsize)
118 {
119         int i;
120
121         for (i=0; i<bsize; ++i)
122                 *dest++ = *src++;
123         *dest = 0;
124 }
125
126 VOID
127 mlx4_err(
128         IN struct mlx4_dev *    mdev,
129         IN char*                                format,
130         ...
131         )
132 {
133         va_list         list;
134         UCHAR           buf[MAX_BUFFER_SIZE];
135         WCHAR           wbuf[MAX_BUFFER_SIZE];
136
137         // print to Debugger
138         va_start(list, format);
139         buf[MAX_BUFFER_SIZE - 1] = '\0';
140
141         if (mdev == NULL) {
142                 ASSERT(mdev != NULL);
143                 return;
144         }
145
146         
147         if (RtlStringCbVPrintfA( (char*)buf, sizeof(buf), format, list))
148                 return;
149         cl_dbg_out( "%s\n", (char*)buf );
150         va_end(list);
151
152         // print to Event Log
153         __ansi_to_wchar( wbuf, buf, (int)strlen((void*)buf) );
154         WriteEventLogEntryStr( mdev->pdev->p_self_do, (ULONG)EVENT_MLX4_ANY_ERROR, 0, 0, wbuf, 0, 0 ); 
155 }
156
157 VOID
158 mlx4_dbg(
159         IN struct mlx4_dev *    mdev,
160         IN char*                                format,
161         ...
162         )
163 {
164 #if DBG
165         va_list         list;
166         UCHAR           buf[MAX_BUFFER_SIZE];
167         UNUSED_PARAM(mdev);
168
169         // print to Debugger
170         va_start(list, format);
171         buf[MAX_BUFFER_SIZE - 1] = '\0';
172         RtlStringCbVPrintfA( (char*)buf, sizeof(buf), format, list);
173         cl_dbg_out( "%s\n", (char*)buf );
174         va_end(list);
175 #else   
176         UNUSED_PARAM(mdev);
177         UNUSED_PARAM(format);
178 #endif //DBG
179 }
180
181 VOID
182 dev_err(
183         IN struct mlx4_dev **   mdev,
184         IN char*                                format,
185         ...
186         )
187 {
188         va_list         list;
189         UCHAR           buf[MAX_BUFFER_SIZE];
190         WCHAR           wbuf[MAX_BUFFER_SIZE];
191
192         if (mdev == NULL) {
193                 ASSERT(mdev != NULL);
194                 return;
195         }
196
197         // print to Debugger
198         va_start(list, format);
199         buf[MAX_BUFFER_SIZE - 1] = '\0';
200         RtlStringCbVPrintfA( (char*)buf, sizeof(buf), format, list);
201         cl_dbg_out( "%s\n", (char*)buf );
202         va_end(list);
203
204         // print to Event Log
205         RtlStringCchPrintfW(wbuf, sizeof(wbuf)/sizeof(wbuf[0]), L"%S", buf);
206         WriteEventLogEntryStr( (*mdev)->pdev->p_self_do, (ULONG)EVENT_MLX4_ANY_ERROR, 0, 0, wbuf, 0, 0 ); 
207 }
208
209 VOID
210 dev_info(
211         IN struct mlx4_dev **   p_mdev,
212         IN char*                                format,
213         ...
214         )
215 {
216 #if DBG
217         va_list         list;
218         UCHAR           buf[MAX_BUFFER_SIZE];
219         UNUSED_PARAM(p_mdev);
220
221         // print to Debugger
222         va_start(list, format);
223         buf[MAX_BUFFER_SIZE - 1] = '\0';
224         RtlStringCbVPrintfA( (char*)buf, sizeof(buf), format, list);
225         cl_dbg_out( "%s\n", (char*)buf );
226         va_end(list);
227 #else   
228         UNUSED_PARAM(p_mdev);
229         UNUSED_PARAM(format);
230 #endif
231 }
232
233
234