1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright 2014 QLogic Corporation
24 * The contents of this file are subject to the terms of the
25 * QLogic End User License (the "License").
26 * You may not use this file except in compliance with the License.
27 *
28 * You can obtain a copy of the License at
29 * http://www.qlogic.com/Resources/Documents/DriverDownloadHelp/
30 * QLogic_End_User_Software_License.txt
31 * See the License for the specific language governing permissions
32 * and limitations under the License.
33 */
34
35 #include "bnxe.h"
36
37 #define BNXE_LOG_LEN 256
38
39
40 #ifdef DBG
41
DbgMessageFunc(void * pDev,int level,char * pFmt,...)42 void DbgMessageFunc(void * pDev,
43 int level,
44 char * pFmt,
45 ...)
46 {
47 um_device_t * pUM = (um_device_t *)pDev;
48 va_list argp;
49 int ce;
50
51 if ((pUM != NULL) &&
52 (((pUM->devParams.debug_level & level & CP_ALL) != (level & CP_ALL)) ||
53 ((pUM->devParams.debug_level & LV_MASK) < (level & LV_MASK))))
54 {
55 return;
56 }
57
58 ce = (((level & LV_VERBOSE) == LV_VERBOSE) ? CE_NOTE :
59 ((level & LV_INFORM) == LV_INFORM) ? CE_NOTE :
60 ((level & LV_WARN) == LV_WARN) ? CE_WARN :
61 CE_PANIC);
62
63 va_start(argp, pFmt);
64 vcmn_err(ce, pFmt, argp);
65 va_end(argp);
66 }
67
68 #endif /* DBG */
69
70
elink_cb_dbg(struct elink_dev * bp,char * fmt)71 void elink_cb_dbg(struct elink_dev * bp, char * fmt)
72 {
73 um_device_t * pUM = (um_device_t *)bp;
74 char buf[BNXE_LOG_LEN];
75
76 #ifdef DBG
77 if ((pUM->devParams.debug_level & LV_MASK) < LV_WARN)
78 {
79 return;
80 }
81
82 snprintf(buf, sizeof(buf), fmt);
83 cmn_err(CE_NOTE, "!%s: ELINK %s", BnxeDevName(pUM), buf);
84 #endif
85 }
86
87
elink_cb_dbg1(struct elink_dev * bp,char * fmt,u32 arg1)88 void elink_cb_dbg1(struct elink_dev * bp, char * fmt, u32 arg1)
89 {
90 um_device_t * pUM = (um_device_t *)bp;
91 char buf[BNXE_LOG_LEN];
92
93 #ifdef DBG
94 if ((pUM->devParams.debug_level & LV_MASK) < LV_WARN)
95 {
96 return;
97 }
98
99 snprintf(buf, sizeof(buf), fmt, arg1);
100 cmn_err(CE_NOTE, "!%s: ELINK %s", BnxeDevName(pUM), buf);
101 #endif
102 }
103
104
elink_cb_dbg2(struct elink_dev * bp,char * fmt,u32 arg1,u32 arg2)105 void elink_cb_dbg2(struct elink_dev * bp, char * fmt, u32 arg1, u32 arg2)
106 {
107 um_device_t * pUM = (um_device_t *)bp;
108 char buf[BNXE_LOG_LEN];
109
110 #ifdef DBG
111 if ((pUM->devParams.debug_level & LV_MASK) < LV_WARN)
112 {
113 return;
114 }
115
116 snprintf(buf, sizeof(buf), fmt, arg1, arg2);
117 cmn_err(CE_NOTE, "!%s: ELINK %s", BnxeDevName(pUM), buf);
118 #endif
119 }
120
121
elink_cb_dbg3(struct elink_dev * bp,char * fmt,u32 arg1,u32 arg2,u32 arg3)122 void elink_cb_dbg3(struct elink_dev * bp, char * fmt, u32 arg1, u32 arg2, u32 arg3)
123 {
124 um_device_t * pUM = (um_device_t *)bp;
125 char buf[BNXE_LOG_LEN];
126
127 #ifdef DBG
128 if ((pUM->devParams.debug_level & LV_MASK) < LV_WARN)
129 {
130 return;
131 }
132
133 snprintf(buf, sizeof(buf), fmt, arg1, arg2, arg3);
134 cmn_err(CE_NOTE, "!%s: ELINK %s", BnxeDevName(pUM), buf);
135 #endif
136 }
137
138
BnxeLogInfo(void * pDev,char * pFmt,...)139 void BnxeLogInfo(void * pDev,
140 char * pFmt,
141 ...)
142 {
143 um_device_t * pUM = (um_device_t *)pDev;
144 char buf[BNXE_LOG_LEN];
145 va_list argp;
146
147 /*
148 * Info message are logged to syslog only if logEnable is
149 * turned on. They are never logged to the console. If
150 * pUM is NULL then the log is allowed through as if logEnable
151 * was turned on.
152 */
153
154 if (pUM && !pUM->devParams.logEnable)
155 {
156 return;
157 }
158 /* if !pUM then let the log through */
159
160 va_start(argp, pFmt);
161 vsnprintf(buf, sizeof(buf), pFmt, argp);
162 va_end(argp);
163
164 cmn_err(CE_NOTE, "!%s: %s", BnxeDevName(pUM), buf);
165 }
166
167
BnxeLogWarn(void * pDev,char * pFmt,...)168 void BnxeLogWarn(void * pDev,
169 char * pFmt,
170 ...)
171 {
172 um_device_t * pUM = (um_device_t *)pDev;
173 char buf[BNXE_LOG_LEN];
174 va_list argp;
175
176 /*
177 * Warning message are always logged to syslog. They are
178 * never logged to the console.
179 */
180
181 va_start(argp, pFmt);
182 vsnprintf(buf, sizeof(buf), pFmt, argp);
183 va_end(argp);
184
185 cmn_err(CE_WARN, "!%s: %s", BnxeDevName(pUM), buf);
186 }
187
188
189 #ifdef DBG
190
BnxeLogDbg(void * pDev,char * pFmt,...)191 void BnxeLogDbg(void * pDev,
192 char * pFmt,
193 ...)
194 {
195 um_device_t * pUM = (um_device_t *)pDev;
196 char buf[BNXE_LOG_LEN];
197 va_list argp;
198
199 /*
200 * Debug message are always logged to syslog. They are
201 * never logged to the console. Debug messages are only
202 * available when the DEBUG compile time flag is turned on.
203 */
204
205 va_start(argp, pFmt);
206 vsnprintf(buf, sizeof(buf), pFmt, argp);
207 va_end(argp);
208
209 cmn_err(CE_WARN, "!%s: %s", BnxeDevName(pUM), buf);
210 }
211
212 #endif /* DBG */
213
214
BnxeDumpMem(um_device_t * pUM,char * pTag,u8_t * pMem,u32_t len)215 void BnxeDumpMem(um_device_t * pUM,
216 char * pTag,
217 u8_t * pMem,
218 u32_t len)
219 {
220 char buf[256];
221 char c[32];
222 int xx;
223
224 mutex_enter(&bnxeLoaderMutex);
225
226 cmn_err(CE_WARN, "!%s ++++++++++++ %s", BnxeDevName(pUM), pTag);
227 strcpy(buf, "!** 000: ");
228
229 for (xx = 0; xx < len; xx++)
230 {
231 if ((xx != 0) && (xx % 16 == 0))
232 {
233 cmn_err(CE_WARN, buf);
234 strcpy(buf, "!** ");
235 snprintf(c, sizeof(c), "%03x", xx);
236 strcat(buf, c);
237 strcat(buf, ": ");
238 }
239
240 snprintf(c, sizeof(c), "%02x ", *pMem);
241 strcat(buf, c);
242
243 pMem++;
244 }
245
246 cmn_err(CE_WARN, buf);
247 cmn_err(CE_WARN, "!%s ------------ %s", BnxeDevName(pUM), pTag);
248
249 mutex_exit(&bnxeLoaderMutex);
250 }
251
252
BnxeDumpPkt(um_device_t * pUM,char * pTag,mblk_t * pMblk,boolean_t contents)253 void BnxeDumpPkt(um_device_t * pUM,
254 char * pTag,
255 mblk_t * pMblk,
256 boolean_t contents)
257 {
258 char buf[256];
259 char c[32];
260 u8_t * pMem;
261 int i, xx = 0;
262
263 mutex_enter(&bnxeLoaderMutex);
264
265 cmn_err(CE_WARN, "!%s ++++++++++++ %s", BnxeDevName(pUM), pTag);
266
267 while (pMblk)
268 {
269 pMem = pMblk->b_rptr;
270 strcpy(buf, "!** > ");
271 snprintf(c, sizeof(c), "%03x", xx);
272 strcat(buf, c);
273 strcat(buf, ": ");
274
275 if (contents)
276 {
277 for (i = 0; i < MBLKL(pMblk); i++)
278 {
279 if ((xx != 0) && (xx % 16 == 0))
280 {
281 cmn_err(CE_WARN, buf);
282 strcpy(buf, "!** ");
283 snprintf(c, sizeof(c), "%03x", xx);
284 strcat(buf, c);
285 strcat(buf, ": ");
286 }
287
288 snprintf(c, sizeof(c), "%02x ", *pMem);
289 strcat(buf, c);
290
291 pMem++;
292 xx++;
293 }
294 }
295 else
296 {
297 snprintf(c, sizeof(c), "%d", (int)MBLKL(pMblk));
298 strcat(buf, c);
299 xx += MBLKL(pMblk);
300 }
301
302 cmn_err(CE_WARN, buf);
303 pMblk = pMblk->b_cont;
304 }
305
306 cmn_err(CE_WARN, "!%s ------------ %s", BnxeDevName(pUM), pTag);
307
308 mutex_exit(&bnxeLoaderMutex);
309 }
310