[mlx4] Added the latest revision of the mlx4 to the trunk.
[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
111 VOID
112 mlx4_err(
113         IN struct mlx4_dev *    mdev,
114         IN char*                                format,
115         ...
116         )
117 {
118         va_list         list;
119         UCHAR           buf[MAX_BUFFER_SIZE];
120         WCHAR           wbuf[MAX_BUFFER_SIZE];
121
122         // print to Debugger
123         va_start(list, format);
124         buf[MAX_BUFFER_SIZE - 1] = '\0';
125         RtlStringCbVPrintfA( (char*)buf, sizeof(buf), format, list);
126         DbgPrint( (char*)buf );
127         va_end(list);
128
129         // print to Event Log
130         if (!RtlStringCchPrintfW(wbuf, sizeof(wbuf), L"%S", buf))
131                 WriteEventLogEntryStr( mdev->pdev->p_self_do, (ULONG)EVENT_MLX4_ANY_ERROR, 0, 0, wbuf, 0, 0 ); 
132 }
133
134 VOID
135 mlx4_dbg(
136         IN struct mlx4_dev *    mdev,
137         IN char*                                format,
138         ...
139         )
140 {
141 #if DBG
142         va_list         list;
143         UCHAR           buf[MAX_BUFFER_SIZE];
144         UNUSED_PARAM(mdev);
145
146         // print to Debugger
147         va_start(list, format);
148         buf[MAX_BUFFER_SIZE - 1] = '\0';
149         RtlStringCbVPrintfA( (char*)buf, sizeof(buf), format, list);
150         DbgPrint( (char*)buf );
151         va_end(list);
152 #else   
153         UNUSED_PARAM(mdev);
154         UNUSED_PARAM(format);
155 #endif //DBG
156 }
157
158 VOID
159 dev_err(
160         IN struct mlx4_dev **   mdev,
161         IN char*                                format,
162         ...
163         )
164 {
165         va_list         list;
166         UCHAR           buf[MAX_BUFFER_SIZE];
167         WCHAR           wbuf[MAX_BUFFER_SIZE];
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         DbgPrint( (char*)buf );
174         va_end(list);
175
176         // print to Event Log
177         RtlStringCchPrintfW(wbuf, sizeof(wbuf), L"%S", buf);
178         WriteEventLogEntryStr( (*mdev)->pdev->p_self_do, (ULONG)EVENT_MLX4_ANY_ERROR, 0, 0, wbuf, 0, 0 ); 
179 }
180
181 VOID
182 dev_info(
183         IN struct mlx4_dev **   p_mdev,
184         IN char*                                format,
185         ...
186         )
187 {
188 #if DBG
189         va_list         list;
190         UCHAR           buf[MAX_BUFFER_SIZE];
191         UNUSED_PARAM(p_mdev);
192
193         // print to Debugger
194         va_start(list, format);
195         buf[MAX_BUFFER_SIZE - 1] = '\0';
196         RtlStringCbVPrintfA( (char*)buf, sizeof(buf), format, list);
197         DbgPrint( (char*)buf );
198         va_end(list);
199 #else   
200         UNUSED_PARAM(p_mdev);
201         UNUSED_PARAM(format);
202 #endif
203 }
204
205