1 /*- 2 * Copyright (c) 2018 Microsemi Corporation. 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 */ 26 27 /* $FreeBSD$ */ 28 29 #include "smartpqi_includes.h" 30 31 /* Validate the scsi sense response code */ 32 static inline boolean_t pqisrc_scsi_sense_valid(const struct sense_header_scsi *sshdr) 33 { 34 DBG_FUNC("IN\n"); 35 36 if (!sshdr) 37 return false; 38 39 DBG_FUNC("OUT\n"); 40 41 return (sshdr->response_code & 0x70) == 0x70; 42 } 43 44 /* Update scsi sense info to a local buffer*/ 45 boolean_t pqisrc_update_scsi_sense(const uint8_t *buff, int len, 46 struct sense_header_scsi *header) 47 { 48 49 DBG_FUNC("IN\n"); 50 51 if (!buff || !len) 52 return false; 53 54 memset(header, 0, sizeof(struct sense_header_scsi)); 55 56 header->response_code = (buff[0] & 0x7f); 57 58 if (!pqisrc_scsi_sense_valid(header)) 59 return false; 60 61 if (header->response_code >= 0x72) { 62 /* descriptor format */ 63 if (len > 1) 64 header->sense_key = (buff[1] & 0xf); 65 if (len > 2) 66 header->asc = buff[2]; 67 if (len > 3) 68 header->ascq = buff[3]; 69 if (len > 7) 70 header->additional_length = buff[7]; 71 } else { 72 /* fixed format */ 73 if (len > 2) 74 header->sense_key = (buff[2] & 0xf); 75 if (len > 7) { 76 len = (len < (buff[7] + 8)) ? 77 len : (buff[7] + 8); 78 if (len > 12) 79 header->asc = buff[12]; 80 if (len > 13) 81 header->ascq = buff[13]; 82 } 83 } 84 85 DBG_FUNC("OUT\n"); 86 87 return true; 88 } 89 90 /* 91 * Function used to build the internal raid request and analyze the response 92 */ 93 int pqisrc_build_send_raid_request(pqisrc_softstate_t *softs, pqisrc_raid_req_t *request, 94 void *buff, size_t datasize, uint8_t cmd, uint16_t vpd_page, uint8_t *scsi3addr, 95 raid_path_error_info_elem_t *error_info) 96 { 97 98 uint8_t *cdb; 99 int ret = PQI_STATUS_SUCCESS; 100 uint32_t tag = 0; 101 struct dma_mem device_mem; 102 sgt_t *sgd; 103 104 ib_queue_t *ib_q = &softs->op_raid_ib_q[PQI_DEFAULT_IB_QUEUE]; 105 ob_queue_t *ob_q = &softs->op_ob_q[PQI_DEFAULT_IB_QUEUE]; 106 107 rcb_t *rcb = NULL; 108 109 DBG_FUNC("IN\n"); 110 111 memset(&device_mem, 0, sizeof(struct dma_mem)); 112 113 /* for TUR datasize: 0 buff: NULL */ 114 if (datasize) { 115 device_mem.tag = "device_mem"; 116 device_mem.size = datasize; 117 device_mem.align = PQISRC_DEFAULT_DMA_ALIGN; 118 119 ret = os_dma_mem_alloc(softs, &device_mem); 120 121 if (ret) { 122 DBG_ERR("failed to allocate dma memory for device_mem return code %d\n", ret); 123 return ret; 124 } 125 126 sgd = (sgt_t *)&request->sg_descriptors[0]; 127 128 sgd->addr = device_mem.dma_addr; 129 sgd->len = datasize; 130 sgd->flags = SG_FLAG_LAST; 131 132 } 133 134 /* Build raid path request */ 135 request->header.iu_type = PQI_IU_TYPE_RAID_PATH_IO_REQUEST; 136 137 request->header.iu_length = LE_16(offsetof(pqisrc_raid_req_t, 138 sg_descriptors[1]) - PQI_REQUEST_HEADER_LENGTH); 139 request->buffer_length = LE_32(datasize); 140 memcpy(request->lun_number, scsi3addr, sizeof(request->lun_number)); 141 request->task_attribute = SOP_TASK_ATTRIBUTE_SIMPLE; 142 request->additional_cdb_bytes_usage = PQI_ADDITIONAL_CDB_BYTES_0; 143 144 cdb = request->cdb; 145 146 switch (cmd) { 147 case SA_INQUIRY: 148 request->data_direction = SOP_DATA_DIR_TO_DEVICE; 149 cdb[0] = SA_INQUIRY; 150 if (vpd_page & VPD_PAGE) { 151 cdb[1] = 0x1; 152 cdb[2] = (uint8_t)vpd_page; 153 } 154 cdb[4] = (uint8_t)datasize; 155 break; 156 case SA_REPORT_LOG: 157 case SA_REPORT_PHYS: 158 request->data_direction = SOP_DATA_DIR_TO_DEVICE; 159 cdb[0] = cmd; 160 if (cmd == SA_REPORT_PHYS) 161 cdb[1] = SA_REPORT_PHYS_EXTENDED; 162 else 163 cdb[1] = SA_REPORT_LOG_EXTENDED; 164 cdb[8] = (uint8_t)((datasize) >> 8); 165 cdb[9] = (uint8_t)datasize; 166 break; 167 case TEST_UNIT_READY: 168 request->data_direction = SOP_DATA_DIR_NONE; 169 break; 170 case SA_GET_RAID_MAP: 171 request->data_direction = SOP_DATA_DIR_TO_DEVICE; 172 cdb[0] = SA_CISS_READ; 173 cdb[1] = cmd; 174 cdb[8] = (uint8_t)((datasize) >> 8); 175 cdb[9] = (uint8_t)datasize; 176 break; 177 case SA_CACHE_FLUSH: 178 request->data_direction = SOP_DATA_DIR_FROM_DEVICE; 179 cdb[0] = BMIC_WRITE; 180 cdb[6] = BMIC_CACHE_FLUSH; 181 cdb[7] = (uint8_t)((datasize) << 8); 182 cdb[8] = (uint8_t)((datasize) >> 8); 183 break; 184 case BMIC_IDENTIFY_CONTROLLER: 185 case BMIC_IDENTIFY_PHYSICAL_DEVICE: 186 request->data_direction = SOP_DATA_DIR_TO_DEVICE; 187 cdb[0] = BMIC_READ; 188 cdb[6] = cmd; 189 cdb[7] = (uint8_t)((datasize) << 8); 190 cdb[8] = (uint8_t)((datasize) >> 8); 191 break; 192 case BMIC_WRITE_HOST_WELLNESS: 193 request->data_direction = SOP_DATA_DIR_FROM_DEVICE; 194 memcpy(device_mem.virt_addr, buff, datasize); 195 cdb[0] = BMIC_WRITE; 196 cdb[6] = cmd; 197 cdb[7] = (uint8_t)((datasize) << 8); 198 cdb[8] = (uint8_t)((datasize) >> 8); 199 break; 200 case BMIC_SENSE_SUBSYSTEM_INFORMATION: 201 request->data_direction = SOP_DATA_DIR_TO_DEVICE; 202 cdb[0] = BMIC_READ; 203 cdb[6] = cmd; 204 cdb[7] = (uint8_t)((datasize) << 8); 205 cdb[8] = (uint8_t)((datasize) >> 8); 206 break; 207 default: 208 DBG_ERR("unknown command 0x%x", cmd); 209 break; 210 } 211 212 tag = pqisrc_get_tag(&softs->taglist); 213 if (INVALID_ELEM == tag) { 214 DBG_ERR("Tag not available\n"); 215 ret = PQI_STATUS_FAILURE; 216 goto err_notag; 217 } 218 219 ((pqisrc_raid_req_t *)request)->request_id = tag; 220 ((pqisrc_raid_req_t *)request)->error_index = ((pqisrc_raid_req_t *)request)->request_id; 221 ((pqisrc_raid_req_t *)request)->response_queue_id = ob_q->q_id; 222 rcb = &softs->rcb[tag]; 223 rcb->success_cmp_callback = pqisrc_process_internal_raid_response_success; 224 rcb->error_cmp_callback = pqisrc_process_internal_raid_response_error; 225 226 rcb->req_pending = true; 227 rcb->tag = tag; 228 /* Submit Command */ 229 ret = pqisrc_submit_cmnd(softs, ib_q, request); 230 231 if (ret != PQI_STATUS_SUCCESS) { 232 DBG_ERR("Unable to submit command\n"); 233 goto err_out; 234 } 235 236 ret = pqisrc_wait_on_condition(softs, rcb); 237 if (ret != PQI_STATUS_SUCCESS) { 238 DBG_ERR("Internal RAID request timed out: cmd : 0x%c\n", cmd); 239 goto err_out; 240 } 241 242 if (datasize) { 243 if (buff) { 244 memcpy(buff, device_mem.virt_addr, datasize); 245 } 246 os_dma_mem_free(softs, &device_mem); 247 } 248 249 ret = rcb->status; 250 if (ret) { 251 if(error_info) { 252 memcpy(error_info, 253 rcb->error_info, 254 sizeof(*error_info)); 255 256 if (error_info->data_out_result == 257 PQI_RAID_DATA_IN_OUT_UNDERFLOW) { 258 ret = PQI_STATUS_SUCCESS; 259 } 260 else{ 261 DBG_INFO("Error!! Bus=%u Target=%u, Cmd=0x%x," 262 "Ret=%d\n", BMIC_GET_LEVEL_2_BUS(scsi3addr), 263 BMIC_GET_LEVEL_TWO_TARGET(scsi3addr), 264 cmd, ret); 265 ret = PQI_STATUS_FAILURE; 266 } 267 } 268 } else { 269 if(error_info) { 270 ret = PQI_STATUS_SUCCESS; 271 memset(error_info, 0, sizeof(*error_info)); 272 } 273 } 274 275 os_reset_rcb(rcb); 276 pqisrc_put_tag(&softs->taglist, ((pqisrc_raid_req_t *)request)->request_id); 277 DBG_FUNC("OUT\n"); 278 return ret; 279 280 err_out: 281 DBG_ERR("Error!! Bus=%u Target=%u, Cmd=0x%x, Ret=%d\n", 282 BMIC_GET_LEVEL_2_BUS(scsi3addr), BMIC_GET_LEVEL_TWO_TARGET(scsi3addr), 283 cmd, ret); 284 os_reset_rcb(rcb); 285 pqisrc_put_tag(&softs->taglist, ((pqisrc_raid_req_t *)request)->request_id); 286 err_notag: 287 if (datasize) 288 os_dma_mem_free(softs, &device_mem); 289 DBG_FUNC("FAILED \n"); 290 return ret; 291 } 292 293 /* common function used to send report physical and logical luns cmnds*/ 294 static int pqisrc_report_luns(pqisrc_softstate_t *softs, uint8_t cmd, 295 void *buff, size_t buf_len) 296 { 297 int ret; 298 pqisrc_raid_req_t request; 299 300 DBG_FUNC("IN\n"); 301 302 memset(&request, 0, sizeof(request)); 303 ret = pqisrc_build_send_raid_request(softs, &request, buff, 304 buf_len, cmd, 0, (uint8_t *)RAID_CTLR_LUNID, NULL); 305 306 DBG_FUNC("OUT\n"); 307 308 return ret; 309 } 310 311 /* subroutine used to get physical and logical luns of the device */ 312 static int pqisrc_get_physical_logical_luns(pqisrc_softstate_t *softs, uint8_t cmd, 313 reportlun_data_ext_t **buff, size_t *data_length) 314 { 315 int ret; 316 size_t list_len; 317 size_t data_len; 318 size_t new_lun_list_length; 319 reportlun_data_ext_t *lun_data; 320 reportlun_header_t report_lun_header; 321 322 DBG_FUNC("IN\n"); 323 324 ret = pqisrc_report_luns(softs, cmd, &report_lun_header, 325 sizeof(report_lun_header)); 326 327 if (ret) { 328 DBG_ERR("failed return code: %d\n", ret); 329 return ret; 330 } 331 list_len = BE_32(report_lun_header.list_length); 332 333 retry: 334 data_len = sizeof(reportlun_header_t) + list_len; 335 *data_length = data_len; 336 337 lun_data = os_mem_alloc(softs, data_len); 338 339 if (!lun_data) { 340 DBG_ERR("failed to allocate memory for lun_data\n"); 341 return PQI_STATUS_FAILURE; 342 } 343 344 if (list_len == 0) { 345 DBG_INFO("list_len is 0\n"); 346 memcpy(lun_data, &report_lun_header, sizeof(report_lun_header)); 347 goto out; 348 } 349 350 ret = pqisrc_report_luns(softs, cmd, lun_data, data_len); 351 352 if (ret) { 353 DBG_ERR("error\n"); 354 goto error; 355 } 356 357 new_lun_list_length = BE_32(lun_data->header.list_length); 358 359 if (new_lun_list_length > list_len) { 360 list_len = new_lun_list_length; 361 os_mem_free(softs, (void *)lun_data, data_len); 362 goto retry; 363 } 364 365 out: 366 *buff = lun_data; 367 DBG_FUNC("OUT\n"); 368 return 0; 369 370 error: 371 os_mem_free(softs, (void *)lun_data, data_len); 372 DBG_ERR("FAILED\n"); 373 return ret; 374 } 375 376 /* 377 * Function used to get physical and logical device list 378 */ 379 static int pqisrc_get_phys_log_device_list(pqisrc_softstate_t *softs, 380 reportlun_data_ext_t **physical_dev_list, 381 reportlun_data_ext_t **logical_dev_list, 382 size_t *phys_data_length, 383 size_t *log_data_length) 384 { 385 int ret = PQI_STATUS_SUCCESS; 386 size_t logical_list_length; 387 size_t logdev_data_length; 388 size_t data_length; 389 reportlun_data_ext_t *local_logdev_list; 390 reportlun_data_ext_t *logdev_data; 391 reportlun_header_t report_lun_header; 392 393 394 DBG_FUNC("IN\n"); 395 396 ret = pqisrc_get_physical_logical_luns(softs, SA_REPORT_PHYS, physical_dev_list, phys_data_length); 397 if (ret) { 398 DBG_ERR("report physical LUNs failed"); 399 return ret; 400 } 401 402 ret = pqisrc_get_physical_logical_luns(softs, SA_REPORT_LOG, logical_dev_list, log_data_length); 403 if (ret) { 404 DBG_ERR("report logical LUNs failed"); 405 return ret; 406 } 407 408 409 logdev_data = *logical_dev_list; 410 411 if (logdev_data) { 412 logical_list_length = 413 BE_32(logdev_data->header.list_length); 414 } else { 415 memset(&report_lun_header, 0, sizeof(report_lun_header)); 416 logdev_data = 417 (reportlun_data_ext_t *)&report_lun_header; 418 logical_list_length = 0; 419 } 420 421 logdev_data_length = sizeof(reportlun_header_t) + 422 logical_list_length; 423 424 /* Adding LOGICAL device entry for controller */ 425 local_logdev_list = os_mem_alloc(softs, 426 logdev_data_length + sizeof(reportlun_ext_entry_t)); 427 if (!local_logdev_list) { 428 data_length = *log_data_length; 429 os_mem_free(softs, (char *)*logical_dev_list, data_length); 430 *logical_dev_list = NULL; 431 return PQI_STATUS_FAILURE; 432 } 433 434 memcpy(local_logdev_list, logdev_data, logdev_data_length); 435 memset((uint8_t *)local_logdev_list + logdev_data_length, 0, 436 sizeof(reportlun_ext_entry_t)); 437 local_logdev_list->header.list_length = BE_32(logical_list_length + 438 sizeof(reportlun_ext_entry_t)); 439 data_length = *log_data_length; 440 os_mem_free(softs, (char *)*logical_dev_list, data_length); 441 *log_data_length = logdev_data_length + sizeof(reportlun_ext_entry_t); 442 *logical_dev_list = local_logdev_list; 443 444 DBG_FUNC("OUT\n"); 445 446 return ret; 447 } 448 449 /* Subroutine used to set Bus-Target-Lun for the requested device */ 450 static inline void pqisrc_set_btl(pqi_scsi_dev_t *device, 451 int bus, int target, int lun) 452 { 453 DBG_FUNC("IN\n"); 454 455 device->bus = bus; 456 device->target = target; 457 device->lun = lun; 458 459 DBG_FUNC("OUT\n"); 460 } 461 462 inline boolean_t pqisrc_is_external_raid_device(pqi_scsi_dev_t *device) 463 { 464 return device->is_external_raid_device; 465 } 466 467 static inline boolean_t pqisrc_is_external_raid_addr(uint8_t *scsi3addr) 468 { 469 return scsi3addr[2] != 0; 470 } 471 472 /* Function used to assign Bus-Target-Lun for the requested device */ 473 static void pqisrc_assign_btl(pqi_scsi_dev_t *device) 474 { 475 uint8_t *scsi3addr; 476 uint32_t lunid; 477 uint32_t bus; 478 uint32_t target; 479 uint32_t lun; 480 DBG_FUNC("IN\n"); 481 482 scsi3addr = device->scsi3addr; 483 lunid = GET_LE32(scsi3addr); 484 485 if (pqisrc_is_hba_lunid(scsi3addr)) { 486 /* The specified device is the controller. */ 487 pqisrc_set_btl(device, PQI_HBA_BUS, PQI_CTLR_INDEX, lunid & 0x3fff); 488 device->target_lun_valid = true; 489 return; 490 } 491 492 if (pqisrc_is_logical_device(device)) { 493 if (pqisrc_is_external_raid_device(device)) { 494 DBG_INFO("External Raid Device!!!"); 495 bus = PQI_EXTERNAL_RAID_VOLUME_BUS; 496 target = (lunid >> 16) & 0x3fff; 497 lun = lunid & 0xff; 498 } else { 499 bus = PQI_RAID_VOLUME_BUS; 500 lun = 0; 501 target = lunid & 0x3fff; 502 } 503 pqisrc_set_btl(device, bus, target, lun); 504 device->target_lun_valid = true; 505 return; 506 } 507 508 /* physical device */ 509 pqisrc_set_btl(device, PQI_PHYSICAL_DEVICE_BUS, PQI_PD_INDEX(scsi3addr[6]), 0); 510 511 DBG_FUNC("OUT\n"); 512 } 513 514 /* Build and send the internal INQUIRY command to particular device */ 515 static int pqisrc_send_scsi_inquiry(pqisrc_softstate_t *softs, 516 uint8_t *scsi3addr, uint16_t vpd_page, uint8_t *buff, int buf_len) 517 { 518 int ret = PQI_STATUS_SUCCESS; 519 pqisrc_raid_req_t request; 520 raid_path_error_info_elem_t error_info; 521 522 DBG_FUNC("IN\n"); 523 524 memset(&request, 0, sizeof(request)); 525 ret = pqisrc_build_send_raid_request(softs, &request, buff, buf_len, 526 SA_INQUIRY, vpd_page, scsi3addr, &error_info); 527 528 DBG_FUNC("OUT\n"); 529 return ret; 530 } 531 532 /* Function used to parse the sense information from response */ 533 static void pqisrc_fetch_sense_info(const uint8_t *sense_data, 534 unsigned sense_data_length, uint8_t *sense_key, uint8_t *asc, uint8_t *ascq) 535 { 536 struct sense_header_scsi header; 537 538 DBG_FUNC("IN\n"); 539 540 *sense_key = 0; 541 *ascq = 0; 542 *asc = 0; 543 544 if (pqisrc_update_scsi_sense(sense_data, sense_data_length, &header)) { 545 *sense_key = header.sense_key; 546 *asc = header.asc; 547 *ascq = header.ascq; 548 } 549 550 DBG_INFO("sense_key: %x asc: %x ascq: %x\n", *sense_key, *asc, *ascq); 551 552 DBG_FUNC("OUT\n"); 553 } 554 555 /* Function used to validate volume offline status */ 556 static uint8_t pqisrc_get_volume_offline_status(pqisrc_softstate_t *softs, 557 uint8_t *scsi3addr) 558 { 559 int ret = PQI_STATUS_SUCCESS; 560 uint8_t status = SA_LV_STATUS_VPD_UNSUPPORTED; 561 uint8_t size; 562 uint8_t *buff = NULL; 563 564 DBG_FUNC("IN\n"); 565 566 buff = os_mem_alloc(softs, 64); 567 if (!buff) 568 return PQI_STATUS_FAILURE; 569 570 /* Get the size of the VPD return buff. */ 571 ret = pqisrc_send_scsi_inquiry(softs, scsi3addr, VPD_PAGE | SA_VPD_LV_STATUS, 572 buff, SCSI_VPD_HEADER_LENGTH); 573 574 if (ret) 575 goto out; 576 577 size = buff[3]; 578 579 /* Now get the whole VPD buff. */ 580 ret = pqisrc_send_scsi_inquiry(softs, scsi3addr, VPD_PAGE | SA_VPD_LV_STATUS, 581 buff, size + SCSI_VPD_HEADER_LENGTH); 582 if (ret) 583 goto out; 584 585 status = buff[4]; 586 587 out: 588 os_mem_free(softs, (char *)buff, 64); 589 DBG_FUNC("OUT\n"); 590 591 return status; 592 } 593 594 595 /* Determine offline status of a volume. Returns appropriate SA_LV_* status.*/ 596 static uint8_t pqisrc_get_dev_vol_status(pqisrc_softstate_t *softs, 597 uint8_t *scsi3addr) 598 { 599 int ret = PQI_STATUS_SUCCESS; 600 uint8_t *sense_data; 601 unsigned sense_data_len; 602 uint8_t sense_key; 603 uint8_t asc; 604 uint8_t ascq; 605 uint8_t off_status; 606 uint8_t scsi_status; 607 pqisrc_raid_req_t request; 608 raid_path_error_info_elem_t error_info; 609 610 DBG_FUNC("IN\n"); 611 612 memset(&request, 0, sizeof(request)); 613 ret = pqisrc_build_send_raid_request(softs, &request, NULL, 0, 614 TEST_UNIT_READY, 0, scsi3addr, &error_info); 615 616 if (ret) 617 goto error; 618 sense_data = error_info.data; 619 sense_data_len = LE_16(error_info.sense_data_len); 620 621 if (sense_data_len > sizeof(error_info.data)) 622 sense_data_len = sizeof(error_info.data); 623 624 pqisrc_fetch_sense_info(sense_data, sense_data_len, &sense_key, &asc, 625 &ascq); 626 627 scsi_status = error_info.status; 628 629 /* scsi status: "CHECK CONDN" / SK: "not ready" ? */ 630 if (scsi_status != 2 || 631 sense_key != 2 || 632 asc != ASC_LUN_NOT_READY) { 633 return SA_LV_OK; 634 } 635 636 /* Determine the reason for not ready state. */ 637 off_status = pqisrc_get_volume_offline_status(softs, scsi3addr); 638 639 DBG_INFO("offline_status 0x%x\n", off_status); 640 641 /* Keep volume offline in certain cases. */ 642 switch (off_status) { 643 case SA_LV_UNDERGOING_ERASE: 644 case SA_LV_NOT_AVAILABLE: 645 case SA_LV_UNDERGOING_RPI: 646 case SA_LV_PENDING_RPI: 647 case SA_LV_ENCRYPTED_NO_KEY: 648 case SA_LV_PLAINTEXT_IN_ENCRYPT_ONLY_CONTROLLER: 649 case SA_LV_UNDERGOING_ENCRYPTION: 650 case SA_LV_UNDERGOING_ENCRYPTION_REKEYING: 651 case SA_LV_ENCRYPTED_IN_NON_ENCRYPTED_CONTROLLER: 652 return off_status; 653 case SA_LV_STATUS_VPD_UNSUPPORTED: 654 /* 655 * If the VPD status page isn't available, 656 * use ASC/ASCQ to determine state. 657 */ 658 if (ascq == ASCQ_LUN_NOT_READY_FORMAT_IN_PROGRESS || 659 ascq == ASCQ_LUN_NOT_READY_INITIALIZING_CMD_REQ) 660 return off_status; 661 break; 662 } 663 664 DBG_FUNC("OUT\n"); 665 666 return SA_LV_OK; 667 668 error: 669 return SA_LV_STATUS_VPD_UNSUPPORTED; 670 } 671 672 /* Validate the RAID map parameters */ 673 static int pqisrc_raid_map_validation(pqisrc_softstate_t *softs, 674 pqi_scsi_dev_t *device, pqisrc_raid_map_t *raid_map) 675 { 676 char *error_msg; 677 uint32_t raidmap_size; 678 uint32_t r5or6_blocks_per_row; 679 unsigned phys_dev_num; 680 unsigned num_raidmap_entries; 681 682 DBG_FUNC("IN\n"); 683 684 raidmap_size = LE_32(raid_map->structure_size); 685 if (raidmap_size < offsetof(pqisrc_raid_map_t, dev_data)) { 686 error_msg = "RAID map too small\n"; 687 goto error; 688 } 689 690 if (raidmap_size > sizeof(*raid_map)) { 691 error_msg = "RAID map too large\n"; 692 goto error; 693 } 694 695 phys_dev_num = LE_16(raid_map->layout_map_count) * 696 (LE_16(raid_map->data_disks_per_row) + 697 LE_16(raid_map->metadata_disks_per_row)); 698 num_raidmap_entries = phys_dev_num * 699 LE_16(raid_map->row_cnt); 700 701 if (num_raidmap_entries > RAID_MAP_MAX_ENTRIES) { 702 error_msg = "invalid number of map entries in RAID map\n"; 703 goto error; 704 } 705 706 if (device->raid_level == SA_RAID_1) { 707 if (LE_16(raid_map->layout_map_count) != 2) { 708 error_msg = "invalid RAID-1 map\n"; 709 goto error; 710 } 711 } else if (device->raid_level == SA_RAID_ADM) { 712 if (LE_16(raid_map->layout_map_count) != 3) { 713 error_msg = "invalid RAID-1(ADM) map\n"; 714 goto error; 715 } 716 } else if ((device->raid_level == SA_RAID_5 || 717 device->raid_level == SA_RAID_6) && 718 LE_16(raid_map->layout_map_count) > 1) { 719 /* RAID 50/60 */ 720 r5or6_blocks_per_row = 721 LE_16(raid_map->strip_size) * 722 LE_16(raid_map->data_disks_per_row); 723 if (r5or6_blocks_per_row == 0) { 724 error_msg = "invalid RAID-5 or RAID-6 map\n"; 725 goto error; 726 } 727 } 728 729 DBG_FUNC("OUT\n"); 730 731 return 0; 732 733 error: 734 DBG_ERR("%s\n", error_msg); 735 return PQI_STATUS_FAILURE; 736 } 737 738 /* Get device raidmap for the requested device */ 739 static int pqisrc_get_device_raidmap(pqisrc_softstate_t *softs, 740 pqi_scsi_dev_t *device) 741 { 742 int ret = PQI_STATUS_SUCCESS; 743 pqisrc_raid_req_t request; 744 pqisrc_raid_map_t *raid_map; 745 746 DBG_FUNC("IN\n"); 747 748 raid_map = os_mem_alloc(softs, sizeof(*raid_map)); 749 if (!raid_map) 750 return PQI_STATUS_FAILURE; 751 752 memset(&request, 0, sizeof(request)); 753 ret = pqisrc_build_send_raid_request(softs, &request, raid_map, sizeof(*raid_map), 754 SA_GET_RAID_MAP, 0, device->scsi3addr, NULL); 755 756 if (ret) { 757 DBG_ERR("error in build send raid req ret=%d\n", ret); 758 goto err_out; 759 } 760 761 ret = pqisrc_raid_map_validation(softs, device, raid_map); 762 if (ret) { 763 DBG_ERR("error in raid map validation ret=%d\n", ret); 764 goto err_out; 765 } 766 767 device->raid_map = raid_map; 768 DBG_FUNC("OUT\n"); 769 return 0; 770 771 err_out: 772 os_mem_free(softs, (char*)raid_map, sizeof(*raid_map)); 773 DBG_FUNC("FAILED \n"); 774 return ret; 775 } 776 777 /* Get device ioaccel_status to validate the type of device */ 778 static void pqisrc_get_dev_ioaccel_status(pqisrc_softstate_t *softs, 779 pqi_scsi_dev_t *device) 780 { 781 int ret = PQI_STATUS_SUCCESS; 782 uint8_t *buff; 783 uint8_t ioaccel_status; 784 785 DBG_FUNC("IN\n"); 786 787 buff = os_mem_alloc(softs, 64); 788 if (!buff) 789 return; 790 791 ret = pqisrc_send_scsi_inquiry(softs, device->scsi3addr, 792 VPD_PAGE | SA_VPD_LV_IOACCEL_STATUS, buff, 64); 793 if (ret) { 794 DBG_ERR("error in send scsi inquiry ret=%d\n", ret); 795 goto err_out; 796 } 797 798 ioaccel_status = buff[IOACCEL_STATUS_BYTE]; 799 device->offload_config = 800 !!(ioaccel_status & OFFLOAD_CONFIGURED_BIT); 801 802 if (device->offload_config) { 803 device->offload_enabled_pending = 804 !!(ioaccel_status & OFFLOAD_ENABLED_BIT); 805 if (pqisrc_get_device_raidmap(softs, device)) 806 device->offload_enabled_pending = false; 807 } 808 809 DBG_INFO("offload_config: 0x%x offload_enabled_pending: 0x%x \n", 810 device->offload_config, device->offload_enabled_pending); 811 812 err_out: 813 os_mem_free(softs, (char*)buff, 64); 814 DBG_FUNC("OUT\n"); 815 } 816 817 /* Get RAID level of requested device */ 818 static void pqisrc_get_dev_raid_level(pqisrc_softstate_t *softs, 819 pqi_scsi_dev_t *device) 820 { 821 uint8_t raid_level; 822 uint8_t *buff; 823 824 DBG_FUNC("IN\n"); 825 826 raid_level = SA_RAID_UNKNOWN; 827 828 buff = os_mem_alloc(softs, 64); 829 if (buff) { 830 int ret; 831 ret = pqisrc_send_scsi_inquiry(softs, device->scsi3addr, 832 VPD_PAGE | SA_VPD_LV_DEVICE_GEOMETRY, buff, 64); 833 if (ret == 0) { 834 raid_level = buff[8]; 835 if (raid_level > SA_RAID_MAX) 836 raid_level = SA_RAID_UNKNOWN; 837 } 838 os_mem_free(softs, (char*)buff, 64); 839 } 840 841 device->raid_level = raid_level; 842 DBG_INFO("RAID LEVEL: %x \n", raid_level); 843 DBG_FUNC("OUT\n"); 844 } 845 846 /* Parse the inquiry response and determine the type of device */ 847 static int pqisrc_get_dev_data(pqisrc_softstate_t *softs, 848 pqi_scsi_dev_t *device) 849 { 850 int ret = PQI_STATUS_SUCCESS; 851 uint8_t *inq_buff; 852 853 DBG_FUNC("IN\n"); 854 855 inq_buff = os_mem_alloc(softs, OBDR_TAPE_INQ_SIZE); 856 if (!inq_buff) 857 return PQI_STATUS_FAILURE; 858 859 /* Send an inquiry to the device to see what it is. */ 860 ret = pqisrc_send_scsi_inquiry(softs, device->scsi3addr, 0, inq_buff, 861 OBDR_TAPE_INQ_SIZE); 862 if (ret) 863 goto err_out; 864 pqisrc_sanitize_inquiry_string(&inq_buff[8], 8); 865 pqisrc_sanitize_inquiry_string(&inq_buff[16], 16); 866 867 device->devtype = inq_buff[0] & 0x1f; 868 memcpy(device->vendor, &inq_buff[8], 869 sizeof(device->vendor)); 870 memcpy(device->model, &inq_buff[16], 871 sizeof(device->model)); 872 DBG_INFO("DEV_TYPE: %x VENDOR: %s MODEL: %s\n", device->devtype, device->vendor, device->model); 873 874 if (pqisrc_is_logical_device(device) && device->devtype == DISK_DEVICE) { 875 if (pqisrc_is_external_raid_device(device)) { 876 device->raid_level = SA_RAID_UNKNOWN; 877 device->volume_status = SA_LV_OK; 878 device->volume_offline = false; 879 } 880 else { 881 pqisrc_get_dev_raid_level(softs, device); 882 pqisrc_get_dev_ioaccel_status(softs, device); 883 device->volume_status = pqisrc_get_dev_vol_status(softs, 884 device->scsi3addr); 885 device->volume_offline = device->volume_status != SA_LV_OK; 886 } 887 } 888 889 /* 890 * Check if this is a One-Button-Disaster-Recovery device 891 * by looking for "$DR-10" at offset 43 in the inquiry data. 892 */ 893 device->is_obdr_device = (device->devtype == ROM_DEVICE && 894 memcmp(&inq_buff[OBDR_SIG_OFFSET], OBDR_TAPE_SIG, 895 OBDR_SIG_LEN) == 0); 896 err_out: 897 os_mem_free(softs, (char*)inq_buff, OBDR_TAPE_INQ_SIZE); 898 899 DBG_FUNC("OUT\n"); 900 return ret; 901 } 902 903 /* 904 * BMIC (Basic Management And Interface Commands) command 905 * to get the controller identify params 906 */ 907 static int pqisrc_identify_ctrl(pqisrc_softstate_t *softs, 908 bmic_ident_ctrl_t *buff) 909 { 910 int ret = PQI_STATUS_SUCCESS; 911 pqisrc_raid_req_t request; 912 913 DBG_FUNC("IN\n"); 914 915 memset(&request, 0, sizeof(request)); 916 ret = pqisrc_build_send_raid_request(softs, &request, buff, sizeof(*buff), 917 BMIC_IDENTIFY_CONTROLLER, 0, (uint8_t *)RAID_CTLR_LUNID, NULL); 918 DBG_FUNC("OUT\n"); 919 920 return ret; 921 } 922 923 /* Get the adapter FW version using BMIC_IDENTIFY_CONTROLLER */ 924 int pqisrc_get_ctrl_fw_version(pqisrc_softstate_t *softs) 925 { 926 int ret = PQI_STATUS_SUCCESS; 927 bmic_ident_ctrl_t *identify_ctrl; 928 929 DBG_FUNC("IN\n"); 930 931 identify_ctrl = os_mem_alloc(softs, sizeof(*identify_ctrl)); 932 if (!identify_ctrl) { 933 DBG_ERR("failed to allocate memory for identify_ctrl\n"); 934 return PQI_STATUS_FAILURE; 935 } 936 937 memset(identify_ctrl, 0, sizeof(*identify_ctrl)); 938 939 ret = pqisrc_identify_ctrl(softs, identify_ctrl); 940 if (ret) 941 goto out; 942 943 softs->fw_build_number = identify_ctrl->fw_build_number; 944 memcpy(softs->fw_version, identify_ctrl->fw_version, 945 sizeof(identify_ctrl->fw_version)); 946 softs->fw_version[sizeof(identify_ctrl->fw_version)] = '\0'; 947 snprintf(softs->fw_version + 948 strlen(softs->fw_version), 949 sizeof(softs->fw_version), 950 "-%u", identify_ctrl->fw_build_number); 951 out: 952 os_mem_free(softs, (char *)identify_ctrl, sizeof(*identify_ctrl)); 953 DBG_INFO("Firmware version: %s Firmware build number: %d\n", softs->fw_version, softs->fw_build_number); 954 DBG_FUNC("OUT\n"); 955 return ret; 956 } 957 958 /* BMIC command to determine scsi device identify params */ 959 static int pqisrc_identify_physical_disk(pqisrc_softstate_t *softs, 960 pqi_scsi_dev_t *device, 961 bmic_ident_physdev_t *buff, 962 int buf_len) 963 { 964 int ret = PQI_STATUS_SUCCESS; 965 uint16_t bmic_device_index; 966 pqisrc_raid_req_t request; 967 968 969 DBG_FUNC("IN\n"); 970 971 memset(&request, 0, sizeof(request)); 972 bmic_device_index = BMIC_GET_DRIVE_NUMBER(device->scsi3addr); 973 request.cdb[2] = (uint8_t)bmic_device_index; 974 request.cdb[9] = (uint8_t)(bmic_device_index >> 8); 975 976 ret = pqisrc_build_send_raid_request(softs, &request, buff, buf_len, 977 BMIC_IDENTIFY_PHYSICAL_DEVICE, 0, (uint8_t *)RAID_CTLR_LUNID, NULL); 978 DBG_FUNC("OUT\n"); 979 return ret; 980 } 981 982 /* 983 * Function used to get the scsi device information using one of BMIC 984 * BMIC_IDENTIFY_PHYSICAL_DEVICE 985 */ 986 static void pqisrc_get_physical_device_info(pqisrc_softstate_t *softs, 987 pqi_scsi_dev_t *device, 988 bmic_ident_physdev_t *id_phys) 989 { 990 int ret = PQI_STATUS_SUCCESS; 991 992 DBG_FUNC("IN\n"); 993 memset(id_phys, 0, sizeof(*id_phys)); 994 995 ret= pqisrc_identify_physical_disk(softs, device, 996 id_phys, sizeof(*id_phys)); 997 if (ret) { 998 device->queue_depth = PQI_PHYSICAL_DISK_DEFAULT_MAX_QUEUE_DEPTH; 999 return; 1000 } 1001 1002 device->queue_depth = 1003 LE_16(id_phys->current_queue_depth_limit); 1004 device->device_type = id_phys->device_type; 1005 device->active_path_index = id_phys->active_path_number; 1006 device->path_map = id_phys->redundant_path_present_map; 1007 memcpy(&device->box, 1008 &id_phys->alternate_paths_phys_box_on_port, 1009 sizeof(device->box)); 1010 memcpy(&device->phys_connector, 1011 &id_phys->alternate_paths_phys_connector, 1012 sizeof(device->phys_connector)); 1013 device->bay = id_phys->phys_bay_in_box; 1014 1015 DBG_INFO("BMIC DEV_TYPE: %x QUEUE DEPTH: 0x%x \n", device->device_type, device->queue_depth); 1016 DBG_FUNC("OUT\n"); 1017 } 1018 1019 1020 /* Function used to find the entry of the device in a list */ 1021 static device_status_t pqisrc_scsi_find_entry(pqisrc_softstate_t *softs, 1022 pqi_scsi_dev_t *device_to_find, 1023 pqi_scsi_dev_t **same_device) 1024 { 1025 pqi_scsi_dev_t *device; 1026 int i,j; 1027 DBG_FUNC("IN\n"); 1028 for(i = 0; i < PQI_MAX_DEVICES; i++) { 1029 for(j = 0; j < PQI_MAX_MULTILUN; j++) { 1030 if(softs->device_list[i][j] == NULL) 1031 continue; 1032 device = softs->device_list[i][j]; 1033 if (pqisrc_scsi3addr_equal(device_to_find->scsi3addr, 1034 device->scsi3addr)) { 1035 *same_device = device; 1036 if (pqisrc_device_equal(device_to_find, device)) { 1037 if (device_to_find->volume_offline) 1038 return DEVICE_CHANGED; 1039 return DEVICE_UNCHANGED; 1040 } 1041 return DEVICE_CHANGED; 1042 } 1043 } 1044 } 1045 DBG_FUNC("OUT\n"); 1046 1047 return DEVICE_NOT_FOUND; 1048 } 1049 1050 1051 /* Update the newly added devices as existed device */ 1052 static void pqisrc_exist_device_update(pqisrc_softstate_t *softs, 1053 pqi_scsi_dev_t *device_exist, 1054 pqi_scsi_dev_t *new_device) 1055 { 1056 DBG_FUNC("IN\n"); 1057 device_exist->expose_device = new_device->expose_device; 1058 memcpy(device_exist->vendor, new_device->vendor, 1059 sizeof(device_exist->vendor)); 1060 memcpy(device_exist->model, new_device->model, 1061 sizeof(device_exist->model)); 1062 device_exist->is_physical_device = new_device->is_physical_device; 1063 device_exist->is_external_raid_device = 1064 new_device->is_external_raid_device; 1065 device_exist->sas_address = new_device->sas_address; 1066 device_exist->raid_level = new_device->raid_level; 1067 device_exist->queue_depth = new_device->queue_depth; 1068 device_exist->ioaccel_handle = new_device->ioaccel_handle; 1069 device_exist->volume_status = new_device->volume_status; 1070 device_exist->active_path_index = new_device->active_path_index; 1071 device_exist->path_map = new_device->path_map; 1072 device_exist->bay = new_device->bay; 1073 memcpy(device_exist->box, new_device->box, 1074 sizeof(device_exist->box)); 1075 memcpy(device_exist->phys_connector, new_device->phys_connector, 1076 sizeof(device_exist->phys_connector)); 1077 device_exist->offload_config = new_device->offload_config; 1078 device_exist->offload_enabled = false; 1079 device_exist->offload_enabled_pending = 1080 new_device->offload_enabled_pending; 1081 device_exist->offload_to_mirror = 0; 1082 if (device_exist->raid_map) 1083 os_mem_free(softs, 1084 (char *)device_exist->raid_map, 1085 sizeof(*device_exist->raid_map)); 1086 device_exist->raid_map = new_device->raid_map; 1087 /* To prevent this from being freed later. */ 1088 new_device->raid_map = NULL; 1089 DBG_FUNC("OUT\n"); 1090 } 1091 1092 /* Validate the ioaccel_handle for a newly added device */ 1093 static pqi_scsi_dev_t *pqisrc_identify_device_via_ioaccel( 1094 pqisrc_softstate_t *softs, uint32_t ioaccel_handle) 1095 { 1096 pqi_scsi_dev_t *device; 1097 int i,j; 1098 DBG_FUNC("IN\n"); 1099 for(i = 0; i < PQI_MAX_DEVICES; i++) { 1100 for(j = 0; j < PQI_MAX_MULTILUN; j++) { 1101 if(softs->device_list[i][j] == NULL) 1102 continue; 1103 device = softs->device_list[i][j]; 1104 if (device->devtype != DISK_DEVICE) 1105 continue; 1106 if (pqisrc_is_logical_device(device)) 1107 continue; 1108 if (device->ioaccel_handle == ioaccel_handle) 1109 return device; 1110 } 1111 } 1112 DBG_FUNC("OUT\n"); 1113 1114 return NULL; 1115 } 1116 1117 /* Get the scsi device queue depth */ 1118 static void pqisrc_update_log_dev_qdepth(pqisrc_softstate_t *softs) 1119 { 1120 unsigned i; 1121 unsigned phys_dev_num; 1122 unsigned num_raidmap_entries; 1123 unsigned queue_depth; 1124 pqisrc_raid_map_t *raid_map; 1125 pqi_scsi_dev_t *device; 1126 raidmap_data_t *dev_data; 1127 pqi_scsi_dev_t *phys_disk; 1128 unsigned j; 1129 1130 DBG_FUNC("IN\n"); 1131 1132 for(i = 0; i < PQI_MAX_DEVICES; i++) { 1133 for(j = 0; j < PQI_MAX_MULTILUN; j++) { 1134 if(softs->device_list[i][j] == NULL) 1135 continue; 1136 device = softs->device_list[i][j]; 1137 if (device->devtype != DISK_DEVICE) 1138 continue; 1139 if (!pqisrc_is_logical_device(device)) 1140 continue; 1141 if (pqisrc_is_external_raid_device(device)) 1142 continue; 1143 device->queue_depth = PQI_LOGICAL_DISK_DEFAULT_MAX_QUEUE_DEPTH; 1144 raid_map = device->raid_map; 1145 if (!raid_map) 1146 return; 1147 dev_data = raid_map->dev_data; 1148 phys_dev_num = LE_16(raid_map->layout_map_count) * 1149 (LE_16(raid_map->data_disks_per_row) + 1150 LE_16(raid_map->metadata_disks_per_row)); 1151 num_raidmap_entries = phys_dev_num * 1152 LE_16(raid_map->row_cnt); 1153 1154 queue_depth = 0; 1155 for (i = 0; i < num_raidmap_entries; i++) { 1156 phys_disk = pqisrc_identify_device_via_ioaccel(softs, 1157 dev_data[i].ioaccel_handle); 1158 1159 if (!phys_disk) { 1160 DBG_WARN( 1161 "Failed to find physical disk handle for logical drive %016llx\n", 1162 (unsigned long long)BE_64(device->scsi3addr[0])); 1163 device->offload_enabled = false; 1164 device->offload_enabled_pending = false; 1165 if (raid_map) 1166 os_mem_free(softs, (char *)raid_map, sizeof(*raid_map)); 1167 device->raid_map = NULL; 1168 return; 1169 } 1170 1171 queue_depth += phys_disk->queue_depth; 1172 } 1173 1174 device->queue_depth = queue_depth; 1175 } /* end inner loop */ 1176 }/* end outer loop */ 1177 DBG_FUNC("OUT\n"); 1178 } 1179 1180 /* Function used to add a scsi device to OS scsi subsystem */ 1181 static int pqisrc_add_device(pqisrc_softstate_t *softs, 1182 pqi_scsi_dev_t *device) 1183 { 1184 DBG_FUNC("IN\n"); 1185 DBG_INFO("vendor: %s model: %s bus:%d target:%d lun:%d is_physical_device:0x%x expose_device:0x%x volume_offline 0x%x volume_status 0x%x \n", 1186 device->vendor, device->model, device->bus, device->target, device->lun, device->is_physical_device, device->expose_device, device->volume_offline, device->volume_status); 1187 1188 device->invalid = false; 1189 1190 if(device->expose_device) { 1191 /* TBD: Call OS upper layer function to add the device entry */ 1192 os_add_device(softs,device); 1193 } 1194 DBG_FUNC("OUT\n"); 1195 return PQI_STATUS_SUCCESS; 1196 1197 } 1198 1199 /* Function used to remove a scsi device from OS scsi subsystem */ 1200 void pqisrc_remove_device(pqisrc_softstate_t *softs, 1201 pqi_scsi_dev_t *device) 1202 { 1203 DBG_FUNC("IN\n"); 1204 DBG_INFO("vendor: %s model: %s bus:%d target:%d lun:%d is_physical_device:0x%x expose_device:0x%x volume_offline 0x%x volume_status 0x%x \n", 1205 device->vendor, device->model, device->bus, device->target, device->lun, device->is_physical_device, device->expose_device, device->volume_offline, device->volume_status); 1206 1207 /* TBD: Call OS upper layer function to remove the device entry */ 1208 device->invalid = true; 1209 os_remove_device(softs,device); 1210 DBG_FUNC("OUT\n"); 1211 } 1212 1213 1214 /* 1215 * When exposing new device to OS fails then adjst list according to the 1216 * mid scsi list 1217 */ 1218 static void pqisrc_adjust_list(pqisrc_softstate_t *softs, 1219 pqi_scsi_dev_t *device) 1220 { 1221 DBG_FUNC("IN\n"); 1222 1223 if (!device) { 1224 DBG_ERR("softs = %p: device is NULL !!!\n", softs); 1225 return; 1226 } 1227 1228 OS_ACQUIRE_SPINLOCK(&softs->devlist_lock); 1229 softs->device_list[device->target][device->lun] = NULL; 1230 OS_RELEASE_SPINLOCK(&softs->devlist_lock); 1231 pqisrc_device_mem_free(softs, device); 1232 1233 DBG_FUNC("OUT\n"); 1234 } 1235 1236 /* Debug routine used to display the RAID volume status of the device */ 1237 static void pqisrc_display_volume_status(pqisrc_softstate_t *softs, 1238 pqi_scsi_dev_t *device) 1239 { 1240 char *status; 1241 1242 DBG_FUNC("IN\n"); 1243 switch (device->volume_status) { 1244 case SA_LV_OK: 1245 status = "Volume is online."; 1246 break; 1247 case SA_LV_UNDERGOING_ERASE: 1248 status = "Volume is undergoing background erase process."; 1249 break; 1250 case SA_LV_NOT_AVAILABLE: 1251 status = "Volume is waiting for transforming volume."; 1252 break; 1253 case SA_LV_UNDERGOING_RPI: 1254 status = "Volume is undergoing rapid parity initialization process."; 1255 break; 1256 case SA_LV_PENDING_RPI: 1257 status = "Volume is queued for rapid parity initialization process."; 1258 break; 1259 case SA_LV_ENCRYPTED_NO_KEY: 1260 status = "Volume is encrypted and cannot be accessed because key is not present."; 1261 break; 1262 case SA_LV_PLAINTEXT_IN_ENCRYPT_ONLY_CONTROLLER: 1263 status = "Volume is not encrypted and cannot be accessed because controller is in encryption-only mode."; 1264 break; 1265 case SA_LV_UNDERGOING_ENCRYPTION: 1266 status = "Volume is undergoing encryption process."; 1267 break; 1268 case SA_LV_UNDERGOING_ENCRYPTION_REKEYING: 1269 status = "Volume is undergoing encryption re-keying process."; 1270 break; 1271 case SA_LV_ENCRYPTED_IN_NON_ENCRYPTED_CONTROLLER: 1272 status = "Volume is encrypted and cannot be accessed because controller does not have encryption enabled."; 1273 break; 1274 case SA_LV_PENDING_ENCRYPTION: 1275 status = "Volume is pending migration to encrypted state, but process has not started."; 1276 break; 1277 case SA_LV_PENDING_ENCRYPTION_REKEYING: 1278 status = "Volume is encrypted and is pending encryption rekeying."; 1279 break; 1280 case SA_LV_STATUS_VPD_UNSUPPORTED: 1281 status = "Volume status is not available through vital product data pages."; 1282 break; 1283 default: 1284 status = "Volume is in an unknown state."; 1285 break; 1286 } 1287 1288 DBG_INFO("scsi BTL %d:%d:%d %s\n", 1289 device->bus, device->target, device->lun, status); 1290 DBG_FUNC("OUT\n"); 1291 } 1292 1293 void pqisrc_device_mem_free(pqisrc_softstate_t *softs, pqi_scsi_dev_t *device) 1294 { 1295 DBG_INFO("IN\n"); 1296 if (!device) 1297 return; 1298 if (device->raid_map) { 1299 os_mem_free(softs, (char *)device->raid_map, sizeof(pqisrc_raid_map_t)); 1300 } 1301 os_mem_free(softs, (char *)device,sizeof(*device)); 1302 DBG_INFO("OUT\n"); 1303 1304 } 1305 1306 /* OS should call this function to free the scsi device */ 1307 void pqisrc_free_device(pqisrc_softstate_t * softs,pqi_scsi_dev_t *device) 1308 { 1309 1310 OS_ACQUIRE_SPINLOCK(&softs->devlist_lock); 1311 pqisrc_device_mem_free(softs, device); 1312 OS_RELEASE_SPINLOCK(&softs->devlist_lock); 1313 1314 } 1315 1316 1317 /* Update the newly added devices to the device list */ 1318 static void pqisrc_update_device_list(pqisrc_softstate_t *softs, 1319 pqi_scsi_dev_t *new_device_list[], int num_new_devices) 1320 { 1321 int ret; 1322 int i; 1323 device_status_t dev_status; 1324 pqi_scsi_dev_t *device; 1325 pqi_scsi_dev_t *same_device; 1326 pqi_scsi_dev_t **added = NULL; 1327 pqi_scsi_dev_t **removed = NULL; 1328 int nadded = 0, nremoved = 0; 1329 int j; 1330 DBG_INFO("IN\n"); 1331 1332 added = os_mem_alloc(softs, sizeof(*added) * PQI_MAX_DEVICES); 1333 removed = os_mem_alloc(softs, sizeof(*removed) * PQI_MAX_DEVICES); 1334 1335 if (!added || !removed) { 1336 DBG_WARN("Out of memory \n"); 1337 goto free_and_out; 1338 } 1339 1340 OS_ACQUIRE_SPINLOCK(&softs->devlist_lock); 1341 1342 for(i = 0; i < PQI_MAX_DEVICES; i++) { 1343 for(j = 0; j < PQI_MAX_MULTILUN; j++) { 1344 if(softs->device_list[i][j] == NULL) 1345 continue; 1346 device = softs->device_list[i][j]; 1347 device->device_gone = true; 1348 } 1349 } 1350 DBG_IO("Device list used an array\n"); 1351 for (i = 0; i < num_new_devices; i++) { 1352 device = new_device_list[i]; 1353 1354 dev_status = pqisrc_scsi_find_entry(softs, device, 1355 &same_device); 1356 1357 switch (dev_status) { 1358 case DEVICE_UNCHANGED: 1359 /* New Device present in existing device list */ 1360 device->new_device = false; 1361 same_device->device_gone = false; 1362 pqisrc_exist_device_update(softs, same_device, device); 1363 break; 1364 case DEVICE_NOT_FOUND: 1365 /* Device not found in existing list */ 1366 device->new_device = true; 1367 break; 1368 case DEVICE_CHANGED: 1369 /* Actual device gone need to add device to list*/ 1370 device->new_device = true; 1371 break; 1372 default: 1373 break; 1374 } 1375 } 1376 /* Process all devices that have gone away. */ 1377 for(i = 0, nremoved = 0; i < PQI_MAX_DEVICES; i++) { 1378 for(j = 0; j < PQI_MAX_MULTILUN; j++) { 1379 if(softs->device_list[i][j] == NULL) 1380 continue; 1381 device = softs->device_list[i][j]; 1382 if (device->device_gone) { 1383 softs->device_list[device->target][device->lun] = NULL; 1384 removed[nremoved] = device; 1385 nremoved++; 1386 } 1387 } 1388 } 1389 1390 /* Process all new devices. */ 1391 for (i = 0, nadded = 0; i < num_new_devices; i++) { 1392 device = new_device_list[i]; 1393 if (!device->new_device) 1394 continue; 1395 if (device->volume_offline) 1396 continue; 1397 1398 softs->device_list[device->target][device->lun] = device; 1399 DBG_INFO("Added device %p at B : %d T : %d L : %d\n",device, 1400 device->bus,device->target,device->lun); 1401 /* To prevent this entry from being freed later. */ 1402 new_device_list[i] = NULL; 1403 added[nadded] = device; 1404 nadded++; 1405 } 1406 1407 pqisrc_update_log_dev_qdepth(softs); 1408 1409 for(i = 0; i < PQI_MAX_DEVICES; i++) { 1410 for(j = 0; j < PQI_MAX_MULTILUN; j++) { 1411 if(softs->device_list[i][j] == NULL) 1412 continue; 1413 device = softs->device_list[i][j]; 1414 device->offload_enabled = device->offload_enabled_pending; 1415 } 1416 } 1417 1418 OS_RELEASE_SPINLOCK(&softs->devlist_lock); 1419 1420 for(i = 0; i < nremoved; i++) { 1421 device = removed[i]; 1422 if (device == NULL) 1423 continue; 1424 pqisrc_remove_device(softs, device); 1425 pqisrc_display_device_info(softs, "removed", device); 1426 1427 } 1428 1429 for(i = 0; i < PQI_MAX_DEVICES; i++) { 1430 for(j = 0; j < PQI_MAX_MULTILUN; j++) { 1431 if(softs->device_list[i][j] == NULL) 1432 continue; 1433 device = softs->device_list[i][j]; 1434 /* 1435 * Notify the OS upper layer if the queue depth of any existing device has 1436 * changed. 1437 */ 1438 if (device->queue_depth != 1439 device->advertised_queue_depth) { 1440 device->advertised_queue_depth = device->queue_depth; 1441 /* TBD: Call OS upper layer function to change device Q depth */ 1442 } 1443 } 1444 } 1445 for(i = 0; i < nadded; i++) { 1446 device = added[i]; 1447 if (device->expose_device) { 1448 ret = pqisrc_add_device(softs, device); 1449 if (ret) { 1450 DBG_WARN("scsi %d:%d:%d addition failed, device not added\n", 1451 device->bus, device->target, 1452 device->lun); 1453 pqisrc_adjust_list(softs, device); 1454 continue; 1455 } 1456 } 1457 1458 pqisrc_display_device_info(softs, "added", device); 1459 } 1460 1461 /* Process all volumes that are offline. */ 1462 for (i = 0; i < num_new_devices; i++) { 1463 device = new_device_list[i]; 1464 if (!device) 1465 continue; 1466 if (!device->new_device) 1467 continue; 1468 if (device->volume_offline) { 1469 pqisrc_display_volume_status(softs, device); 1470 pqisrc_display_device_info(softs, "offline", device); 1471 } 1472 } 1473 1474 free_and_out: 1475 if (added) 1476 os_mem_free(softs, (char *)added, 1477 sizeof(*added) * PQI_MAX_DEVICES); 1478 if (removed) 1479 os_mem_free(softs, (char *)removed, 1480 sizeof(*removed) * PQI_MAX_DEVICES); 1481 1482 DBG_INFO("OUT\n"); 1483 } 1484 1485 /* 1486 * Let the Adapter know about driver version using one of BMIC 1487 * BMIC_WRITE_HOST_WELLNESS 1488 */ 1489 int pqisrc_write_driver_version_to_host_wellness(pqisrc_softstate_t *softs) 1490 { 1491 int rval = PQI_STATUS_SUCCESS; 1492 struct bmic_host_wellness_driver_version *host_wellness_driver_ver; 1493 size_t data_length; 1494 pqisrc_raid_req_t request; 1495 1496 DBG_FUNC("IN\n"); 1497 1498 memset(&request, 0, sizeof(request)); 1499 data_length = sizeof(*host_wellness_driver_ver); 1500 1501 host_wellness_driver_ver = os_mem_alloc(softs, data_length); 1502 if (!host_wellness_driver_ver) { 1503 DBG_ERR("failed to allocate memory for host wellness driver_version\n"); 1504 return PQI_STATUS_FAILURE; 1505 } 1506 1507 host_wellness_driver_ver->start_tag[0] = '<'; 1508 host_wellness_driver_ver->start_tag[1] = 'H'; 1509 host_wellness_driver_ver->start_tag[2] = 'W'; 1510 host_wellness_driver_ver->start_tag[3] = '>'; 1511 host_wellness_driver_ver->driver_version_tag[0] = 'D'; 1512 host_wellness_driver_ver->driver_version_tag[1] = 'V'; 1513 host_wellness_driver_ver->driver_version_length = LE_16(sizeof(host_wellness_driver_ver->driver_version)); 1514 strncpy(host_wellness_driver_ver->driver_version, softs->os_name, 1515 sizeof(host_wellness_driver_ver->driver_version)); 1516 if (strlen(softs->os_name) < sizeof(host_wellness_driver_ver->driver_version) ) { 1517 strncpy(host_wellness_driver_ver->driver_version + strlen(softs->os_name), PQISRC_DRIVER_VERSION, 1518 sizeof(host_wellness_driver_ver->driver_version) - strlen(softs->os_name)); 1519 } else { 1520 DBG_INFO("OS name length(%lu) is longer than buffer of driver_version\n", 1521 strlen(softs->os_name)); 1522 } 1523 host_wellness_driver_ver->driver_version[sizeof(host_wellness_driver_ver->driver_version) - 1] = '\0'; 1524 host_wellness_driver_ver->end_tag[0] = 'Z'; 1525 host_wellness_driver_ver->end_tag[1] = 'Z'; 1526 1527 rval = pqisrc_build_send_raid_request(softs, &request, host_wellness_driver_ver,data_length, 1528 BMIC_WRITE_HOST_WELLNESS, 0, (uint8_t *)RAID_CTLR_LUNID, NULL); 1529 1530 os_mem_free(softs, (char *)host_wellness_driver_ver, data_length); 1531 1532 DBG_FUNC("OUT"); 1533 return rval; 1534 } 1535 1536 /* 1537 * Write current RTC time from host to the adapter using 1538 * BMIC_WRITE_HOST_WELLNESS 1539 */ 1540 int pqisrc_write_current_time_to_host_wellness(pqisrc_softstate_t *softs) 1541 { 1542 int rval = PQI_STATUS_SUCCESS; 1543 struct bmic_host_wellness_time *host_wellness_time; 1544 size_t data_length; 1545 pqisrc_raid_req_t request; 1546 1547 DBG_FUNC("IN\n"); 1548 1549 memset(&request, 0, sizeof(request)); 1550 data_length = sizeof(*host_wellness_time); 1551 1552 host_wellness_time = os_mem_alloc(softs, data_length); 1553 if (!host_wellness_time) { 1554 DBG_ERR("failed to allocate memory for host wellness time structure\n"); 1555 return PQI_STATUS_FAILURE; 1556 } 1557 1558 host_wellness_time->start_tag[0] = '<'; 1559 host_wellness_time->start_tag[1] = 'H'; 1560 host_wellness_time->start_tag[2] = 'W'; 1561 host_wellness_time->start_tag[3] = '>'; 1562 host_wellness_time->time_tag[0] = 'T'; 1563 host_wellness_time->time_tag[1] = 'D'; 1564 host_wellness_time->time_length = LE_16(offsetof(struct bmic_host_wellness_time, time_length) - 1565 offsetof(struct bmic_host_wellness_time, century)); 1566 1567 os_get_time(host_wellness_time); 1568 1569 host_wellness_time->dont_write_tag[0] = 'D'; 1570 host_wellness_time->dont_write_tag[1] = 'W'; 1571 host_wellness_time->end_tag[0] = 'Z'; 1572 host_wellness_time->end_tag[1] = 'Z'; 1573 1574 rval = pqisrc_build_send_raid_request(softs, &request, host_wellness_time,data_length, 1575 BMIC_WRITE_HOST_WELLNESS, 0, (uint8_t *)RAID_CTLR_LUNID, NULL); 1576 1577 os_mem_free(softs, (char *)host_wellness_time, data_length); 1578 1579 DBG_FUNC("OUT"); 1580 return rval; 1581 } 1582 1583 /* 1584 * Function used to perform a rescan of scsi devices 1585 * for any config change events 1586 */ 1587 int pqisrc_scan_devices(pqisrc_softstate_t *softs) 1588 { 1589 boolean_t is_physical_device; 1590 int ret = PQI_STATUS_FAILURE; 1591 int i; 1592 int new_dev_cnt; 1593 int phy_log_dev_cnt; 1594 uint8_t *scsi3addr; 1595 uint32_t physical_cnt; 1596 uint32_t logical_cnt; 1597 uint32_t ndev_allocated = 0; 1598 size_t phys_data_length, log_data_length; 1599 reportlun_data_ext_t *physical_dev_list = NULL; 1600 reportlun_data_ext_t *logical_dev_list = NULL; 1601 reportlun_ext_entry_t *lun_ext_entry = NULL; 1602 bmic_ident_physdev_t *bmic_phy_info = NULL; 1603 pqi_scsi_dev_t **new_device_list = NULL; 1604 pqi_scsi_dev_t *device = NULL; 1605 1606 1607 DBG_FUNC("IN\n"); 1608 1609 ret = pqisrc_get_phys_log_device_list(softs, &physical_dev_list, &logical_dev_list, 1610 &phys_data_length, &log_data_length); 1611 1612 if (ret) 1613 goto err_out; 1614 1615 physical_cnt = BE_32(physical_dev_list->header.list_length) 1616 / sizeof(physical_dev_list->lun_entries[0]); 1617 1618 logical_cnt = BE_32(logical_dev_list->header.list_length) 1619 / sizeof(logical_dev_list->lun_entries[0]); 1620 1621 DBG_INFO("physical_cnt %d logical_cnt %d\n", physical_cnt, logical_cnt); 1622 1623 if (physical_cnt) { 1624 bmic_phy_info = os_mem_alloc(softs, sizeof(*bmic_phy_info)); 1625 if (bmic_phy_info == NULL) { 1626 ret = PQI_STATUS_FAILURE; 1627 DBG_ERR("failed to allocate memory for BMIC ID PHYS Device : %d\n", ret); 1628 goto err_out; 1629 } 1630 } 1631 phy_log_dev_cnt = physical_cnt + logical_cnt; 1632 new_device_list = os_mem_alloc(softs, 1633 sizeof(*new_device_list) * phy_log_dev_cnt); 1634 1635 if (new_device_list == NULL) { 1636 ret = PQI_STATUS_FAILURE; 1637 DBG_ERR("failed to allocate memory for device list : %d\n", ret); 1638 goto err_out; 1639 } 1640 1641 for (i = 0; i < phy_log_dev_cnt; i++) { 1642 new_device_list[i] = os_mem_alloc(softs, 1643 sizeof(*new_device_list[i])); 1644 if (new_device_list[i] == NULL) { 1645 ret = PQI_STATUS_FAILURE; 1646 DBG_ERR("failed to allocate memory for device list : %d\n", ret); 1647 ndev_allocated = i; 1648 goto err_out; 1649 } 1650 } 1651 1652 ndev_allocated = phy_log_dev_cnt; 1653 new_dev_cnt = 0; 1654 for (i = 0; i < phy_log_dev_cnt; i++) { 1655 1656 if (i < physical_cnt) { 1657 is_physical_device = true; 1658 lun_ext_entry = &physical_dev_list->lun_entries[i]; 1659 } else { 1660 is_physical_device = false; 1661 lun_ext_entry = 1662 &logical_dev_list->lun_entries[i - physical_cnt]; 1663 } 1664 1665 scsi3addr = lun_ext_entry->lunid; 1666 1667 /* Skip masked physical non-disk devices. */ 1668 if (MASKED_DEVICE(scsi3addr) && is_physical_device) 1669 continue; 1670 1671 device = new_device_list[new_dev_cnt]; 1672 memset(device, 0, sizeof(*device)); 1673 memcpy(device->scsi3addr, scsi3addr, sizeof(device->scsi3addr)); 1674 device->wwid = lun_ext_entry->wwid; 1675 device->is_physical_device = is_physical_device; 1676 if (!is_physical_device) 1677 device->is_external_raid_device = 1678 pqisrc_is_external_raid_addr(scsi3addr); 1679 1680 1681 /* Get device type, vendor, model, device ID. */ 1682 ret = pqisrc_get_dev_data(softs, device); 1683 if (ret) { 1684 DBG_WARN("Inquiry failed, skipping device %016llx\n", 1685 (unsigned long long)BE_64(device->scsi3addr[0])); 1686 DBG_INFO("INQUIRY FAILED \n"); 1687 continue; 1688 } 1689 pqisrc_assign_btl(device); 1690 1691 /* 1692 * Expose all devices except for physical devices that 1693 * are masked. 1694 */ 1695 if (device->is_physical_device && 1696 MASKED_DEVICE(scsi3addr)) 1697 device->expose_device = false; 1698 else 1699 device->expose_device = true; 1700 1701 if (device->is_physical_device && 1702 (lun_ext_entry->device_flags & 1703 REPORT_LUN_DEV_FLAG_AIO_ENABLED) && 1704 lun_ext_entry->ioaccel_handle) { 1705 device->aio_enabled = true; 1706 } 1707 switch (device->devtype) { 1708 case ROM_DEVICE: 1709 /* 1710 * We don't *really* support actual CD-ROM devices, 1711 * but we do support the HP "One Button Disaster 1712 * Recovery" tape drive which temporarily pretends to 1713 * be a CD-ROM drive. 1714 */ 1715 if (device->is_obdr_device) 1716 new_dev_cnt++; 1717 break; 1718 case DISK_DEVICE: 1719 case ZBC_DEVICE: 1720 if (device->is_physical_device) { 1721 device->ioaccel_handle = 1722 lun_ext_entry->ioaccel_handle; 1723 device->sas_address = BE_64(lun_ext_entry->wwid); 1724 pqisrc_get_physical_device_info(softs, device, 1725 bmic_phy_info); 1726 } 1727 /* Logical device doesn't have SAS address 1728 * so requires target SAS address for MSA. 1729 */ 1730 if(device->is_external_raid_device) 1731 device->sas_address = BE_64((uint64_t)lun_ext_entry->lunid); 1732 new_dev_cnt++; 1733 break; 1734 case ENCLOSURE_DEVICE: 1735 if (device->is_physical_device) { 1736 device->sas_address = BE_64(lun_ext_entry->wwid); 1737 } 1738 new_dev_cnt++; 1739 break; 1740 case TAPE_DEVICE: 1741 case MEDIUM_CHANGER_DEVICE: 1742 new_dev_cnt++; 1743 break; 1744 case RAID_DEVICE: 1745 /* 1746 * Only present the HBA controller itself as a RAID 1747 * controller. If it's a RAID controller other than 1748 * the HBA itself (an external RAID controller, MSA500 1749 * or similar), don't present it. 1750 */ 1751 if (pqisrc_is_hba_lunid(scsi3addr)) 1752 new_dev_cnt++; 1753 break; 1754 } 1755 } 1756 DBG_INFO("new_dev_cnt %d\n", new_dev_cnt); 1757 1758 pqisrc_update_device_list(softs, new_device_list, new_dev_cnt); 1759 1760 err_out: 1761 if (new_device_list) { 1762 for (i = 0; i < ndev_allocated; i++) { 1763 if (new_device_list[i]) { 1764 if(new_device_list[i]->raid_map) 1765 os_mem_free(softs, (char *)new_device_list[i]->raid_map, 1766 sizeof(pqisrc_raid_map_t)); 1767 os_mem_free(softs, (char*)new_device_list[i], 1768 sizeof(*new_device_list[i])); 1769 } 1770 } 1771 os_mem_free(softs, (char *)new_device_list, 1772 sizeof(*new_device_list) * ndev_allocated); 1773 } 1774 if(physical_dev_list) 1775 os_mem_free(softs, (char *)physical_dev_list, phys_data_length); 1776 if(logical_dev_list) 1777 os_mem_free(softs, (char *)logical_dev_list, log_data_length); 1778 if (bmic_phy_info) 1779 os_mem_free(softs, (char *)bmic_phy_info, sizeof(*bmic_phy_info)); 1780 1781 DBG_FUNC("OUT \n"); 1782 1783 return ret; 1784 } 1785 1786 /* 1787 * Clean up memory allocated for devices. 1788 */ 1789 void pqisrc_cleanup_devices(pqisrc_softstate_t *softs) 1790 { 1791 1792 int i = 0,j = 0; 1793 pqi_scsi_dev_t *dvp = NULL; 1794 DBG_FUNC("IN\n"); 1795 1796 for(i = 0; i < PQI_MAX_DEVICES; i++) { 1797 for(j = 0; j < PQI_MAX_MULTILUN; j++) { 1798 if (softs->device_list[i][j] == NULL) 1799 continue; 1800 dvp = softs->device_list[i][j]; 1801 pqisrc_device_mem_free(softs, dvp); 1802 } 1803 } 1804 DBG_FUNC("OUT\n"); 1805 } 1806 1807