sys/dev/smartpqi/smartpqi_init.c

   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 /* 5 mins timeout for quiesce */
  31 #define PQI_QUIESCE_TIMEOUT     300000
  32
  33 /*
  34  * Request the adapter to get PQI capabilities supported.
  35  */
  36 static int
  37 pqisrc_report_pqi_capability(pqisrc_softstate_t *softs)
  38 {
  39         int ret = PQI_STATUS_SUCCESS;
  40
  41         DBG_FUNC("IN\n");
  42
  43         gen_adm_req_iu_t        admin_req;
  44         gen_adm_resp_iu_t       admin_resp;
  45         dma_mem_t               pqi_cap_dma_buf;
  46         pqi_dev_cap_t           *capability = NULL;
  47         pqi_iu_layer_desc_t     *iu_layer_desc = NULL;
  48
  49         /* Allocate Non DMA memory */
  50         capability = os_mem_alloc(softs, sizeof(*capability));
  51         if (!capability) {
  52                 DBG_ERR("Failed to allocate memory for capability\n");
  53                 ret = PQI_STATUS_FAILURE;
  54                 goto err_out;
  55         }
  56
  57         memset(&admin_req, 0, sizeof(admin_req));
  58         memset(&admin_resp, 0, sizeof(admin_resp));
  59
  60         memset(&pqi_cap_dma_buf, 0, sizeof(struct dma_mem));
  61         pqi_cap_dma_buf.tag = "pqi_cap_buf";
  62         pqi_cap_dma_buf.size = REPORT_PQI_DEV_CAP_DATA_BUF_SIZE;
  63         pqi_cap_dma_buf.align = PQISRC_DEFAULT_DMA_ALIGN;
  64
  65         ret = os_dma_mem_alloc(softs, &pqi_cap_dma_buf);
  66         if (ret) {
  67                 DBG_ERR("Failed to allocate capability DMA buffer : %d\n", ret);
  68                 goto err_dma_alloc;
  69         }
  70
  71         admin_req.fn_code = PQI_FUNCTION_REPORT_DEV_CAP;
  72         admin_req.req_type.general_func.buf_size = pqi_cap_dma_buf.size;
  73         admin_req.req_type.general_func.sg_desc.length = pqi_cap_dma_buf.size;
  74         admin_req.req_type.general_func.sg_desc.addr = pqi_cap_dma_buf.dma_addr;
  75         admin_req.req_type.general_func.sg_desc.type =  SGL_DESCRIPTOR_CODE_DATA_BLOCK;
  76
  77         ret = pqisrc_submit_admin_req(softs, &admin_req, &admin_resp);
  78         if( PQI_STATUS_SUCCESS == ret) {
  79                 memcpy(capability,
  80                         pqi_cap_dma_buf.virt_addr,
  81                         pqi_cap_dma_buf.size);
  82         } else {
  83                 DBG_ERR("Failed to send admin req report pqi device capability\n");
  84                 goto err_admin_req;
  85
  86         }
  87
  88         softs->pqi_dev_cap.max_iqs = capability->max_iqs;
  89         softs->pqi_dev_cap.max_iq_elements = capability->max_iq_elements;
  90         softs->pqi_dev_cap.max_iq_elem_len = capability->max_iq_elem_len;
  91         softs->pqi_dev_cap.min_iq_elem_len = capability->min_iq_elem_len;
  92         softs->pqi_dev_cap.max_oqs = capability->max_oqs;
  93         softs->pqi_dev_cap.max_oq_elements = capability->max_oq_elements;
  94         softs->pqi_dev_cap.max_oq_elem_len = capability->max_oq_elem_len;
  95         softs->pqi_dev_cap.intr_coales_time_granularity = capability->intr_coales_time_granularity;
  96
  97         iu_layer_desc = &capability->iu_layer_desc[PQI_PROTOCOL_SOP];
  98         softs->max_ib_iu_length_per_fw = iu_layer_desc->max_ib_iu_len;
  99         softs->ib_spanning_supported = iu_layer_desc->ib_spanning_supported;
 100         softs->ob_spanning_supported = iu_layer_desc->ob_spanning_supported;
 101
 102         DBG_INIT("softs->pqi_dev_cap.max_iqs: %d\n", softs->pqi_dev_cap.max_iqs);
 103         DBG_INIT("softs->pqi_dev_cap.max_iq_elements: %d\n", softs->pqi_dev_cap.max_iq_elements);
 104         DBG_INIT("softs->pqi_dev_cap.max_iq_elem_len: %d\n", softs->pqi_dev_cap.max_iq_elem_len);
 105         DBG_INIT("softs->pqi_dev_cap.min_iq_elem_len: %d\n", softs->pqi_dev_cap.min_iq_elem_len);
 106         DBG_INIT("softs->pqi_dev_cap.max_oqs: %d\n", softs->pqi_dev_cap.max_oqs);
 107         DBG_INIT("softs->pqi_dev_cap.max_oq_elements: %d\n", softs->pqi_dev_cap.max_oq_elements);
 108         DBG_INIT("softs->pqi_dev_cap.max_oq_elem_len: %d\n", softs->pqi_dev_cap.max_oq_elem_len);
 109         DBG_INIT("softs->pqi_dev_cap.intr_coales_time_granularity: %d\n", softs->pqi_dev_cap.intr_coales_time_granularity);
 110         DBG_INIT("softs->max_ib_iu_length_per_fw: %d\n", softs->max_ib_iu_length_per_fw);
 111         DBG_INIT("softs->ib_spanning_supported: %d\n", softs->ib_spanning_supported);
 112         DBG_INIT("softs->ob_spanning_supported: %d\n", softs->ob_spanning_supported);
 113
 114
 115         os_mem_free(softs, (void *)capability,
 116                     REPORT_PQI_DEV_CAP_DATA_BUF_SIZE);
 117         os_dma_mem_free(softs, &pqi_cap_dma_buf);
 118
 119         DBG_FUNC("OUT\n");
 120         return ret;
 121
 122 err_admin_req:
 123         os_dma_mem_free(softs, &pqi_cap_dma_buf);
 124 err_dma_alloc:
 125         if (capability)
 126                 os_mem_free(softs, (void *)capability,
 127                             REPORT_PQI_DEV_CAP_DATA_BUF_SIZE);
 128 err_out:
 129         DBG_FUNC("failed OUT\n");
 130         return PQI_STATUS_FAILURE;
 131 }
 132
 133 /*
 134  * Function used to deallocate the used rcb.
 135  */
 136 void
 137 pqisrc_free_rcb(pqisrc_softstate_t *softs, int req_count)
 138 {
 139         uint32_t num_req;
 140         size_t size;
 141         int i;
 142
 143         DBG_FUNC("IN\n");
 144         num_req = softs->max_outstanding_io + 1;
 145         size = num_req * sizeof(rcb_t);
 146         for (i = 1; i < req_count; i++)
 147                 os_dma_mem_free(softs, &softs->sg_dma_desc[i]);
 148         os_mem_free(softs, (void *)softs->rcb, size);
 149         softs->rcb = NULL;
 150         DBG_FUNC("OUT\n");
 151 }
 152
 153
 154 /*
 155  * Allocate memory for rcb and SG descriptors.
 156  */
 157 static int
 158 pqisrc_allocate_rcb(pqisrc_softstate_t *softs)
 159 {
 160         int ret = PQI_STATUS_SUCCESS;
 161         int i = 0;
 162         uint32_t num_req = 0;
 163         uint32_t sg_buf_size = 0;
 164         uint64_t alloc_size = 0;
 165         rcb_t *rcb = NULL;
 166         rcb_t *prcb = NULL;
 167         DBG_FUNC("IN\n");
 168
 169         /* Set maximum outstanding requests */
 170         /* The valid tag values are from 1, 2, ..., softs->max_outstanding_io
 171          * The rcb will be accessed by using the tag as index
 172          * As 0 tag index is not used, we need to allocate one extra.
 173          */
 174         softs->max_outstanding_io = softs->pqi_cap.max_outstanding_io;
 175         num_req = softs->max_outstanding_io + 1;
 176         DBG_INIT("Max Outstanding IO reset to %d\n", num_req);
 177
 178         alloc_size = num_req * sizeof(rcb_t);
 179
 180         /* Allocate Non DMA memory */
 181         rcb = os_mem_alloc(softs, alloc_size);
 182         if (!rcb) {
 183                 DBG_ERR("Failed to allocate memory for rcb\n");
 184                 ret = PQI_STATUS_FAILURE;
 185                 goto err_out;
 186         }
 187         softs->rcb = rcb;
 188
 189         /* Allocate sg dma memory for sg chain  */
 190         sg_buf_size = softs->pqi_cap.max_sg_elem *
 191                         sizeof(sgt_t);
 192
 193         prcb = &softs->rcb[1];
 194         /* Initialize rcb */
 195         for(i=1; i < num_req; i++) {
 196                 char tag[15];
 197                 sprintf(tag, "sg_dma_buf%d", i);
 198                 softs->sg_dma_desc[i].tag = tag;
 199                 softs->sg_dma_desc[i].size = sg_buf_size;
 200                 softs->sg_dma_desc[i].align = PQISRC_DEFAULT_DMA_ALIGN;
 201
 202                 ret = os_dma_mem_alloc(softs, &softs->sg_dma_desc[i]);
 203                 if (ret) {
 204                         DBG_ERR("Failed to Allocate sg desc %d\n", ret);
 205                         ret = PQI_STATUS_FAILURE;
 206                         goto error;
 207                 }
 208                 prcb->sg_chain_virt = (sgt_t *)(softs->sg_dma_desc[i].virt_addr);
 209                 prcb->sg_chain_dma = (dma_addr_t)(softs->sg_dma_desc[i].dma_addr);
 210                 prcb ++;
 211         }
 212
 213         DBG_FUNC("OUT\n");
 214         return ret;
 215 error:
 216         pqisrc_free_rcb(softs, i);
 217 err_out:
 218         DBG_FUNC("failed OUT\n");
 219         return ret;
 220 }
 221
 222 /*
 223  * Function used to decide the operational queue configuration params
 224  * - no of ibq/obq, shared/non-shared interrupt resource, IU spanning support
 225  */
 226 void
 227 pqisrc_decide_opq_config(pqisrc_softstate_t *softs)
 228 {
 229         uint16_t total_iq_elements;
 230
 231         DBG_FUNC("IN\n");
 232
 233         DBG_INIT("softs->intr_count : %d  softs->num_cpus_online : %d",
 234                 softs->intr_count, softs->num_cpus_online);
 235
 236         if (softs->intr_count == 1 || softs->num_cpus_online == 1) {
 237                 /* Share the event and Operational queue. */
 238                 softs->num_op_obq = 1;
 239                 softs->share_opq_and_eventq = true;
 240         }
 241         else {
 242                 /* Note :  One OBQ (OBQ0) reserved for event queue */
 243                 softs->num_op_obq = MIN(softs->num_cpus_online,
 244                                         softs->intr_count) - 1;
 245                 softs->share_opq_and_eventq = false;
 246         }
 247         /* If the available interrupt count is more than one,
 248         we dont need to share the interrupt for IO and event queue */
 249         if (softs->intr_count > 1)
 250                 softs->share_opq_and_eventq = false;
 251
 252         DBG_INIT("softs->num_op_obq : %d\n",softs->num_op_obq);
 253
 254         softs->num_op_raid_ibq = softs->num_op_obq;
 255         softs->num_op_aio_ibq = softs->num_op_raid_ibq;
 256         softs->ibq_elem_size =  softs->pqi_dev_cap.max_iq_elem_len * 16;
 257         softs->obq_elem_size = softs->pqi_dev_cap.max_oq_elem_len * 16;
 258         if (softs->max_ib_iu_length_per_fw == 256 &&
 259             softs->ob_spanning_supported) {
 260                 /* older f/w that doesn't actually support spanning. */
 261                 softs->max_ib_iu_length = softs->ibq_elem_size;
 262         } else {
 263                 /* max. inbound IU length is an multiple of our inbound element size. */
 264                 softs->max_ib_iu_length =
 265                         (softs->max_ib_iu_length_per_fw / softs->ibq_elem_size) *
 266                          softs->ibq_elem_size;
 267
 268         }
 269         /* If Max. Outstanding IO came with Max. Spanning element count then,
 270                 needed elements per IO are multiplication of
 271                 Max.Outstanding IO and  Max.Spanning element */
 272         total_iq_elements = (softs->max_outstanding_io *
 273                 (softs->max_ib_iu_length / softs->ibq_elem_size));
 274
 275         softs->num_elem_per_op_ibq = total_iq_elements / softs->num_op_raid_ibq;
 276         softs->num_elem_per_op_ibq = MIN(softs->num_elem_per_op_ibq,
 277                 softs->pqi_dev_cap.max_iq_elements);
 278
 279         softs->num_elem_per_op_obq = softs->max_outstanding_io / softs->num_op_obq;
 280         softs->num_elem_per_op_obq = MIN(softs->num_elem_per_op_obq,
 281                 softs->pqi_dev_cap.max_oq_elements);
 282
 283         softs->max_sg_per_iu = ((softs->max_ib_iu_length -
 284                                 softs->ibq_elem_size) /
 285                                 sizeof(sgt_t)) +
 286                                 MAX_EMBEDDED_SG_IN_FIRST_IU;
 287
 288         DBG_INIT("softs->max_ib_iu_length: %d\n", softs->max_ib_iu_length);
 289         DBG_INIT("softs->num_elem_per_op_ibq: %d\n", softs->num_elem_per_op_ibq);
 290         DBG_INIT("softs->num_elem_per_op_obq: %d\n", softs->num_elem_per_op_obq);
 291         DBG_INIT("softs->max_sg_per_iu: %d\n", softs->max_sg_per_iu);
 292
 293         DBG_FUNC("OUT\n");
 294 }
 295
 296 /*
 297  * Configure the operational queue parameters.
 298  */
 299 int
 300 pqisrc_configure_op_queues(pqisrc_softstate_t *softs)
 301 {
 302         int ret = PQI_STATUS_SUCCESS;
 303
 304         /* Get the PQI capability,
 305                 REPORT PQI DEVICE CAPABILITY request */
 306         ret = pqisrc_report_pqi_capability(softs);
 307         if (ret) {
 308                 DBG_ERR("Failed to send report pqi dev capability request : %d\n",
 309                                 ret);
 310                 goto err_out;
 311         }
 312
 313         /* Reserve required no of slots for internal requests */
 314         softs->max_io_for_scsi_ml = softs->max_outstanding_io - PQI_RESERVED_IO_SLOTS_CNT;
 315
 316         /* Decide the Op queue configuration */
 317         pqisrc_decide_opq_config(softs);
 318
 319         DBG_FUNC("OUT\n");
 320         return ret;
 321
 322 err_out:
 323         DBG_FUNC("OUT failed\n");
 324         return ret;
 325 }
 326
 327 /*
 328  * Validate the PQI mode of adapter.
 329  */
 330 int
 331 pqisrc_check_pqimode(pqisrc_softstate_t *softs)
 332 {
 333         int ret = PQI_STATUS_FAILURE;
 334         int tmo = 0;
 335         uint64_t signature = 0;
 336
 337         DBG_FUNC("IN\n");
 338
 339         /* Check the PQI device signature */
 340         tmo = PQISRC_PQIMODE_READY_TIMEOUT;
 341         do {
 342                 signature = LE_64(PCI_MEM_GET64(softs, &softs->pqi_reg->signature, PQI_SIGNATURE));
 343
 344                 if (memcmp(&signature, PQISRC_PQI_DEVICE_SIGNATURE,
 345                                 sizeof(uint64_t)) == 0) {
 346                         ret = PQI_STATUS_SUCCESS;
 347                         break;
 348                 }
 349                 OS_SLEEP(PQISRC_MODE_READY_POLL_INTERVAL);
 350         } while (tmo--);
 351
 352         PRINT_PQI_SIGNATURE(signature);
 353
 354         if (tmo <= 0) {
 355                 DBG_ERR("PQI Signature is invalid\n");
 356                 ret = PQI_STATUS_TIMEOUT;
 357                 goto err_out;
 358         }
 359
 360         tmo = PQISRC_PQIMODE_READY_TIMEOUT;
 361         /* Check function and status code for the device */
 362         COND_WAIT((PCI_MEM_GET64(softs, &softs->pqi_reg->admin_q_config,
 363                 PQI_ADMINQ_CONFIG) == PQI_ADMIN_QUEUE_CONF_FUNC_STATUS_IDLE), tmo);
 364         if (!tmo) {
 365                 DBG_ERR("PQI device is not in IDLE state\n");
 366                 ret = PQI_STATUS_TIMEOUT;
 367                 goto err_out;
 368         }
 369
 370
 371         tmo = PQISRC_PQIMODE_READY_TIMEOUT;
 372         /* Check the PQI device status register */
 373         COND_WAIT(LE_32(PCI_MEM_GET32(softs, &softs->pqi_reg->pqi_dev_status, PQI_DEV_STATUS)) &
 374                                 PQI_DEV_STATE_AT_INIT, tmo);
 375         if (!tmo) {
 376                 DBG_ERR("PQI Registers are not ready\n");
 377                 ret = PQI_STATUS_TIMEOUT;
 378                 goto err_out;
 379         }
 380
 381         DBG_FUNC("OUT\n");
 382         return ret;
 383 err_out:
 384         DBG_FUNC("OUT failed\n");
 385         return ret;
 386 }
 387
 388 /* PQI Feature processing */
 389 static int
 390 pqisrc_config_table_update(struct pqisrc_softstate *softs,
 391         uint16_t first_section, uint16_t last_section)
 392 {
 393         pqi_vendor_general_request_t request;
 394         int ret = PQI_STATUS_FAILURE;
 395
 396         memset(&request, 0, sizeof(request));
 397
 398         request.header.iu_type = PQI_REQUEST_IU_VENDOR_GENERAL;
 399         request.header.iu_length = sizeof(request) - PQI_REQUEST_HEADER_LENGTH;
 400         request.function_code = PQI_VENDOR_GENERAL_CONFIG_TABLE_UPDATE;
 401         request.data.config_table_update.first_section = first_section;
 402         request.data.config_table_update.last_section = last_section;
 403
 404         ret = pqisrc_build_send_vendor_request(softs, &request, NULL);
 405
 406         if (ret != PQI_STATUS_SUCCESS) {
 407                 DBG_ERR("Failed to submit vendor general request IU, Ret status: %d\n", ret);
 408                 return PQI_STATUS_FAILURE;
 409         }
 410
 411         return PQI_STATUS_SUCCESS;
 412 }
 413
 414 static inline
 415 boolean_t pqi_is_firmware_feature_supported(
 416         struct pqi_conf_table_firmware_features *firmware_feature_list,
 417         unsigned int bit_position)
 418 {
 419         unsigned int byte_index;
 420
 421         byte_index = bit_position / BITS_PER_BYTE;
 422
 423         if (byte_index >= firmware_feature_list->num_elements)
 424                 return false;
 425
 426         return firmware_feature_list->features_supported[byte_index] &
 427                 (1 << (bit_position % BITS_PER_BYTE)) ? true : false;
 428 }
 429
 430 static inline
 431 boolean_t pqi_is_firmware_feature_enabled(
 432         struct pqi_conf_table_firmware_features *firmware_feature_list,
 433         uint8_t *firmware_features_addr, unsigned int bit_position)
 434 {
 435         unsigned int byte_index;
 436         uint8_t *feature_enabled_addr;
 437
 438         byte_index = (bit_position / BITS_PER_BYTE) +
 439                 (firmware_feature_list->num_elements * 2);
 440
 441         feature_enabled_addr = firmware_features_addr +
 442                 offsetof(struct pqi_conf_table_firmware_features,
 443                         features_supported) + byte_index;
 444
 445         return *feature_enabled_addr &
 446                 (1 << (bit_position % BITS_PER_BYTE)) ? true : false;
 447 }
 448
 449 static inline void
 450 pqi_request_firmware_feature(
 451         struct pqi_conf_table_firmware_features *firmware_feature_list,
 452         unsigned int bit_position)
 453 {
 454         unsigned int byte_index;
 455
 456         byte_index = (bit_position / BITS_PER_BYTE) +
 457                 firmware_feature_list->num_elements;
 458
 459         firmware_feature_list->features_supported[byte_index] |=
 460                 (1 << (bit_position % BITS_PER_BYTE));
 461 }
 462
 463 /* Update PQI config table firmware features section and inform the firmware */
 464 static int
 465 pqisrc_set_host_requested_firmware_feature(pqisrc_softstate_t *softs,
 466         struct pqi_conf_table_firmware_features *firmware_feature_list)
 467 {
 468         uint8_t *request_feature_addr;
 469         void *request_feature_abs_addr;
 470
 471         request_feature_addr = firmware_feature_list->features_supported +
 472                 firmware_feature_list->num_elements;
 473         request_feature_abs_addr = softs->fw_features_section_abs_addr +
 474                 (request_feature_addr - (uint8_t*)firmware_feature_list);
 475
 476         os_io_memcpy(request_feature_abs_addr, request_feature_addr,
 477                         firmware_feature_list->num_elements);
 478
 479         return pqisrc_config_table_update(softs,
 480                 PQI_CONF_TABLE_SECTION_FIRMWARE_FEATURES,
 481                 PQI_CONF_TABLE_SECTION_FIRMWARE_FEATURES);
 482 }
 483
 484 /* Check firmware has enabled the feature specified in the respective bit position. */
 485 inline boolean_t
 486 pqisrc_is_firmware_feature_enabled(pqisrc_softstate_t *softs,
 487                 struct pqi_conf_table_firmware_features *firmware_feature_list, uint16_t bit_position)
 488 {
 489         uint16_t byte_index;
 490         uint8_t *features_enabled_abs_addr;
 491
 492         byte_index = (bit_position / BITS_PER_BYTE) +
 493                 (firmware_feature_list->num_elements * 2);
 494
 495         features_enabled_abs_addr = softs->fw_features_section_abs_addr +
 496         offsetof(struct pqi_conf_table_firmware_features,features_supported) + byte_index;
 497
 498         return *features_enabled_abs_addr &
 499                 (1 << (bit_position % BITS_PER_BYTE)) ? true : false;
 500 }
 501
 502 static void
 503 pqi_firmware_feature_status(struct pqisrc_softstate     *softs,
 504         struct pqi_firmware_feature *firmware_feature)
 505 {
 506         switch(firmware_feature->feature_bit) {
 507         case PQI_FIRMWARE_FEATURE_OFA:
 508                 break;
 509         case PQI_FIRMWARE_FEATURE_TIMEOUT_IN_RAID_IU_SUPPORT:
 510                 softs->timeout_in_passthrough = true;
 511                 break;
 512         case PQI_FIRMWARE_FEATURE_TIMEOUT_IN_TMF_IU_SUPPORT:
 513                 softs->timeout_in_tmf = true;
 514                 break;
 515         default:
 516                 DBG_NOTE("Nothing to do \n");
 517         }
 518 }
 519
 520 /* Firmware features supported by the driver */
 521 static struct
 522 pqi_firmware_feature pqi_firmware_features[] = {
 523         {
 524                 .feature_name = "Support timeout for pass-through commands",
 525                 .feature_bit = PQI_FIRMWARE_FEATURE_TIMEOUT_IN_RAID_IU_SUPPORT,
 526                 .feature_status = pqi_firmware_feature_status,
 527         },
 528         {
 529                 .feature_name = "Support timeout for LUN Reset TMF",
 530                 .feature_bit = PQI_FIRMWARE_FEATURE_TIMEOUT_IN_TMF_IU_SUPPORT,
 531                 .feature_status = pqi_firmware_feature_status,
 532         }
 533 };
 534
 535 static void
 536 pqisrc_process_firmware_features(pqisrc_softstate_t *softs)
 537 {
 538         int rc;
 539         struct pqi_conf_table_firmware_features *firmware_feature_list;
 540         unsigned int i;
 541         unsigned int num_features_requested;
 542
 543         firmware_feature_list = (struct pqi_conf_table_firmware_features*)
 544                 softs->fw_features_section_abs_addr;
 545
 546         /* Check features and request those supported by firmware and driver.*/
 547         for (i = 0, num_features_requested = 0;
 548                 i < ARRAY_SIZE(pqi_firmware_features); i++) {
 549                 /* Firmware support it ? */
 550                 if (pqi_is_firmware_feature_supported(firmware_feature_list,
 551                                 pqi_firmware_features[i].feature_bit)) {
 552                         pqi_request_firmware_feature(firmware_feature_list,
 553                                 pqi_firmware_features[i].feature_bit);
 554                         pqi_firmware_features[i].supported = true;
 555                         num_features_requested++;
 556                         DBG_NOTE("%s supported by driver, requesting firmware to enable it\n",
 557                                         pqi_firmware_features[i].feature_name);
 558                 } else {
 559                         DBG_NOTE("%s supported by driver, but not by current firmware\n",
 560                                         pqi_firmware_features[i].feature_name);
 561                 }
 562         }
 563         if (num_features_requested == 0)
 564                 return;
 565
 566         rc = pqisrc_set_host_requested_firmware_feature(softs, firmware_feature_list);
 567         if (rc) {
 568                 DBG_ERR("Failed to update pqi config table\n");
 569                 return;
 570         }
 571
 572         for (i = 0; i < ARRAY_SIZE(pqi_firmware_features); i++) {
 573                 if (pqi_is_firmware_feature_enabled(firmware_feature_list,
 574                         softs->fw_features_section_abs_addr, pqi_firmware_features[i].feature_bit)) {
 575                         pqi_firmware_features[i].enabled = true;
 576                         DBG_NOTE("Firmware feature %s enabled \n",pqi_firmware_features[i].feature_name);
 577                         if(pqi_firmware_features[i].feature_status)
 578                                 pqi_firmware_features[i].feature_status(softs, &(pqi_firmware_features[i]));
 579                 }
 580         }
 581 }
 582
 583 /*
 584  * Get the PQI configuration table parameters.
 585  * Currently using for heart-beat counter scratch-pad register.
 586  */
 587 int
 588 pqisrc_process_config_table(pqisrc_softstate_t *softs)
 589 {
 590         int ret = PQI_STATUS_FAILURE;
 591         uint32_t config_table_size;
 592         uint32_t section_off;
 593         uint8_t *config_table_abs_addr;
 594         struct pqi_conf_table *conf_table;
 595         struct pqi_conf_table_section_header *section_hdr;
 596
 597         config_table_size = softs->pqi_cap.conf_tab_sz;
 598
 599         if (config_table_size < sizeof(*conf_table) ||
 600                 config_table_size > PQI_CONF_TABLE_MAX_LEN) {
 601                 DBG_ERR("Invalid PQI conf table length of %u\n",
 602                         config_table_size);
 603                 return ret;
 604         }
 605
 606         conf_table = os_mem_alloc(softs, config_table_size);
 607         if (!conf_table) {
 608                 DBG_ERR("Failed to allocate memory for PQI conf table\n");
 609                 return ret;
 610         }
 611
 612         if (config_table_size < sizeof(conf_table) ||
 613                 config_table_size > PQI_CONF_TABLE_MAX_LEN) {
 614                 DBG_ERR("Invalid PQI conf table length of %u\n",
 615                         config_table_size);
 616                 goto out;
 617         }
 618
 619         config_table_abs_addr = (uint8_t *)(softs->pci_mem_base_vaddr +
 620                                         softs->pqi_cap.conf_tab_off);
 621
 622         PCI_MEM_GET_BUF(softs, config_table_abs_addr,
 623                         softs->pqi_cap.conf_tab_off,
 624                         (uint8_t*)conf_table, config_table_size);
 625
 626
 627         if (memcmp(conf_table->sign, PQI_CONF_TABLE_SIGNATURE,
 628                         sizeof(conf_table->sign)) != 0) {
 629                 DBG_ERR("Invalid PQI config signature\n");
 630                 goto out;
 631         }
 632
 633         section_off = LE_32(conf_table->first_section_off);
 634
 635         while (section_off) {
 636
 637                 if (section_off+ sizeof(*section_hdr) >= config_table_size) {
 638                         DBG_INFO("Reached end of PQI config table. Breaking off.\n");
 639                         break;
 640                 }
 641
 642                 section_hdr = (struct pqi_conf_table_section_header *)((uint8_t *)conf_table + section_off);
 643
 644                 switch (LE_16(section_hdr->section_id)) {
 645                 case PQI_CONF_TABLE_SECTION_GENERAL_INFO:
 646                 case PQI_CONF_TABLE_SECTION_FIRMWARE_ERRATA:
 647                 case PQI_CONF_TABLE_SECTION_DEBUG:
 648                         break;
 649                 case PQI_CONF_TABLE_SECTION_FIRMWARE_FEATURES:
 650                         softs->fw_features_section_off = softs->pqi_cap.conf_tab_off + section_off;
 651                         softs->fw_features_section_abs_addr = softs->pci_mem_base_vaddr + softs->fw_features_section_off;
 652                         pqisrc_process_firmware_features(softs);
 653                 break;
 654                 case PQI_CONF_TABLE_SECTION_HEARTBEAT:
 655                 softs->heartbeat_counter_off = softs->pqi_cap.conf_tab_off +
 656                                                 section_off +
 657                                                 offsetof(struct pqi_conf_table_heartbeat,
 658                                                 heartbeat_counter);
 659                 softs->heartbeat_counter_abs_addr = (uint64_t *)(softs->pci_mem_base_vaddr +
 660                                                         softs->heartbeat_counter_off);
 661                 ret = PQI_STATUS_SUCCESS;
 662                 break;
 663                 default:
 664                 DBG_INFO("unrecognized PQI config table section ID: 0x%x\n",
 665                                         LE_16(section_hdr->section_id));
 666                 break;
 667                 }
 668                 section_off = LE_16(section_hdr->next_section_off);
 669         }
 670 out:
 671         os_mem_free(softs, (void *)conf_table,config_table_size);
 672         return ret;
 673 }
 674
 675 /* Wait for PQI reset completion for the adapter*/
 676 int
 677 pqisrc_wait_for_pqi_reset_completion(pqisrc_softstate_t *softs)
 678 {
 679         int ret = PQI_STATUS_SUCCESS;
 680         pqi_reset_reg_t reset_reg;
 681         int pqi_reset_timeout = 0;
 682         uint64_t val = 0;
 683         uint32_t max_timeout = 0;
 684
 685         val = PCI_MEM_GET64(softs, &softs->pqi_reg->pqi_dev_adminq_cap, PQI_ADMINQ_CAP);
 686
 687         max_timeout = (val & 0xFFFF00000000) >> 32;
 688
 689         DBG_INIT("max_timeout for PQI reset completion in 100 msec units = %u\n", max_timeout);
 690
 691         while(1) {
 692                 if (pqi_reset_timeout++ == max_timeout) {
 693                         return PQI_STATUS_TIMEOUT;
 694                 }
 695                 OS_SLEEP(PQI_RESET_POLL_INTERVAL);/* 100 msec */
 696                 reset_reg.all_bits = PCI_MEM_GET32(softs,
 697                         &softs->pqi_reg->dev_reset, PQI_DEV_RESET);
 698                 if (reset_reg.bits.reset_action == PQI_RESET_ACTION_COMPLETED)
 699                         break;
 700         }
 701
 702         return ret;
 703 }
 704
 705 /*
 706  * Function used to perform PQI hard reset.
 707  */
 708 int
 709 pqi_reset(pqisrc_softstate_t *softs)
 710 {
 711         int ret = PQI_STATUS_SUCCESS;
 712         uint32_t val = 0;
 713         pqi_reset_reg_t pqi_reset_reg;
 714
 715         DBG_FUNC("IN\n");
 716
 717         if (true == softs->ctrl_in_pqi_mode) {
 718
 719                 if (softs->pqi_reset_quiesce_allowed) {
 720                         val = PCI_MEM_GET32(softs, &softs->ioa_reg->host_to_ioa_db,
 721                                         LEGACY_SIS_IDBR);
 722                         val |= SIS_PQI_RESET_QUIESCE;
 723                         PCI_MEM_PUT32(softs, &softs->ioa_reg->host_to_ioa_db,
 724                                         LEGACY_SIS_IDBR, LE_32(val));
 725                         ret = pqisrc_sis_wait_for_db_bit_to_clear(softs, SIS_PQI_RESET_QUIESCE);
 726                         if (ret) {
 727                                 DBG_ERR("failed with error %d during quiesce\n", ret);
 728                                 return ret;
 729                         }
 730                 }
 731
 732                 pqi_reset_reg.all_bits = 0;
 733                 pqi_reset_reg.bits.reset_type = PQI_RESET_TYPE_HARD_RESET;
 734                 pqi_reset_reg.bits.reset_action = PQI_RESET_ACTION_RESET;
 735
 736                 PCI_MEM_PUT32(softs, &softs->pqi_reg->dev_reset, PQI_DEV_RESET,
 737                         LE_32(pqi_reset_reg.all_bits));
 738
 739                 ret = pqisrc_wait_for_pqi_reset_completion(softs);
 740                 if (ret) {
 741                         DBG_ERR("PQI reset timed out: ret = %d!\n", ret);
 742                         return ret;
 743                 }
 744         }
 745         softs->ctrl_in_pqi_mode = false;
 746         DBG_FUNC("OUT\n");
 747         return ret;
 748 }
 749
 750 /*
 751  * Initialize the adapter with supported PQI configuration.
 752  */
 753 int
 754 pqisrc_pqi_init(pqisrc_softstate_t *softs)
 755 {
 756         int ret = PQI_STATUS_SUCCESS;
 757
 758         DBG_FUNC("IN\n");
 759
 760         /* Check the PQI signature */
 761         ret = pqisrc_check_pqimode(softs);
 762         if(ret) {
 763                 DBG_ERR("failed to switch to pqi\n");
 764                 goto err_out;
 765         }
 766
 767         PQI_SAVE_CTRL_MODE(softs, CTRL_PQI_MODE);
 768         softs->ctrl_in_pqi_mode = true;
 769
 770         /* Get the No. of Online CPUs,NUMA/Processor config from OS */
 771         ret = os_get_processor_config(softs);
 772         if (ret) {
 773                 DBG_ERR("Failed to get processor config from OS %d\n",
 774                         ret);
 775                 goto err_out;
 776         }
 777
 778         softs->intr_type = INTR_TYPE_NONE;
 779
 780         /* Get the interrupt count, type, priority available from OS */
 781         ret = os_get_intr_config(softs);
 782         if (ret) {
 783                 DBG_ERR("Failed to get interrupt config from OS %d\n",
 784                         ret);
 785                 goto err_out;
 786         }
 787
 788         /*Enable/Set Legacy INTx Interrupt mask clear pqi register,
 789          *if allocated interrupt is legacy type.
 790          */
 791         if (INTR_TYPE_FIXED == softs->intr_type) {
 792                 pqisrc_configure_legacy_intx(softs, true);
 793                 sis_enable_intx(softs);
 794         }
 795
 796         /* Create Admin Queue pair*/
 797         ret = pqisrc_create_admin_queue(softs);
 798         if(ret) {
 799                 DBG_ERR("Failed to configure admin queue\n");
 800                 goto err_admin_queue;
 801         }
 802
 803         /* For creating event and IO operational queues we have to submit
 804            admin IU requests.So Allocate resources for submitting IUs */
 805
 806         /* Allocate the request container block (rcb) */
 807         ret = pqisrc_allocate_rcb(softs);
 808         if (ret == PQI_STATUS_FAILURE) {
 809                 DBG_ERR("Failed to allocate rcb \n");
 810                 goto err_rcb;
 811         }
 812
 813         /* Allocate & initialize request id queue */
 814         ret = pqisrc_init_taglist(softs,&softs->taglist,
 815                                 softs->max_outstanding_io);
 816         if (ret) {
 817                 DBG_ERR("Failed to allocate memory for request id q : %d\n",
 818                         ret);
 819                 goto err_taglist;
 820         }
 821
 822         ret = pqisrc_configure_op_queues(softs);
 823         if (ret) {
 824                         DBG_ERR("Failed to configure op queue\n");
 825                         goto err_config_opq;
 826         }
 827
 828         /* Create Operational queues */
 829         ret = pqisrc_create_op_queues(softs);
 830         if(ret) {
 831                 DBG_ERR("Failed to create op queue\n");
 832                 ret = PQI_STATUS_FAILURE;
 833                 goto err_create_opq;
 834         }
 835
 836         softs->ctrl_online = true;
 837
 838         DBG_FUNC("OUT\n");
 839         return ret;
 840
 841 err_create_opq:
 842 err_config_opq:
 843         pqisrc_destroy_taglist(softs,&softs->taglist);
 844 err_taglist:
 845         pqisrc_free_rcb(softs, softs->max_outstanding_io + 1);
 846 err_rcb:
 847         pqisrc_destroy_admin_queue(softs);
 848 err_admin_queue:
 849         os_free_intr_config(softs);
 850 err_out:
 851         DBG_FUNC("OUT failed\n");
 852         return PQI_STATUS_FAILURE;
 853 }
 854
 855 int
 856 pqisrc_force_sis(pqisrc_softstate_t *softs)
 857 {
 858         int ret = PQI_STATUS_SUCCESS;
 859
 860         if (SIS_IS_KERNEL_PANIC(softs)) {
 861                 DBG_INIT("Controller FW is not runnning");
 862                 return PQI_STATUS_FAILURE;
 863         }
 864
 865         if (PQI_GET_CTRL_MODE(softs) == CTRL_SIS_MODE) {
 866                 return ret;
 867         }
 868
 869         if (SIS_IS_KERNEL_UP(softs)) {
 870                 PQI_SAVE_CTRL_MODE(softs, CTRL_SIS_MODE);
 871                 return ret;
 872         }
 873         /* Disable interrupts ? */
 874         sis_disable_interrupt(softs);
 875
 876         /* reset pqi, this will delete queues */
 877         ret = pqi_reset(softs);
 878         if (ret) {
 879                 return ret;
 880         }
 881         /* Re enable SIS */
 882         ret = pqisrc_reenable_sis(softs);
 883         if (ret) {
 884                 return ret;
 885         }
 886
 887         PQI_SAVE_CTRL_MODE(softs, CTRL_SIS_MODE);
 888
 889         return ret;
 890 }
 891
 892 static int
 893 pqisrc_wait_for_cmnd_complete(pqisrc_softstate_t *softs)
 894 {
 895         int count = 0;
 896         int ret = PQI_STATUS_SUCCESS;
 897
 898         DBG_NOTE("softs->taglist.num_elem : %d",softs->taglist.num_elem);
 899
 900         if (softs->taglist.num_elem == softs->max_outstanding_io)
 901                 return ret;
 902         else {
 903                 DBG_WARN("%d commands pending\n",
 904                 softs->max_outstanding_io - softs->taglist.num_elem);
 905
 906                 while(1) {
 907
 908                         /* Since heartbeat timer stopped ,check for firmware status*/
 909                         if (SIS_IS_KERNEL_PANIC(softs)) {
 910                                 DBG_ERR("Controller FW is not running\n");
 911                                 return PQI_STATUS_FAILURE;
 912                         }
 913
 914                         if (softs->taglist.num_elem != softs->max_outstanding_io) {
 915                                 /* Sleep for 1 msec */
 916                                 OS_SLEEP(1000);
 917                                 count++;
 918                                 if(count % 1000 == 0) {
 919                                         DBG_WARN("Waited for %d seconds", count/1000);
 920                                 }
 921                                 if (count >= PQI_QUIESCE_TIMEOUT) {
 922                                         return PQI_STATUS_FAILURE;
 923                                 }
 924                                 continue;
 925                         }
 926                         break;
 927                 }
 928         }
 929         return ret;
 930 }
 931
 932 static void
 933 pqisrc_complete_internal_cmds(pqisrc_softstate_t *softs)
 934 {
 935
 936         int tag = 0;
 937         rcb_t *rcb;
 938
 939         for (tag = 1; tag <= softs->max_outstanding_io; tag++) {
 940                 rcb = &softs->rcb[tag];
 941                 if(rcb->req_pending && is_internal_req(rcb)) {
 942                         rcb->status = REQUEST_FAILED;
 943                         rcb->req_pending = false;
 944                 }
 945         }
 946 }
 947
 948
 949 /*
 950  * Uninitialize the resources used during PQI initialization.
 951  */
 952 void
 953 pqisrc_pqi_uninit(pqisrc_softstate_t *softs)
 954 {
 955         int i, ret;
 956
 957         DBG_FUNC("IN\n");
 958
 959         /* Wait for any rescan to finish */
 960         pqisrc_wait_for_rescan_complete(softs);
 961
 962         /* Wait for commands to complete */
 963         ret = pqisrc_wait_for_cmnd_complete(softs);
 964
 965         /* disable and free the interrupt resources */
 966         os_destroy_intr(softs);
 967
 968         /* Complete all pending commands. */
 969         if(ret != PQI_STATUS_SUCCESS) {
 970                 pqisrc_complete_internal_cmds(softs);
 971                 os_complete_outstanding_cmds_nodevice(softs);
 972         }
 973
 974         if(softs->devlist_lockcreated==true){
 975                 os_uninit_spinlock(&softs->devlist_lock);
 976                 softs->devlist_lockcreated = false;
 977         }
 978
 979         for (i = 0; i <  softs->num_op_raid_ibq; i++) {
 980                 /* OP RAID IB Q */
 981                 if(softs->op_raid_ib_q[i].lockcreated==true){
 982                         OS_UNINIT_PQILOCK(&softs->op_raid_ib_q[i].lock);
 983                         softs->op_raid_ib_q[i].lockcreated = false;
 984                 }
 985                 /* OP AIO IB Q */
 986                 if(softs->op_aio_ib_q[i].lockcreated==true){
 987                         OS_UNINIT_PQILOCK(&softs->op_aio_ib_q[i].lock);
 988                         softs->op_aio_ib_q[i].lockcreated = false;
 989                 }
 990         }
 991
 992         /* Free Op queues */
 993         os_dma_mem_free(softs, &softs->op_ibq_dma_mem);
 994         os_dma_mem_free(softs, &softs->op_obq_dma_mem);
 995         os_dma_mem_free(softs, &softs->event_q_dma_mem);
 996
 997
 998
 999         /* Free  rcb */
1000         pqisrc_free_rcb(softs, softs->max_outstanding_io + 1);
1001
1002         /* Free request id lists */
1003         pqisrc_destroy_taglist(softs,&softs->taglist);
1004
1005         if(softs->admin_ib_queue.lockcreated==true) {
1006                 OS_UNINIT_PQILOCK(&softs->admin_ib_queue.lock);
1007                 softs->admin_ib_queue.lockcreated = false;
1008         }
1009
1010         /* Free Admin Queue */
1011         os_dma_mem_free(softs, &softs->admin_queue_dma_mem);
1012
1013         /* Switch back to SIS mode */
1014         if (pqisrc_force_sis(softs)) {
1015                 DBG_ERR("Failed to switch back the adapter to SIS mode!\n");
1016         }
1017
1018         DBG_FUNC("OUT\n");
1019 }
1020
1021 /*
1022  * Function to initialize the adapter settings.
1023  */
1024 int
1025 pqisrc_init(pqisrc_softstate_t *softs)
1026 {
1027         int ret = 0;
1028         int i = 0, j = 0;
1029
1030         DBG_FUNC("IN\n");
1031
1032         check_struct_sizes();
1033
1034         /* Init the Sync interface */
1035         ret = pqisrc_sis_init(softs);
1036         if (ret) {
1037                 DBG_ERR("SIS Init failed with error %d\n", ret);
1038                 goto err_out;
1039         }
1040
1041         ret = os_create_semaphore("scan_lock", 1, &softs->scan_lock);
1042         if(ret != PQI_STATUS_SUCCESS){
1043                 DBG_ERR(" Failed to initialize scan lock\n");
1044                 goto err_scan_lock;
1045         }
1046
1047         /* Init the PQI interface */
1048         ret = pqisrc_pqi_init(softs);
1049         if (ret) {
1050                 DBG_ERR("PQI Init failed with error %d\n", ret);
1051                 goto err_pqi;
1052         }
1053
1054         /* Setup interrupt */
1055         ret = os_setup_intr(softs);
1056         if (ret) {
1057                 DBG_ERR("Interrupt setup failed with error %d\n", ret);
1058                 goto err_intr;
1059         }
1060
1061         /* Report event configuration */
1062         ret = pqisrc_report_event_config(softs);
1063         if(ret){
1064                 DBG_ERR(" Failed to configure Report events\n");
1065                 goto err_event;
1066         }
1067
1068         /* Set event configuration*/
1069         ret = pqisrc_set_event_config(softs);
1070         if(ret){
1071                 DBG_ERR(" Failed to configure Set events\n");
1072                 goto err_event;
1073         }
1074
1075         /* Check for For PQI spanning */
1076         ret = pqisrc_get_ctrl_fw_version(softs);
1077         if(ret){
1078                 DBG_ERR(" Failed to get ctrl fw version\n");
1079                 goto err_fw_version;
1080         }
1081
1082         /* update driver version in to FW */
1083         ret = pqisrc_write_driver_version_to_host_wellness(softs);
1084         if (ret) {
1085                 DBG_ERR(" Failed to update driver version in to FW");
1086                 goto err_host_wellness;
1087         }
1088
1089
1090         os_strlcpy(softs->devlist_lock_name, "devlist_lock", LOCKNAME_SIZE);
1091         ret = os_init_spinlock(softs, &softs->devlist_lock, softs->devlist_lock_name);
1092         if(ret){
1093                 DBG_ERR(" Failed to initialize devlist_lock\n");
1094                 softs->devlist_lockcreated=false;
1095                 goto err_lock;
1096         }
1097         softs->devlist_lockcreated = true;
1098
1099         /* Get the PQI configuration table to read heart-beat counter*/
1100         ret = pqisrc_process_config_table(softs);
1101         if (ret) {
1102                 DBG_ERR("Failed to process PQI configuration table %d\n", ret);
1103                 goto err_config_tab;
1104         }
1105
1106         softs->prev_heartbeat_count = CTRLR_HEARTBEAT_CNT(softs) - OS_FW_HEARTBEAT_TIMER_INTERVAL;
1107
1108         /* Init device list */
1109         for(i = 0; i < PQI_MAX_DEVICES; i++)
1110                 for(j = 0; j < PQI_MAX_MULTILUN; j++)
1111                         softs->device_list[i][j] = NULL;
1112
1113         pqisrc_init_targetid_pool(softs);
1114
1115         DBG_FUNC("OUT\n");
1116         return ret;
1117
1118 err_config_tab:
1119         if(softs->devlist_lockcreated==true){
1120                 os_uninit_spinlock(&softs->devlist_lock);
1121                 softs->devlist_lockcreated = false;
1122         }
1123 err_lock:
1124 err_fw_version:
1125 err_event:
1126 err_host_wellness:
1127 err_intr:
1128         pqisrc_pqi_uninit(softs);
1129 err_pqi:
1130         os_destroy_semaphore(&softs->scan_lock);
1131 err_scan_lock:
1132         pqisrc_sis_uninit(softs);
1133 err_out:
1134         DBG_FUNC("OUT failed\n");
1135         return ret;
1136 }
1137
1138 /*
1139  * Write all data in the adapter's battery-backed cache to
1140  * storage.
1141  */
1142 int
1143 pqisrc_flush_cache( pqisrc_softstate_t *softs,
1144                         enum pqisrc_flush_cache_event_type event_type)
1145 {
1146         int rval = PQI_STATUS_SUCCESS;
1147         pqisrc_raid_req_t request;
1148         pqisrc_bmic_flush_cache_t *flush_buff = NULL;
1149
1150         DBG_FUNC("IN\n");
1151
1152         if (pqisrc_ctrl_offline(softs))
1153                 return PQI_STATUS_FAILURE;
1154
1155         flush_buff = os_mem_alloc(softs, sizeof(pqisrc_bmic_flush_cache_t));
1156         if (!flush_buff) {
1157                 DBG_ERR("Failed to allocate memory for flush cache params\n");
1158                 rval = PQI_STATUS_FAILURE;
1159                 return rval;
1160         }
1161
1162         flush_buff->halt_event = event_type;
1163
1164         memset(&request, 0, sizeof(request));
1165
1166         rval = pqisrc_build_send_raid_request(softs, &request, flush_buff,
1167                         sizeof(*flush_buff), SA_CACHE_FLUSH, 0,
1168                         (uint8_t *)RAID_CTLR_LUNID, NULL);
1169         if (rval) {
1170                 DBG_ERR("error in build send raid req ret=%d\n", rval);
1171         }
1172
1173         if (flush_buff)
1174                 os_mem_free(softs, (void *)flush_buff,
1175                         sizeof(pqisrc_bmic_flush_cache_t));
1176
1177         DBG_FUNC("OUT\n");
1178
1179         return rval;
1180 }
1181
1182 /*
1183  * Uninitialize the adapter.
1184  */
1185 void
1186 pqisrc_uninit(pqisrc_softstate_t *softs)
1187 {
1188         DBG_FUNC("IN\n");
1189
1190         pqisrc_pqi_uninit(softs);
1191
1192         pqisrc_sis_uninit(softs);
1193
1194         os_destroy_semaphore(&softs->scan_lock);
1195
1196         pqisrc_cleanup_devices(softs);
1197
1198         DBG_FUNC("OUT\n");
1199 }