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