Print this page
XXXX introduce drv_sectohz


4351 
4352 } /* emlxs_dfc_get_drvstats() */
4353 
4354 
4355 extern uint32_t
4356 emlxs_set_hba_mode(emlxs_hba_t *hba, uint32_t mode)
4357 {
4358         emlxs_port_t    *port = &PPORT;
4359         uint32_t        i;
4360 
4361         mutex_enter(&EMLXS_PORT_LOCK);
4362 
4363         /* Wait if adapter is in transition */
4364         i = 0;
4365         while ((hba->flag & (FC_ONLINING_MODE | FC_OFFLINING_MODE))) {
4366                 if (i++ > 30) {
4367                         break;
4368                 }
4369 
4370                 mutex_exit(&EMLXS_PORT_LOCK);
4371                 delay(drv_usectohz(1000000));
4372                 mutex_enter(&EMLXS_PORT_LOCK);
4373         }
4374 
4375         if (hba->sli_mode <= EMLXS_HBA_SLI3_MODE) {
4376                 switch (mode) {
4377                 case DDI_SHOW:
4378                         break;
4379 
4380                 case DDI_ONDI:
4381                         if (hba->flag & FC_OFFLINE_MODE) {
4382                                 mutex_exit(&EMLXS_PORT_LOCK);
4383                                 (void) emlxs_online(hba);
4384                                 mutex_enter(&EMLXS_PORT_LOCK);
4385                         }
4386                         break;
4387 
4388 
4389                 /* Killed + Restart state */
4390                 case DDI_OFFDI:
4391                         if (hba->flag & FC_ONLINE_MODE) {


4446                                 mutex_enter(&EMLXS_PORT_LOCK);
4447                         }
4448 
4449                         break;
4450 
4451                 default:
4452                         EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
4453                             "set_hba_mode: Invalid mode. mode=%x", mode);
4454                         mutex_exit(&EMLXS_PORT_LOCK);
4455                         return (0);
4456                 }
4457 
4458                 /* Wait if adapter is in transition */
4459                 i = 0;
4460                 while ((hba->flag & (FC_ONLINING_MODE | FC_OFFLINING_MODE))) {
4461                         if (i++ > 30) {
4462                                 break;
4463                         }
4464 
4465                         mutex_exit(&EMLXS_PORT_LOCK);
4466                         delay(drv_usectohz(1000000));
4467                         mutex_enter(&EMLXS_PORT_LOCK);
4468                 }
4469 
4470                 /* Return current state */
4471                 if (hba->flag & FC_ONLINE_MODE) {
4472                         mode = DDI_ONDI;
4473                 } else if (hba->state == FC_KILLED) {
4474                         mode = DDI_DIAGDI;
4475                 } else if (hba->state == FC_WARM_START) {
4476                         mode = DDI_WARMDI;
4477                 } else {
4478                         mode = DDI_OFFDI;
4479                 }
4480 
4481                 mutex_exit(&EMLXS_PORT_LOCK);
4482 
4483                 return (mode);
4484 
4485         } else { /* SLI4 */
4486                 switch (mode) {


4529                             EMLXS_DFC_RESET_ALL_FORCE_DUMP);
4530 
4531                         return (mode);
4532 
4533                 case DDI_WARMDI:
4534                 default:
4535                         EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
4536                             "set_hba_mode: Invalid mode. mode=%x", mode);
4537                         mutex_exit(&EMLXS_PORT_LOCK);
4538                         return (0);
4539                 }
4540 
4541                 /* Wait if adapter is in transition */
4542                 i = 0;
4543                 while ((hba->flag & (FC_ONLINING_MODE | FC_OFFLINING_MODE))) {
4544                         if (i++ > 30) {
4545                                 break;
4546                         }
4547 
4548                         mutex_exit(&EMLXS_PORT_LOCK);
4549                         delay(drv_usectohz(1000000));
4550                         mutex_enter(&EMLXS_PORT_LOCK);
4551                 }
4552 
4553                 /* Return current state */
4554                 if (hba->flag & FC_ONLINE_MODE) {
4555                         mode = DDI_ONDI;
4556                 } else {
4557                         mode = DDI_OFFDI;
4558                 }
4559 
4560                 mutex_exit(&EMLXS_PORT_LOCK);
4561 
4562                 return (mode);
4563         }
4564 
4565 } /* emlxs_set_hba_mode() */
4566 
4567 
4568 /*ARGSUSED*/
4569 static int32_t


8307         /* CLEAR MENLO maint mode */
8308         /* Create the set_variable mailbox request */
8309         emlxs_mb_set_var(hba, mbq, 0x103107, 0);
8310 
8311         mbq->flag |= MBQ_PASSTHRU;
8312 
8313         /* issue the mbox cmd to the sli */
8314         mbxstatus = EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbq, MBX_WAIT, 0);
8315 
8316         if (mbxstatus) {
8317                 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
8318                     "%s: %s failed. mbxstatus=0x%x",
8319                     emlxs_dfc_xlate(EMLXS_LOOPBACK_MODE),
8320                     emlxs_mb_cmd_xlate(mb->mbxCommand), mbxstatus);
8321 
8322                 rval = DFC_IO_ERROR;
8323                 if (mbxstatus == MBX_TIMEOUT)
8324                         rval = DFC_TIMEOUT;
8325         }
8326 
8327         delay(drv_usectohz(1000000));
8328         i = 0;
8329         while ((hba->state < FC_LINK_UP) && (hba->state != FC_ERROR)) {
8330                 delay(drv_usectohz(100000));
8331                 i++;
8332 
8333                 if (i == 300) {
8334                         rval = DFC_TIMEOUT;
8335 
8336                         EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
8337                             "%s: Linkup timeout.",
8338                             emlxs_dfc_xlate(EMLXS_LOOPBACK_MODE));
8339 
8340                         goto done;
8341                 }
8342         }
8343 
8344 done:
8345         /* Free allocated mbox memory */
8346         if (mbq) {
8347                 kmem_free(mbq, sizeof (MAILBOXQ));




4351 
4352 } /* emlxs_dfc_get_drvstats() */
4353 
4354 
4355 extern uint32_t
4356 emlxs_set_hba_mode(emlxs_hba_t *hba, uint32_t mode)
4357 {
4358         emlxs_port_t    *port = &PPORT;
4359         uint32_t        i;
4360 
4361         mutex_enter(&EMLXS_PORT_LOCK);
4362 
4363         /* Wait if adapter is in transition */
4364         i = 0;
4365         while ((hba->flag & (FC_ONLINING_MODE | FC_OFFLINING_MODE))) {
4366                 if (i++ > 30) {
4367                         break;
4368                 }
4369 
4370                 mutex_exit(&EMLXS_PORT_LOCK);
4371                 delay(drv_sectohz(1));
4372                 mutex_enter(&EMLXS_PORT_LOCK);
4373         }
4374 
4375         if (hba->sli_mode <= EMLXS_HBA_SLI3_MODE) {
4376                 switch (mode) {
4377                 case DDI_SHOW:
4378                         break;
4379 
4380                 case DDI_ONDI:
4381                         if (hba->flag & FC_OFFLINE_MODE) {
4382                                 mutex_exit(&EMLXS_PORT_LOCK);
4383                                 (void) emlxs_online(hba);
4384                                 mutex_enter(&EMLXS_PORT_LOCK);
4385                         }
4386                         break;
4387 
4388 
4389                 /* Killed + Restart state */
4390                 case DDI_OFFDI:
4391                         if (hba->flag & FC_ONLINE_MODE) {


4446                                 mutex_enter(&EMLXS_PORT_LOCK);
4447                         }
4448 
4449                         break;
4450 
4451                 default:
4452                         EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
4453                             "set_hba_mode: Invalid mode. mode=%x", mode);
4454                         mutex_exit(&EMLXS_PORT_LOCK);
4455                         return (0);
4456                 }
4457 
4458                 /* Wait if adapter is in transition */
4459                 i = 0;
4460                 while ((hba->flag & (FC_ONLINING_MODE | FC_OFFLINING_MODE))) {
4461                         if (i++ > 30) {
4462                                 break;
4463                         }
4464 
4465                         mutex_exit(&EMLXS_PORT_LOCK);
4466                         delay(drv_sectohz(1));
4467                         mutex_enter(&EMLXS_PORT_LOCK);
4468                 }
4469 
4470                 /* Return current state */
4471                 if (hba->flag & FC_ONLINE_MODE) {
4472                         mode = DDI_ONDI;
4473                 } else if (hba->state == FC_KILLED) {
4474                         mode = DDI_DIAGDI;
4475                 } else if (hba->state == FC_WARM_START) {
4476                         mode = DDI_WARMDI;
4477                 } else {
4478                         mode = DDI_OFFDI;
4479                 }
4480 
4481                 mutex_exit(&EMLXS_PORT_LOCK);
4482 
4483                 return (mode);
4484 
4485         } else { /* SLI4 */
4486                 switch (mode) {


4529                             EMLXS_DFC_RESET_ALL_FORCE_DUMP);
4530 
4531                         return (mode);
4532 
4533                 case DDI_WARMDI:
4534                 default:
4535                         EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
4536                             "set_hba_mode: Invalid mode. mode=%x", mode);
4537                         mutex_exit(&EMLXS_PORT_LOCK);
4538                         return (0);
4539                 }
4540 
4541                 /* Wait if adapter is in transition */
4542                 i = 0;
4543                 while ((hba->flag & (FC_ONLINING_MODE | FC_OFFLINING_MODE))) {
4544                         if (i++ > 30) {
4545                                 break;
4546                         }
4547 
4548                         mutex_exit(&EMLXS_PORT_LOCK);
4549                         delay(drv_sectohz(1));
4550                         mutex_enter(&EMLXS_PORT_LOCK);
4551                 }
4552 
4553                 /* Return current state */
4554                 if (hba->flag & FC_ONLINE_MODE) {
4555                         mode = DDI_ONDI;
4556                 } else {
4557                         mode = DDI_OFFDI;
4558                 }
4559 
4560                 mutex_exit(&EMLXS_PORT_LOCK);
4561 
4562                 return (mode);
4563         }
4564 
4565 } /* emlxs_set_hba_mode() */
4566 
4567 
4568 /*ARGSUSED*/
4569 static int32_t


8307         /* CLEAR MENLO maint mode */
8308         /* Create the set_variable mailbox request */
8309         emlxs_mb_set_var(hba, mbq, 0x103107, 0);
8310 
8311         mbq->flag |= MBQ_PASSTHRU;
8312 
8313         /* issue the mbox cmd to the sli */
8314         mbxstatus = EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbq, MBX_WAIT, 0);
8315 
8316         if (mbxstatus) {
8317                 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
8318                     "%s: %s failed. mbxstatus=0x%x",
8319                     emlxs_dfc_xlate(EMLXS_LOOPBACK_MODE),
8320                     emlxs_mb_cmd_xlate(mb->mbxCommand), mbxstatus);
8321 
8322                 rval = DFC_IO_ERROR;
8323                 if (mbxstatus == MBX_TIMEOUT)
8324                         rval = DFC_TIMEOUT;
8325         }
8326 
8327         delay(drv_sectohz(1));
8328         i = 0;
8329         while ((hba->state < FC_LINK_UP) && (hba->state != FC_ERROR)) {
8330                 delay(drv_usectohz(100000));
8331                 i++;
8332 
8333                 if (i == 300) {
8334                         rval = DFC_TIMEOUT;
8335 
8336                         EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
8337                             "%s: Linkup timeout.",
8338                             emlxs_dfc_xlate(EMLXS_LOOPBACK_MODE));
8339 
8340                         goto done;
8341                 }
8342         }
8343 
8344 done:
8345         /* Free allocated mbox memory */
8346         if (mbq) {
8347                 kmem_free(mbq, sizeof (MAILBOXQ));