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 } 352