[MLX4] cleaning
[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         /* Init the variable argument list */   
49         va_start(l_Argptr, pi_nDataItems);
50
51         /* Allocate an error log entry */ 
52         if (l_TotalSize >= ERROR_LOG_MAXIMUM_SIZE - 2) 
53                 l_TotalSize = ERROR_LOG_MAXIMUM_SIZE - 2;
54         l_pErrorLogEntry = (PIO_ERROR_LOG_PACKET)IoAllocateErrorLogEntry(
55                 pi_pIoObject,  (UCHAR)l_TotalSize );
56
57         /* Check allocation */
58         if ( l_pErrorLogEntry != NULL) 
59         { /* OK */
60
61                 /* Data item index */
62                 USHORT l_nDataItem ;
63
64                 /* Set the error log entry header */
65                 l_pErrorLogEntry->ErrorCode                     = pi_ErrorCode; 
66                 l_pErrorLogEntry->DumpDataSize          = (USHORT) (pi_nDataItems*sizeof(ULONG)); 
67                 l_pErrorLogEntry->SequenceNumber        = 0; 
68                 l_pErrorLogEntry->MajorFunctionCode = 0; 
69                 l_pErrorLogEntry->IoControlCode         = 0; 
70                 l_pErrorLogEntry->RetryCount            = 0; 
71                 l_pErrorLogEntry->UniqueErrorValue      = pi_UniqueErrorCode; 
72                 l_pErrorLogEntry->FinalStatus           = pi_FinalStatus; 
73
74                 /* Insert the data items */
75                 for (l_nDataItem = 0; l_nDataItem < pi_nDataItems; l_nDataItem++) 
76                 { /* Inset a data item */
77
78                         /* Current data item */
79                         int l_CurDataItem ;
80                                 
81                         /* Get next data item */
82                         l_CurDataItem = va_arg( l_Argptr, int);
83
84                         /* Put it into the data array */
85                         l_pErrorLogEntry->DumpData[l_nDataItem] = l_CurDataItem ;
86
87                 } /* Inset a data item */
88
89                 /* add insertion string */
90                 if (pi_InsertionStr) {
91                         char *ptr; 
92                         int sz = min( l_TotalSize - l_PktSize, l_Size );
93                         l_pErrorLogEntry->NumberOfStrings = 1;
94                         l_pErrorLogEntry->StringOffset = sizeof(IO_ERROR_LOG_PACKET) + l_pErrorLogEntry->DumpDataSize;
95                         ptr = (char*)l_pErrorLogEntry + l_pErrorLogEntry->StringOffset;
96                         memcpy( ptr, pi_InsertionStr, sz );
97                         *(WCHAR*)&ptr[sz - 2] = (WCHAR)0;
98                 }
99                 
100                 /* Write the packet */
101                 IoWriteErrorLogEntry(l_pErrorLogEntry);
102
103         } /* OK */
104
105         /* Term the variable argument list */   
106         va_end(l_Argptr);
107
108 } /* WriteEventLogEntry */
109
110 // bsize is to be a strlen(src)
111 // dest has to have enough place, i.e at least (2*strlen(src) + 2)
112 void __ansi_to_wchar( USHORT *dest, UCHAR *src, int bsize)
113 {
114         int i;
115
116         for (i=0; i<bsize; ++i)
117                 *dest++ = *src++;
118         *dest = 0;
119 }
120
121 VOID
122 mlx4_err(
123         IN struct mlx4_dev *    mdev,
124         IN char*                                format,
125         ...
126         )
127 {
128         va_list         list;
129         UCHAR           buf[MAX_BUFFER_SIZE];
130         WCHAR           wbuf[MAX_BUFFER_SIZE];
131
132         // print to Debugger
133         va_start(list, format);
134         buf[MAX_BUFFER_SIZE - 1] = '\0';
135         if (RtlStringCbVPrintfA( (char*)buf, sizeof(buf), format, list))
136                 return;
137         DbgPrint( (char*)buf );
138         va_end(list);
139
140         // print to Event Log
141         __ansi_to_wchar( wbuf, buf, strlen(buf) );
142         WriteEventLogEntryStr( mdev->pdev->p_self_do, (ULONG)EVENT_MLX4_ANY_ERROR, 0, 0, wbuf, 0, 0 ); 
143 }
144
145 VOID
146 mlx4_dbg(
147         IN struct mlx4_dev *    mdev,
148         IN char*                                format,
149         ...
150         )
151 {
152 #if DBG
153         va_list         list;
154         UCHAR           buf[MAX_BUFFER_SIZE];
155         UNUSED_PARAM(mdev);
156
157         // print to Debugger
158         va_start(list, format);
159         buf[MAX_BUFFER_SIZE - 1] = '\0';
160         RtlStringCbVPrintfA( (char*)buf, sizeof(buf), format, list);
161         DbgPrint( (char*)buf );
162         va_end(list);
163 #else   
164         UNUSED_PARAM(mdev);
165         UNUSED_PARAM(format);
166 #endif //DBG
167 }
168
169 VOID
170 dev_err(
171         IN struct mlx4_dev **   mdev,
172         IN char*                                format,
173         ...
174         )
175 {
176         va_list         list;
177         UCHAR           buf[MAX_BUFFER_SIZE];
178         WCHAR           wbuf[MAX_BUFFER_SIZE];
179
180         // print to Debugger
181         va_start(list, format);
182         buf[MAX_BUFFER_SIZE - 1] = '\0';
183         RtlStringCbVPrintfA( (char*)buf, sizeof(buf), format, list);
184         DbgPrint( (char*)buf );
185         va_end(list);
186
187         // print to Event Log
188         RtlStringCchPrintfW(wbuf, sizeof(wbuf)/sizeof(wbuf[0]), L"%S", buf);
189         WriteEventLogEntryStr( (*mdev)->pdev->p_self_do, (ULONG)EVENT_MLX4_ANY_ERROR, 0, 0, wbuf, 0, 0 ); 
190 }
191
192 VOID
193 dev_info(
194         IN struct mlx4_dev **   p_mdev,
195         IN char*                                format,
196         ...
197         )
198 {
199 #if DBG
200         va_list         list;
201         UCHAR           buf[MAX_BUFFER_SIZE];
202         UNUSED_PARAM(p_mdev);
203
204         // print to Debugger
205         va_start(list, format);
206         buf[MAX_BUFFER_SIZE - 1] = '\0';
207         RtlStringCbVPrintfA( (char*)buf, sizeof(buf), format, list);
208         DbgPrint( (char*)buf );
209         va_end(list);
210 #else   
211         UNUSED_PARAM(p_mdev);
212         UNUSED_PARAM(format);
213 #endif
214 }
215
216
217