smartpqi_response.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    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 /*
   31  * Process internal RAID response in the case of success.
   32  */
   33 void
   34 pqisrc_process_internal_raid_response_success(pqisrc_softstate_t *softs,rcb_t *rcb)
   35 {
   36         DBG_FUNC("IN");
   37 
   38         rcb->status = REQUEST_SUCCESS;
   39         rcb->req_pending = false;
   40 
   41         DBG_FUNC("OUT");
   42 }
   43 
   44 /*
   45  * Process internal RAID response in the case of failure.
   46  */
   47 void
   48 pqisrc_process_internal_raid_response_error(pqisrc_softstate_t *softs,
   49                                        rcb_t *rcb, uint16_t err_idx)
   50 {
   51         raid_path_error_info_elem_t error_info;
   52 
   53         DBG_FUNC("IN");
   54 
   55         rcb->error_info = (char *) (softs->err_buf_dma_mem.virt_addr) +
   56                           (err_idx * PQI_ERROR_BUFFER_ELEMENT_LENGTH);
   57 
   58         memcpy(&error_info, rcb->error_info, sizeof(error_info));
   59 
   60         DBG_INFO("error_status 0x%x data_in_result 0x%x data_out_result 0x%x\n",
   61                 error_info.status, error_info.data_in_result, error_info.data_out_result);
   62 
   63         rcb->status = REQUEST_FAILED;
   64 
   65         switch (error_info.data_out_result) {
   66         case PQI_RAID_DATA_IN_OUT_GOOD:
   67                 if (error_info.status == PQI_RAID_DATA_IN_OUT_GOOD)
   68                         rcb->status = REQUEST_SUCCESS;
   69                 break;
   70         case PQI_RAID_DATA_IN_OUT_UNDERFLOW:
   71                 if (error_info.status == PQI_RAID_DATA_IN_OUT_GOOD ||
   72                                 error_info.status == PQI_RAID_STATUS_CHECK_CONDITION)
   73                         rcb->status = REQUEST_SUCCESS;
   74                 break;
   75         }
   76 
   77         rcb->req_pending = false;
   78 
   79         DBG_FUNC("OUT");
   80 }
   81 
   82 /*
   83  * Process the AIO/RAID IO in the case of success.
   84  */
   85 void
   86 pqisrc_process_io_response_success(pqisrc_softstate_t *softs, rcb_t *rcb)
   87 {
   88         DBG_FUNC("IN");
   89 
   90         os_io_response_success(rcb);
   91 
   92         DBG_FUNC("OUT");
   93 }
   94 
   95 static void
   96 pqisrc_extract_sense_data(sense_data_u_t *sense_data, uint8_t *key, uint8_t *asc, uint8_t *ascq)
   97 {
   98         if (sense_data->fixed_format.response_code == SCSI_SENSE_RESPONSE_70 ||
   99                 sense_data->fixed_format.response_code == SCSI_SENSE_RESPONSE_71)
  100         {
  101                 sense_data_fixed_t *fixed = &sense_data->fixed_format;
  102 
  103                 *key = fixed->sense_key;
  104                 *asc = fixed->sense_code;
  105                 *ascq = fixed->sense_qual;
  106         }
  107         else if (sense_data->descriptor_format.response_code == SCSI_SENSE_RESPONSE_72 ||
  108                 sense_data->descriptor_format.response_code == SCSI_SENSE_RESPONSE_73)
  109         {
  110                 sense_data_descriptor_t *desc = &sense_data->descriptor_format;
  111 
  112                 *key = desc->sense_key;
  113                 *asc = desc->sense_code;
  114                 *ascq = desc->sense_qual;
  115         }
  116         else
  117         {
  118                 *key = 0xFF;
  119                 *asc = 0xFF;
  120                 *ascq = 0xFF;
  121         }
  122 }
  123 
  124 static void
  125 pqisrc_show_sense_data_simple(pqisrc_softstate_t *softs, rcb_t *rcb, sense_data_u_t *sense_data)
  126 {
  127         uint8_t opcode = rcb->cdbp ? rcb->cdbp[0] : 0xFF;
  128         char *path = io_path_to_ascii(rcb->path);
  129         uint8_t key, asc, ascq;
  130         pqisrc_extract_sense_data(sense_data, &key, &asc, &ascq);
  131 
  132         DBG_NOTE("[ERR INFO] BTL: %d:%d:%d op=0x%x path=%s K:C:Q: %x:%x:%x\n",
  133                 rcb->dvp->bus, rcb->dvp->target, rcb->dvp->lun,
  134                 opcode, path, key, asc, ascq);
  135 }
  136 
  137 void
  138 pqisrc_show_sense_data_full(pqisrc_softstate_t *softs, rcb_t *rcb, sense_data_u_t *sense_data)
  139 {
  140         pqisrc_print_buffer(softs, "sense data", sense_data, 32, 0);
  141 
  142         pqisrc_show_sense_data_simple(softs, rcb, sense_data);
  143 
  144         /* add more detail here as needed */
  145 }
  146 
  147 
  148 /*
  149  * Process the error info for AIO in the case of failure.
  150  */
  151 void
  152 pqisrc_process_aio_response_error(pqisrc_softstate_t *softs,
  153                 rcb_t *rcb, uint16_t err_idx)
  154 {
  155         aio_path_error_info_elem_t *err_info = NULL;
  156 
  157         DBG_FUNC("IN");
  158 
  159         err_info = (aio_path_error_info_elem_t*)
  160                         softs->err_buf_dma_mem.virt_addr +
  161                         err_idx;
  162 
  163         if(err_info == NULL) {
  164                 DBG_ERR("err_info structure is NULL  err_idx :%x", err_idx);
  165                 return;
  166         }
  167 
  168         os_aio_response_error(rcb, err_info);
  169 
  170         DBG_FUNC("OUT");
  171 }
  172 
  173 /*
  174  * Process the error info for RAID IO in the case of failure.
  175  */
  176 void
  177 pqisrc_process_raid_response_error(pqisrc_softstate_t *softs,
  178                 rcb_t *rcb, uint16_t err_idx)
  179 {
  180         raid_path_error_info_elem_t *err_info = NULL;
  181 
  182         DBG_FUNC("IN");
  183 
  184         err_info = (raid_path_error_info_elem_t*)
  185                         softs->err_buf_dma_mem.virt_addr +
  186                         err_idx;
  187 
  188         if(err_info == NULL) {
  189                 DBG_ERR("err_info structure is NULL  err_idx :%x", err_idx);
  190                 return;
  191         }
  192 
  193         os_raid_response_error(rcb, err_info);
  194 
  195         DBG_FUNC("OUT");
  196 }
  197 
  198 /*
  199  * Process the Task Management function response.
  200  */
  201 int
  202 pqisrc_process_task_management_response(pqisrc_softstate_t *softs,
  203                         pqi_tmf_resp_t *tmf_resp)
  204 {
  205         int ret = REQUEST_SUCCESS;
  206         uint32_t tag = (uint32_t)tmf_resp->req_id;
  207         rcb_t *rcb = &softs->rcb[tag];
  208 
  209         ASSERT(rcb->tag == tag);
  210 
  211         DBG_FUNC("IN\n");
  212 
  213         switch (tmf_resp->resp_code) {
  214         case SOP_TASK_MANAGEMENT_FUNCTION_COMPLETE:
  215         case SOP_TASK_MANAGEMENT_FUNCTION_SUCCEEDED:
  216                 ret = REQUEST_SUCCESS;
  217                 break;
  218         default:
  219                 DBG_WARN("TMF Failed, Response code : 0x%x\n", tmf_resp->resp_code);
  220                 ret = REQUEST_FAILED;
  221                 break;
  222         }
  223 
  224         rcb->status = ret;
  225         rcb->req_pending = false;
  226 
  227         DBG_FUNC("OUT");
  228         return ret;
  229 }
  230 
  231 static int
  232 pqisrc_process_vendor_general_response(pqi_vendor_general_response_t *response)
  233 {
  234 
  235         int ret = REQUEST_SUCCESS;
  236 
  237         switch(response->status) {
  238         case PQI_VENDOR_RESPONSE_IU_SUCCESS:
  239                 break;
  240         case PQI_VENDOR_RESPONSE_IU_UNSUCCESS:
  241         case PQI_VENDOR_RESPONSE_IU_INVALID_PARAM:
  242         case PQI_VENDOR_RESPONSE_IU_INSUFF_RESRC:
  243                 ret = REQUEST_FAILED;
  244                 break;
  245         }
  246 
  247         return ret;
  248 }
  249 
  250 /*
  251  * Function used to process the response from the adapter
  252  * which is invoked by IRQ handler.
  253  */
  254 void
  255 pqisrc_process_response_queue(pqisrc_softstate_t *softs, int oq_id)
  256 {
  257         ob_queue_t *ob_q;
  258         struct pqi_io_response *response;
  259         uint32_t oq_pi, oq_ci;
  260         pqi_scsi_dev_t  *dvp = NULL;
  261 
  262         DBG_FUNC("IN");
  263 
  264         ob_q = &softs->op_ob_q[oq_id - 1]; /* zero for event Q */
  265         oq_ci = ob_q->ci_local;
  266         oq_pi = *(ob_q->pi_virt_addr);
  267 
  268         DBG_INFO("ci : %d pi : %d qid : %d\n", oq_ci, oq_pi, ob_q->q_id);
  269 
  270         while (1) {
  271                 rcb_t *rcb = NULL;
  272                 uint32_t tag = 0;
  273                 uint32_t offset;
  274                 boolean_t os_scsi_cmd = false;
  275 
  276                 if (oq_pi == oq_ci)
  277                         break;
  278                 /* Get the response */
  279                 offset = oq_ci * ob_q->elem_size;
  280                 response = (struct pqi_io_response *)(ob_q->array_virt_addr +
  281                                                         offset);
  282                 tag = response->request_id;
  283                 rcb = &softs->rcb[tag];
  284                 /* Make sure we are processing a valid response. */
  285                 if ((rcb->tag != tag) || (rcb->req_pending == false)) {
  286                         DBG_ERR("No such request pending with tag : %x", tag);
  287                         oq_ci = (oq_ci + 1) % ob_q->num_elem;
  288                         break;
  289                 }
  290                 /* Timedout request has been completed. This should not hit,
  291                  * if timeout is set as TIMEOUT_INFINITE while calling
  292                  * pqisrc_wait_on_condition(softs,rcb,timeout).
  293                  */
  294                 if (rcb->timedout) {
  295                         DBG_WARN("timed out request completing from firmware, driver already completed it with failure , free the tag %d\n", tag);
  296                         oq_ci = (oq_ci + 1) % ob_q->num_elem;
  297                         os_reset_rcb(rcb);
  298                         pqisrc_put_tag(&softs->taglist, tag);
  299                         break;
  300                 }
  301 
  302                 if (IS_OS_SCSICMD(rcb)) {
  303                         dvp = rcb->dvp;
  304                         if (dvp)
  305                                 os_scsi_cmd = true;
  306                         else
  307                                 DBG_WARN("Received IO completion for the Null device!!!\n");
  308                 }
  309 
  310 
  311                 DBG_INFO("response.header.iu_type : %x \n", response->header.iu_type);
  312 
  313                 switch (response->header.iu_type) {
  314                 case PQI_RESPONSE_IU_RAID_PATH_IO_SUCCESS:
  315                 case PQI_RESPONSE_IU_AIO_PATH_IO_SUCCESS:
  316                         rcb->success_cmp_callback(softs, rcb);
  317                         if (os_scsi_cmd)
  318                                 pqisrc_decrement_device_active_io(softs, dvp);
  319 
  320                         break;
  321                 case PQI_RESPONSE_IU_RAID_PATH_IO_ERROR:
  322                 case PQI_RESPONSE_IU_AIO_PATH_IO_ERROR:
  323                         rcb->error_cmp_callback(softs, rcb, LE_16(response->error_index));
  324                         if (os_scsi_cmd)
  325                                 pqisrc_decrement_device_active_io(softs, dvp);
  326                         break;
  327                 case PQI_RESPONSE_IU_GENERAL_MANAGEMENT:
  328                         rcb->req_pending = false;
  329                         break;
  330                 case PQI_RESPONSE_IU_VENDOR_GENERAL:
  331                         rcb->req_pending = false;
  332                         rcb->status = pqisrc_process_vendor_general_response(
  333                                                                 (pqi_vendor_general_response_t *)response);
  334                         break;
  335                 case PQI_RESPONSE_IU_TASK_MANAGEMENT:
  336                         rcb->status = pqisrc_process_task_management_response(softs, (void *)response);
  337                         break;
  338 
  339                 default:
  340                         DBG_ERR("Invalid Response IU 0x%x\n",response->header.iu_type);
  341                         break;
  342                 }
  343 
  344                 oq_ci = (oq_ci + 1) % ob_q->num_elem;
  345         }
  346 
  347         ob_q->ci_local = oq_ci;
  348         PCI_MEM_PUT32(softs, ob_q->ci_register_abs,
  349         ob_q->ci_register_offset, ob_q->ci_local );
  350         DBG_FUNC("OUT");
  351 }
Cache object: 6e7fa9f1bd7ef0bdd2f7b8186fc30af4
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.
FreeBSD/Linux Kernel Cross Reference sys/dev/smartpqi/smartpqi_response.c

FreeBSD/Linux Kernel Cross Reference
sys/dev/smartpqi/smartpqi_response.c
