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