emlxs_diag.c (fcf3ce44) emlxs_diag.c (291a2b48)
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

--- 6 unchanged lines hidden (view full) ---

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/*
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

--- 6 unchanged lines hidden (view full) ---

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 2008 Emulex. All rights reserved.
23 * Copyright 2009 Emulex. All rights reserved.
24 * Use is subject to License terms.
25 */
26
24 * Use is subject to License terms.
25 */
26
27#include <emlxs.h>
27
28
28#include "emlxs.h"
29
29
30
31/* Required for EMLXS_CONTEXT in EMLXS_MSGF calls */
32EMLXS_MSG_DEF(EMLXS_DIAG_C);
33
30/* Required for EMLXS_CONTEXT in EMLXS_MSGF calls */
31EMLXS_MSG_DEF(EMLXS_DIAG_C);
32
34uint32_t emlxs_diag_pattern[256] =
35{
33uint32_t emlxs_diag_pattern[256] = {
36 /* Walking ones */
37 0x80000000, 0x40000000, 0x20000000, 0x10000000,
38 0x08000000, 0x04000000, 0x02000000, 0x01000000,
39 0x00800000, 0x00400000, 0x00200000, 0x00100000,
40 0x00080000, 0x00040000, 0x00020000, 0x00010000,
41 0x00008000, 0x00004000, 0x00002000, 0x00001000,
42 0x00000800, 0x00000400, 0x00000200, 0x00000100,
43 0x00000080, 0x00000040, 0x00000020, 0x00000010,

--- 80 unchanged lines hidden (view full) ---

124 /* Set the completed flag and wake up sleeping threads */
125 mutex_enter(&EMLXS_PKT_LOCK);
126 pkt->pkt_tran_flags |= FC_TRAN_COMPLETED;
127 cv_broadcast(&EMLXS_PKT_CV);
128 mutex_exit(&EMLXS_PKT_LOCK);
129
130 return;
131
34 /* Walking ones */
35 0x80000000, 0x40000000, 0x20000000, 0x10000000,
36 0x08000000, 0x04000000, 0x02000000, 0x01000000,
37 0x00800000, 0x00400000, 0x00200000, 0x00100000,
38 0x00080000, 0x00040000, 0x00020000, 0x00010000,
39 0x00008000, 0x00004000, 0x00002000, 0x00001000,
40 0x00000800, 0x00000400, 0x00000200, 0x00000100,
41 0x00000080, 0x00000040, 0x00000020, 0x00000010,

--- 80 unchanged lines hidden (view full) ---

122 /* Set the completed flag and wake up sleeping threads */
123 mutex_enter(&EMLXS_PKT_LOCK);
124 pkt->pkt_tran_flags |= FC_TRAN_COMPLETED;
125 cv_broadcast(&EMLXS_PKT_CV);
126 mutex_exit(&EMLXS_PKT_LOCK);
127
128 return;
129
132} /* emlxs_diag_pkt_callback() */
130} /* emlxs_diag_pkt_callback() */
133
134
131
132
135
136extern uint32_t
137emlxs_diag_echo_run(emlxs_port_t *port, uint32_t did, uint32_t pattern)
138{
139 emlxs_hba_t *hba = HBA;
140 uint32_t i = 0;
141 uint32_t rval = FC_SUCCESS;
142 int32_t pkt_ret;
143 fc_packet_t *pkt;

--- 5 unchanged lines hidden (view full) ---

149 uint32_t *lptr;
150 NODELIST *ndlp;
151 uint8_t *pat;
152
153 /* Check did */
154 if (did == 0) {
155 did = port->did;
156 }
133extern uint32_t
134emlxs_diag_echo_run(emlxs_port_t *port, uint32_t did, uint32_t pattern)
135{
136 emlxs_hba_t *hba = HBA;
137 uint32_t i = 0;
138 uint32_t rval = FC_SUCCESS;
139 int32_t pkt_ret;
140 fc_packet_t *pkt;

--- 5 unchanged lines hidden (view full) ---

146 uint32_t *lptr;
147 NODELIST *ndlp;
148 uint8_t *pat;
149
150 /* Check did */
151 if (did == 0) {
152 did = port->did;
153 }
154
157 /* Check if device is ready */
158 if ((hba->state < FC_LINK_UP) || (port->did == 0)) {
159 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_diag_error_msg,
160 "ECHO: HBA not ready.");
161
162 return (FC_TRAN_BUSY);
163 }
155 /* Check if device is ready */
156 if ((hba->state < FC_LINK_UP) || (port->did == 0)) {
157 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_diag_error_msg,
158 "ECHO: HBA not ready.");
159
160 return (FC_TRAN_BUSY);
161 }
162
164 /* Check for the host node */
165 ndlp = emlxs_node_find_did(port, port->did);
166
167 if (!ndlp || !ndlp->nlp_active) {
168 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_diag_error_msg,
169 "ECHO: HBA not ready.");
170
171 return (FC_TRAN_BUSY);
172 }
163 /* Check for the host node */
164 ndlp = emlxs_node_find_did(port, port->did);
165
166 if (!ndlp || !ndlp->nlp_active) {
167 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_diag_error_msg,
168 "ECHO: HBA not ready.");
169
170 return (FC_TRAN_BUSY);
171 }
172
173 length = 124;
174
175 /* Prepare ECHO pkt */
176 if (!(pkt = emlxs_pkt_alloc(port, sizeof (uint32_t) + length,
177 sizeof (uint32_t) + length, 0, KM_NOSLEEP))) {
178 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_diag_error_msg,
179 "ECHO: Unable to allocate packet. size=%x",
180 sizeof (uint32_t) + length);
181
182 return (FC_NOMEM);
183 }
173 length = 124;
174
175 /* Prepare ECHO pkt */
176 if (!(pkt = emlxs_pkt_alloc(port, sizeof (uint32_t) + length,
177 sizeof (uint32_t) + length, 0, KM_NOSLEEP))) {
178 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_diag_error_msg,
179 "ECHO: Unable to allocate packet. size=%x",
180 sizeof (uint32_t) + length);
181
182 return (FC_NOMEM);
183 }
184
184 /* pkt initialization */
185 pkt->pkt_tran_type = FC_PKT_EXCHANGE;
186 pkt->pkt_timeout = 60;
187
188 /* Build the fc header */
189 pkt->pkt_cmd_fhdr.d_id = did;
190 pkt->pkt_cmd_fhdr.r_ctl = R_CTL_EXTENDED_SVC | R_CTL_UNSOL_CONTROL;
191 pkt->pkt_cmd_fhdr.s_id = port->did;
192 pkt->pkt_cmd_fhdr.type = FC_TYPE_EXTENDED_LS;
185 /* pkt initialization */
186 pkt->pkt_tran_type = FC_PKT_EXCHANGE;
187 pkt->pkt_timeout = 60;
188
189 /* Build the fc header */
190 pkt->pkt_cmd_fhdr.d_id = did;
191 pkt->pkt_cmd_fhdr.r_ctl = R_CTL_EXTENDED_SVC | R_CTL_UNSOL_CONTROL;
192 pkt->pkt_cmd_fhdr.s_id = port->did;
193 pkt->pkt_cmd_fhdr.type = FC_TYPE_EXTENDED_LS;
193 pkt->pkt_cmd_fhdr.f_ctl = F_CTL_FIRST_SEQ | F_CTL_SEQ_INITIATIVE |
194 F_CTL_END_SEQ;
194 pkt->pkt_cmd_fhdr.f_ctl =
195 F_CTL_FIRST_SEQ | F_CTL_SEQ_INITIATIVE | F_CTL_END_SEQ;
195 pkt->pkt_cmd_fhdr.seq_id = 0;
196 pkt->pkt_cmd_fhdr.df_ctl = 0;
197 pkt->pkt_cmd_fhdr.seq_cnt = 0;
198 pkt->pkt_cmd_fhdr.ox_id = 0xffff;
199 pkt->pkt_cmd_fhdr.rx_id = 0xffff;
200 pkt->pkt_cmd_fhdr.ro = 0;
201 pkt->pkt_comp = emlxs_diag_pkt_callback;
202
203 /* Build the command */
196 pkt->pkt_cmd_fhdr.seq_id = 0;
197 pkt->pkt_cmd_fhdr.df_ctl = 0;
198 pkt->pkt_cmd_fhdr.seq_cnt = 0;
199 pkt->pkt_cmd_fhdr.ox_id = 0xffff;
200 pkt->pkt_cmd_fhdr.rx_id = 0xffff;
201 pkt->pkt_cmd_fhdr.ro = 0;
202 pkt->pkt_comp = emlxs_diag_pkt_callback;
203
204 /* Build the command */
204 els = (ELS_PKT *)pkt->pkt_cmd;
205 els = (ELS_PKT *) pkt->pkt_cmd;
205 els->elsCode = 0x10;
206 pattern_buffer = (char *)els->un.pad;
207
208 if (pattern) {
209 /* Fill the transmit buffer with the pattern */
210 lptr = (uint32_t *)pattern_buffer;
211
212 for (i = 0; i < length; i += 4) {
213 *lptr++ = pattern;
214 }
215 } else {
216 /* Program the default echo pattern */
217 bzero(pattern_buffer, length);
206 els->elsCode = 0x10;
207 pattern_buffer = (char *)els->un.pad;
208
209 if (pattern) {
210 /* Fill the transmit buffer with the pattern */
211 lptr = (uint32_t *)pattern_buffer;
212
213 for (i = 0; i < length; i += 4) {
214 *lptr++ = pattern;
215 }
216 } else {
217 /* Program the default echo pattern */
218 bzero(pattern_buffer, length);
218 (void) sprintf(pattern_buffer, "Emulex. We network storage."
219 " Emulex. We network storage. Emulex. We network storage."
220 " Emulex. We network storage.");
219 (void) sprintf(pattern_buffer, "Emulex. We network storage. "
220 "Emulex. We network storage. Emulex. We network storage. "
221 "Emulex. We network storage.");
221 }
222
223 /* Send ECHO pkt */
224 if ((rval = emlxs_pkt_send(pkt, 1)) != FC_SUCCESS) {
225 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_diag_error_msg,
226 "ECHO: Packet send failed.");
227
228 goto done;
229 }
222 }
223
224 /* Send ECHO pkt */
225 if ((rval = emlxs_pkt_send(pkt, 1)) != FC_SUCCESS) {
226 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_diag_error_msg,
227 "ECHO: Packet send failed.");
228
229 goto done;
230 }
231
230 /* Wait for ECHO completion */
231 mutex_enter(&EMLXS_PKT_LOCK);
232 timeout = emlxs_timeout(hba, (pkt->pkt_timeout + 15));
233 pkt_ret = 0;
234 while ((pkt_ret != -1) && !(pkt->pkt_tran_flags & FC_TRAN_COMPLETED)) {
232 /* Wait for ECHO completion */
233 mutex_enter(&EMLXS_PKT_LOCK);
234 timeout = emlxs_timeout(hba, (pkt->pkt_timeout + 15));
235 pkt_ret = 0;
236 while ((pkt_ret != -1) && !(pkt->pkt_tran_flags & FC_TRAN_COMPLETED)) {
235 pkt_ret = cv_timedwait(&EMLXS_PKT_CV, &EMLXS_PKT_LOCK, timeout);
237 pkt_ret =
238 cv_timedwait(&EMLXS_PKT_CV, &EMLXS_PKT_LOCK, timeout);
236
237 }
238 mutex_exit(&EMLXS_PKT_LOCK);
239
240 if (pkt_ret == -1) {
241 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_echo_failed_msg,
242 "Packet timed out.");
243
244 return (FC_ABORTED);
245 }
239
240 }
241 mutex_exit(&EMLXS_PKT_LOCK);
242
243 if (pkt_ret == -1) {
244 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_echo_failed_msg,
245 "Packet timed out.");
246
247 return (FC_ABORTED);
248 }
249
246 if (pkt->pkt_state != FC_PKT_SUCCESS) {
247 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_echo_failed_msg,
248 "Transport error.");
249
250 rval = FC_TRANSPORT_ERROR;
251 goto done;
252 }
250 if (pkt->pkt_state != FC_PKT_SUCCESS) {
251 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_echo_failed_msg,
252 "Transport error.");
253
254 rval = FC_TRANSPORT_ERROR;
255 goto done;
256 }
257
253 /* Check response payload */
254 pkt_resp = (uint8_t *)pkt->pkt_resp + 4;
255 pat = (uint8_t *)pattern_buffer;
256 rval = FC_SUCCESS;
257
258 for (i = 0; i < length; i++, pkt_resp++, pat++) {
259 if (*pkt_resp != *pat) {
260 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_echo_failed_msg,
261 "Data miscompare. did=%06x length=%d. Offset %d "
258 /* Check response payload */
259 pkt_resp = (uint8_t *)pkt->pkt_resp + 4;
260 pat = (uint8_t *)pattern_buffer;
261 rval = FC_SUCCESS;
262
263 for (i = 0; i < length; i++, pkt_resp++, pat++) {
264 if (*pkt_resp != *pat) {
265 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_echo_failed_msg,
266 "Data miscompare. did=%06x length=%d. Offset %d "
262 "value %02x should be %02x.",
263 did, length, i, *pkt_resp, *pat);
267 "value %02x should be %02x.", did, length, i,
268 *pkt_resp, *pat);
264
265 rval = EMLXS_TEST_FAILED;
266
267 break;
268 }
269 }
270
271 if (rval == FC_SUCCESS) {
272 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_echo_complete_msg,
273 "did=%06x length=%d pattern=%02x,%02x,%02x,%02x...",
274 did, length, pattern_buffer[0] & 0xff,
275 pattern_buffer[1] & 0xff, pattern_buffer[2] & 0xff,
276 pattern_buffer[3] & 0xff);
277 }
269
270 rval = EMLXS_TEST_FAILED;
271
272 break;
273 }
274 }
275
276 if (rval == FC_SUCCESS) {
277 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_echo_complete_msg,
278 "did=%06x length=%d pattern=%02x,%02x,%02x,%02x...",
279 did, length, pattern_buffer[0] & 0xff,
280 pattern_buffer[1] & 0xff, pattern_buffer[2] & 0xff,
281 pattern_buffer[3] & 0xff);
282 }
283
278done:
279
280 /* Free the echo pkt */
281 emlxs_pkt_free(pkt);
282
283 return (rval);
284
284done:
285
286 /* Free the echo pkt */
287 emlxs_pkt_free(pkt);
288
289 return (rval);
290
285} /* emlxs_diag_echo_run() */
291} /* emlxs_diag_echo_run() */
286
287
288extern uint32_t
289emlxs_diag_biu_run(emlxs_hba_t *hba, uint32_t pattern)
290{
291 emlxs_port_t *port = &PPORT;
292 MAILBOX *mb;
293 MATCHMAP *mp;

--- 9 unchanged lines hidden (view full) ---

303
304 /* Check if device is ready */
305 if (hba->state < FC_LINK_DOWN) {
306 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_diag_error_msg,
307 "BIU: HBA not ready.");
308
309 return (FC_TRAN_BUSY);
310 }
292
293
294extern uint32_t
295emlxs_diag_biu_run(emlxs_hba_t *hba, uint32_t pattern)
296{
297 emlxs_port_t *port = &PPORT;
298 MAILBOX *mb;
299 MATCHMAP *mp;

--- 9 unchanged lines hidden (view full) ---

309
310 /* Check if device is ready */
311 if (hba->state < FC_LINK_DOWN) {
312 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_diag_error_msg,
313 "BIU: HBA not ready.");
314
315 return (FC_TRAN_BUSY);
316 }
317
311 /*
312 * Get a buffer which will be used for the mailbox command
313 */
314 if ((mb = (MAILBOX *) emlxs_mem_get(hba, MEM_MBOX | MEM_PRI)) == 0) {
315 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_diag_error_msg,
316 "BIU: Mailbox allocation failed.");
317
318 rval = FC_NOMEM;
319 goto done;
320 }
318 /*
319 * Get a buffer which will be used for the mailbox command
320 */
321 if ((mb = (MAILBOX *) emlxs_mem_get(hba, MEM_MBOX | MEM_PRI)) == 0) {
322 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_diag_error_msg,
323 "BIU: Mailbox allocation failed.");
324
325 rval = FC_NOMEM;
326 goto done;
327 }
328
321 /*
322 * Setup and issue mailbox RUN BIU DIAG command Setup test buffers
323 */
329 /*
330 * Setup and issue mailbox RUN BIU DIAG command Setup test buffers
331 */
324 if (((mp = (MATCHMAP *)emlxs_mem_get(hba, MEM_BUF | MEM_PRI)) == 0) ||
325 ((mp1 = (MATCHMAP *)emlxs_mem_get(hba, MEM_BUF | MEM_PRI)) == 0)) {
332 if (((mp = (MATCHMAP *) emlxs_mem_get(hba, MEM_BUF | MEM_PRI)) == 0) ||
333 ((mp1 = (MATCHMAP *) emlxs_mem_get(hba, MEM_BUF | MEM_PRI)) == 0)) {
326 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_diag_error_msg,
327 "BIU: Buffer allocation failed.");
328
329 rval = FC_NOMEM;
330 goto done;
331 }
334 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_diag_error_msg,
335 "BIU: Buffer allocation failed.");
336
337 rval = FC_NOMEM;
338 goto done;
339 }
340
332 if (pattern) {
333 /* Fill the transmit buffer with the pattern */
334 lptr = (uint32_t *)mp->virt;
335
336 for (i = 0; i < MEM_ELSBUF_SIZE; i += 4) {
337 *lptr++ = pattern;
338 }
339 } else {

--- 6 unchanged lines hidden (view full) ---

346
347 bzero(mp1->virt, MEM_ELSBUF_SIZE);
348 emlxs_mpdata_sync(mp1->dma_handle, 0, MEM_ELSBUF_SIZE,
349 DDI_DMA_SYNC_FORDEV);
350
351 /* Create the biu diag request */
352 (void) emlxs_mb_run_biu_diag(hba, mb, mp->phys, mp1->phys);
353
341 if (pattern) {
342 /* Fill the transmit buffer with the pattern */
343 lptr = (uint32_t *)mp->virt;
344
345 for (i = 0; i < MEM_ELSBUF_SIZE; i += 4) {
346 *lptr++ = pattern;
347 }
348 } else {

--- 6 unchanged lines hidden (view full) ---

355
356 bzero(mp1->virt, MEM_ELSBUF_SIZE);
357 emlxs_mpdata_sync(mp1->dma_handle, 0, MEM_ELSBUF_SIZE,
358 DDI_DMA_SYNC_FORDEV);
359
360 /* Create the biu diag request */
361 (void) emlxs_mb_run_biu_diag(hba, mb, mp->phys, mp1->phys);
362
354 rval = emlxs_mb_issue_cmd(hba, mb, MBX_WAIT, 60);
363 rval = emlxs_sli_issue_mbox_cmd(hba, mb, MBX_WAIT, 60);
355
356 if (rval == MBX_TIMEOUT) {
357 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_biu_failed_msg,
358 "BUI diagnostic timed out.");
359
360 rval = EMLXS_TEST_FAILED;
361 goto done;
362 }
364
365 if (rval == MBX_TIMEOUT) {
366 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_biu_failed_msg,
367 "BUI diagnostic timed out.");
368
369 rval = EMLXS_TEST_FAILED;
370 goto done;
371 }
372
363 emlxs_mpdata_sync(mp1->dma_handle, 0, MEM_ELSBUF_SIZE,
364 DDI_DMA_SYNC_FORKERNEL);
365
366 outptr = mp->virt;
367 inptr = mp1->virt;
368
369 for (i = 0; i < MEM_ELSBUF_SIZE; i++, outptr++, inptr++) {
370 if (*outptr != *inptr) {
371 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_biu_failed_msg,
373 emlxs_mpdata_sync(mp1->dma_handle, 0, MEM_ELSBUF_SIZE,
374 DDI_DMA_SYNC_FORKERNEL);
375
376 outptr = mp->virt;
377 inptr = mp1->virt;
378
379 for (i = 0; i < MEM_ELSBUF_SIZE; i++, outptr++, inptr++) {
380 if (*outptr != *inptr) {
381 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_biu_failed_msg,
372 "Data miscompare. Offset %d value %02x "
373 "should be %02x.",
374 i, *inptr, *outptr);
382 "Data miscompare. Offset %d value %02x should "
383 "be %02x.", i, *inptr, *outptr);
375
376 rval = EMLXS_TEST_FAILED;
377 goto done;
378 }
379 }
380
381 /* Wait half second before returning */
382 delay(drv_usectohz(500000));
383 rval = FC_SUCCESS;
384
385 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_biu_complete_msg, "Status Good.");
386
387done:
388
384
385 rval = EMLXS_TEST_FAILED;
386 goto done;
387 }
388 }
389
390 /* Wait half second before returning */
391 delay(drv_usectohz(500000));
392 rval = FC_SUCCESS;
393
394 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_biu_complete_msg, "Status Good.");
395
396done:
397
389 if (mp)
398 if (mp) {
390 (void) emlxs_mem_put(hba, MEM_BUF, (uint8_t *)mp);
399 (void) emlxs_mem_put(hba, MEM_BUF, (uint8_t *)mp);
391 if (mp1)
400 }
401 if (mp1) {
392 (void) emlxs_mem_put(hba, MEM_BUF, (uint8_t *)mp1);
402 (void) emlxs_mem_put(hba, MEM_BUF, (uint8_t *)mp1);
393 if (mb)
403 }
404 if (mb) {
394 (void) emlxs_mem_put(hba, MEM_MBOX, (uint8_t *)mb);
405 (void) emlxs_mem_put(hba, MEM_MBOX, (uint8_t *)mb);
406 }
395
396 return (rval);
397
407
408 return (rval);
409
398} /* emlxs_diag_biu_run() */
410} /* emlxs_diag_biu_run() */
399
400
411
412
401
402extern uint32_t
403emlxs_diag_post_run(emlxs_hba_t *hba)
404{
405 emlxs_port_t *port = &PPORT;
406 uint32_t rval = FC_SUCCESS;
407
408 if (hba->flag & (FC_OFFLINE_MODE | FC_OFFLINING_MODE)) {
409 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_diag_error_msg,
410 "POST: HBA shutdown.");
411
412 return (FC_TRAN_BUSY);
413 }
413extern uint32_t
414emlxs_diag_post_run(emlxs_hba_t *hba)
415{
416 emlxs_port_t *port = &PPORT;
417 uint32_t rval = FC_SUCCESS;
418
419 if (hba->flag & (FC_OFFLINE_MODE | FC_OFFLINING_MODE)) {
420 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_diag_error_msg,
421 "POST: HBA shutdown.");
422
423 return (FC_TRAN_BUSY);
424 }
425
414 /* Take board offline */
415 if ((rval = emlxs_offline(hba))) {
416 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_post_failed_msg,
417 "Unable to take adapter offline.");
418
419 rval = FC_RESETFAIL;
420 }
426 /* Take board offline */
427 if ((rval = emlxs_offline(hba))) {
428 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_post_failed_msg,
429 "Unable to take adapter offline.");
430
431 rval = FC_RESETFAIL;
432 }
433
421 /* Restart the adapter */
434 /* Restart the adapter */
422 rval = emlxs_hba_reset(hba, 1, 1);
435 rval = emlxs_sli_hba_reset(hba, 1, 1);
423
424 switch (rval) {
425 case 0:
426
427 (void) emlxs_online(hba);
428
429 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_post_complete_msg,
430 "Status good.");

--- 20 unchanged lines hidden (view full) ---

451 rval = FC_STATEC_BUSY;
452
453 break;
454
455 }
456
457 return (rval);
458
436
437 switch (rval) {
438 case 0:
439
440 (void) emlxs_online(hba);
441
442 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_post_complete_msg,
443 "Status good.");

--- 20 unchanged lines hidden (view full) ---

464 rval = FC_STATEC_BUSY;
465
466 break;
467
468 }
469
470 return (rval);
471
459} /* emlxs_diag_post_run() */
472} /* emlxs_diag_post_run() */
460
461
462/* ARGSUSED */
463extern uint32_t
464emlxs_core_size(emlxs_hba_t *hba)
465{
473
474
475/* ARGSUSED */
476extern uint32_t
477emlxs_core_size(emlxs_hba_t *hba)
478{
479
466 return (256);
467
480 return (256);
481
468} /* emlxs_core_size() */
469
470
482
483
484} /* emlxs_core_size() */
485
486
471/* ARGSUSED */
472extern uint32_t
473emlxs_core_dump(emlxs_hba_t *hba, char *buffer, uint32_t size)
474{
475 uint32_t i;
476
477 bzero(buffer, size);
478
479 /* Fill the buffer with dummy data */
480 for (i = 0; i < 256; i++) {
481 buffer[i] = (char)(i & 0xff);
482 }
483 return (FC_SUCCESS);
484
487/* ARGSUSED */
488extern uint32_t
489emlxs_core_dump(emlxs_hba_t *hba, char *buffer, uint32_t size)
490{
491 uint32_t i;
492
493 bzero(buffer, size);
494
495 /* Fill the buffer with dummy data */
496 for (i = 0; i < 256; i++) {
497 buffer[i] = (char)(i & 0xff);
498 }
499 return (FC_SUCCESS);
500
485} /* emlxs_core_dump() */
501
502
503} /* emlxs_core_dump() */