sys/dev/smartpqi/smartpqi_discovery.c

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