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 #define SG_FLAG_LAST 0x40000000 32 #define SG_FLAG_CHAIN 0x80000000 33 34 /* Subroutine to find out embedded sgl count in IU */ 35 static inline 36 uint32_t pqisrc_embedded_sgl_count(uint32_t elem_alloted) 37 { 38 uint32_t embedded_sgl_count = MAX_EMBEDDED_SG_IN_FIRST_IU; 39 DBG_FUNC(" IN "); 40 /** 41 calculate embedded sgl count using num_elem_alloted for IO 42 **/ 43 if(elem_alloted - 1) 44 embedded_sgl_count += ((elem_alloted - 1) * MAX_EMBEDDED_SG_IN_IU); 45 DBG_IO("embedded_sgl_count :%d\n",embedded_sgl_count); 46 47 DBG_FUNC(" OUT "); 48 49 return embedded_sgl_count; 50 51 } 52 53 /* Subroutine to find out contiguous free elem in IU */ 54 static inline 55 uint32_t pqisrc_contiguous_free_elem(uint32_t pi, uint32_t ci, uint32_t elem_in_q) 56 { 57 uint32_t contiguous_free_elem = 0; 58 59 DBG_FUNC(" IN "); 60 61 if(pi >= ci) { 62 contiguous_free_elem = (elem_in_q - pi); 63 if(ci == 0) 64 contiguous_free_elem -= 1; 65 } else { 66 contiguous_free_elem = (ci - pi - 1); 67 } 68 69 DBG_FUNC(" OUT "); 70 71 return contiguous_free_elem; 72 } 73 74 /* Subroutine to find out num of elements need for the request */ 75 static uint32_t 76 pqisrc_num_elem_needed(pqisrc_softstate_t *softs, uint32_t SG_Count) 77 { 78 uint32_t num_sg; 79 uint32_t num_elem_required = 1; 80 DBG_FUNC(" IN "); 81 DBG_IO("SGL_Count :%d",SG_Count); 82 /******** 83 If SG_Count greater than max sg per IU i.e 4 or 68 84 (4 is with out spanning or 68 is with spanning) chaining is required. 85 OR, If SG_Count <= MAX_EMBEDDED_SG_IN_FIRST_IU then, 86 on these two cases one element is enough. 87 ********/ 88 if(SG_Count > softs->max_sg_per_iu || SG_Count <= MAX_EMBEDDED_SG_IN_FIRST_IU) 89 return num_elem_required; 90 /* 91 SGL Count Other Than First IU 92 */ 93 num_sg = SG_Count - MAX_EMBEDDED_SG_IN_FIRST_IU; 94 num_elem_required += PQISRC_DIV_ROUND_UP(num_sg, MAX_EMBEDDED_SG_IN_IU); 95 DBG_FUNC(" OUT "); 96 return num_elem_required; 97 } 98 99 /* Subroutine to build SG list for the IU submission*/ 100 static 101 boolean_t pqisrc_build_sgl(sgt_t *sg_array, rcb_t *rcb, iu_header_t *iu_hdr, 102 uint32_t num_elem_alloted) 103 { 104 uint32_t i; 105 uint32_t num_sg = OS_GET_IO_SG_COUNT(rcb); 106 sgt_t *sgt = sg_array; 107 sgt_t *sg_chain = NULL; 108 boolean_t partial = false; 109 110 DBG_FUNC(" IN "); 111 112 DBG_IO("SGL_Count :%d",num_sg); 113 if (0 == num_sg) { 114 goto out; 115 } 116 117 if (num_sg <= pqisrc_embedded_sgl_count(num_elem_alloted)) { 118 for (i = 0; i < num_sg; i++, sgt++) { 119 sgt->addr= OS_GET_IO_SG_ADDR(rcb,i); 120 sgt->len= OS_GET_IO_SG_LEN(rcb,i); 121 sgt->flags= 0; 122 } 123 124 sg_array[num_sg - 1].flags = SG_FLAG_LAST; 125 } else { 126 /** 127 SGL Chaining 128 **/ 129 sg_chain = rcb->sg_chain_virt; 130 sgt->addr = rcb->sg_chain_dma; 131 sgt->len = num_sg * sizeof(sgt_t); 132 sgt->flags = SG_FLAG_CHAIN; 133 134 sgt = sg_chain; 135 for (i = 0; i < num_sg; i++, sgt++) { 136 sgt->addr = OS_GET_IO_SG_ADDR(rcb,i); 137 sgt->len = OS_GET_IO_SG_LEN(rcb,i); 138 sgt->flags = 0; 139 } 140 141 sg_chain[num_sg - 1].flags = SG_FLAG_LAST; 142 num_sg = 1; 143 partial = true; 144 145 } 146 out: 147 iu_hdr->iu_length = num_sg * sizeof(sgt_t); 148 DBG_FUNC(" OUT "); 149 return partial; 150 151 } 152 153 /*Subroutine used to Build the RAID request */ 154 static void 155 pqisrc_build_raid_io(pqisrc_softstate_t *softs, rcb_t *rcb, 156 pqisrc_raid_req_t *raid_req, uint32_t num_elem_alloted) 157 { 158 DBG_FUNC(" IN "); 159 160 raid_req->header.iu_type = PQI_IU_TYPE_RAID_PATH_IO_REQUEST; 161 raid_req->header.comp_feature = 0; 162 raid_req->response_queue_id = OS_GET_IO_RESP_QID(softs, rcb); 163 raid_req->work_area[0] = 0; 164 raid_req->work_area[1] = 0; 165 raid_req->request_id = rcb->tag; 166 raid_req->nexus_id = 0; 167 raid_req->buffer_length = GET_SCSI_BUFFLEN(rcb); 168 memcpy(raid_req->lun_number, rcb->dvp->scsi3addr, 169 sizeof(raid_req->lun_number)); 170 raid_req->protocol_spec = 0; 171 raid_req->data_direction = rcb->data_dir; 172 raid_req->reserved1 = 0; 173 raid_req->fence = 0; 174 raid_req->error_index = raid_req->request_id; 175 raid_req->reserved2 = 0; 176 raid_req->task_attribute = OS_GET_TASK_ATTR(rcb); 177 raid_req->command_priority = 0; 178 raid_req->reserved3 = 0; 179 raid_req->reserved4 = 0; 180 raid_req->reserved5 = 0; 181 182 /* As cdb and additional_cdb_bytes are contiguous, 183 update them in a single statement */ 184 memcpy(raid_req->cdb, rcb->cdbp, rcb->cmdlen); 185 #if 0 186 DBG_IO("CDB :"); 187 for(i = 0; i < rcb->cmdlen ; i++) 188 DBG_IO(" 0x%x \n ",raid_req->cdb[i]); 189 #endif 190 191 switch (rcb->cmdlen) { 192 case 6: 193 case 10: 194 case 12: 195 case 16: 196 raid_req->additional_cdb_bytes_usage = 197 PQI_ADDITIONAL_CDB_BYTES_0; 198 break; 199 case 20: 200 raid_req->additional_cdb_bytes_usage = 201 PQI_ADDITIONAL_CDB_BYTES_4; 202 break; 203 case 24: 204 raid_req->additional_cdb_bytes_usage = 205 PQI_ADDITIONAL_CDB_BYTES_8; 206 break; 207 case 28: 208 raid_req->additional_cdb_bytes_usage = 209 PQI_ADDITIONAL_CDB_BYTES_12; 210 break; 211 case 32: 212 default: /* todo:review again */ 213 raid_req->additional_cdb_bytes_usage = 214 PQI_ADDITIONAL_CDB_BYTES_16; 215 break; 216 } 217 218 /* Frame SGL Descriptor */ 219 raid_req->partial = pqisrc_build_sgl(&raid_req->sg_descriptors[0], rcb, 220 &raid_req->header, num_elem_alloted); 221 222 raid_req->header.iu_length += 223 offsetof(pqisrc_raid_req_t, sg_descriptors) - sizeof(iu_header_t); 224 225 #if 0 226 DBG_IO("raid_req->header.iu_type : 0x%x", raid_req->header.iu_type); 227 DBG_IO("raid_req->response_queue_id :%d\n"raid_req->response_queue_id); 228 DBG_IO("raid_req->request_id : 0x%x", raid_req->request_id); 229 DBG_IO("raid_req->buffer_length : 0x%x", raid_req->buffer_length); 230 DBG_IO("raid_req->task_attribute : 0x%x", raid_req->task_attribute); 231 DBG_IO("raid_req->lun_number : 0x%x", raid_req->lun_number); 232 DBG_IO("raid_req->error_index : 0x%x", raid_req->error_index); 233 DBG_IO("raid_req->sg_descriptors[0].addr : %p", (void*)raid_req->sg_descriptors[0].addr); 234 DBG_IO("raid_req->sg_descriptors[0].len : 0x%x", raid_req->sg_descriptors[0].len); 235 DBG_IO("raid_req->sg_descriptors[0].flags : 0%x", raid_req->sg_descriptors[0].flags); 236 #endif 237 rcb->success_cmp_callback = pqisrc_process_io_response_success; 238 rcb->error_cmp_callback = pqisrc_process_raid_response_error; 239 rcb->resp_qid = raid_req->response_queue_id; 240 241 DBG_FUNC(" OUT "); 242 243 } 244 245 /*Subroutine used to Build the AIO request */ 246 static void 247 pqisrc_build_aio_io(pqisrc_softstate_t *softs, rcb_t *rcb, 248 pqi_aio_req_t *aio_req, uint32_t num_elem_alloted) 249 { 250 DBG_FUNC(" IN "); 251 252 aio_req->header.iu_type = PQI_IU_TYPE_AIO_PATH_IO_REQUEST; 253 aio_req->header.comp_feature = 0; 254 aio_req->response_queue_id = OS_GET_IO_RESP_QID(softs, rcb); 255 aio_req->work_area[0] = 0; 256 aio_req->work_area[1] = 0; 257 aio_req->req_id = rcb->tag; 258 aio_req->res1[0] = 0; 259 aio_req->res1[1] = 0; 260 aio_req->nexus = rcb->ioaccel_handle; 261 aio_req->buf_len = GET_SCSI_BUFFLEN(rcb); 262 aio_req->data_dir = rcb->data_dir; 263 aio_req->mem_type = 0; 264 aio_req->fence = 0; 265 aio_req->res2 = 0; 266 aio_req->task_attr = OS_GET_TASK_ATTR(rcb); 267 aio_req->cmd_prio = 0; 268 aio_req->res3 = 0; 269 aio_req->err_idx = aio_req->req_id; 270 aio_req->cdb_len = rcb->cmdlen; 271 if(rcb->cmdlen > sizeof(aio_req->cdb)) 272 rcb->cmdlen = sizeof(aio_req->cdb); 273 memcpy(aio_req->cdb, rcb->cdbp, rcb->cmdlen); 274 #if 0 275 DBG_IO("CDB : \n"); 276 for(int i = 0; i < rcb->cmdlen ; i++) 277 DBG_IO(" 0x%x \n",aio_req->cdb[i]); 278 #endif 279 memset(aio_req->lun,0,sizeof(aio_req->lun)); 280 memset(aio_req->res4,0,sizeof(aio_req->res4)); 281 282 if(rcb->encrypt_enable == true) { 283 aio_req->encrypt_enable = true; 284 aio_req->encrypt_key_index = LE_16(rcb->enc_info.data_enc_key_index); 285 aio_req->encrypt_twk_low = LE_32(rcb->enc_info.encrypt_tweak_lower); 286 aio_req->encrypt_twk_high = LE_32(rcb->enc_info.encrypt_tweak_upper); 287 } else { 288 aio_req->encrypt_enable = 0; 289 aio_req->encrypt_key_index = 0; 290 aio_req->encrypt_twk_high = 0; 291 aio_req->encrypt_twk_low = 0; 292 } 293 294 /* Frame SGL Descriptor */ 295 aio_req->partial = pqisrc_build_sgl(&aio_req->sg_desc[0], rcb, 296 &aio_req->header, num_elem_alloted); 297 298 aio_req->num_sg = aio_req->header.iu_length / sizeof(sgt_t); 299 300 DBG_INFO("aio_req->num_sg :%d",aio_req->num_sg); 301 302 aio_req->header.iu_length += offsetof(pqi_aio_req_t, sg_desc) - 303 sizeof(iu_header_t); 304 #if 0 305 DBG_IO("aio_req->header.iu_type : 0x%x \n",aio_req->header.iu_type); 306 DBG_IO("aio_req->resp_qid :0x%x",aio_req->resp_qid); 307 DBG_IO("aio_req->req_id : 0x%x \n",aio_req->req_id); 308 DBG_IO("aio_req->nexus : 0x%x \n",aio_req->nexus); 309 DBG_IO("aio_req->buf_len : 0x%x \n",aio_req->buf_len); 310 DBG_IO("aio_req->data_dir : 0x%x \n",aio_req->data_dir); 311 DBG_IO("aio_req->task_attr : 0x%x \n",aio_req->task_attr); 312 DBG_IO("aio_req->err_idx : 0x%x \n",aio_req->err_idx); 313 DBG_IO("aio_req->num_sg :%d",aio_req->num_sg); 314 DBG_IO("aio_req->sg_desc[0].addr : %p \n", (void*)aio_req->sg_desc[0].addr); 315 DBG_IO("aio_req->sg_desc[0].len : 0%x \n", aio_req->sg_desc[0].len); 316 DBG_IO("aio_req->sg_desc[0].flags : 0%x \n", aio_req->sg_desc[0].flags); 317 #endif 318 319 rcb->success_cmp_callback = pqisrc_process_io_response_success; 320 rcb->error_cmp_callback = pqisrc_process_aio_response_error; 321 rcb->resp_qid = aio_req->response_queue_id; 322 323 DBG_FUNC(" OUT "); 324 325 } 326 327 /*Function used to build and send RAID/AIO */ 328 int pqisrc_build_send_io(pqisrc_softstate_t *softs,rcb_t *rcb) 329 { 330 ib_queue_t *ib_q_array = softs->op_aio_ib_q; 331 ib_queue_t *ib_q = NULL; 332 char *ib_iu = NULL; 333 IO_PATH_T io_path = AIO_PATH; 334 uint32_t TraverseCount = 0; 335 int first_qindex = OS_GET_IO_REQ_QINDEX(softs, rcb); 336 int qindex = first_qindex; 337 uint32_t num_op_ib_q = softs->num_op_aio_ibq; 338 uint32_t num_elem_needed; 339 uint32_t num_elem_alloted = 0; 340 pqi_scsi_dev_t *devp = rcb->dvp; 341 uint8_t raidbypass_cdb[16]; 342 343 DBG_FUNC(" IN "); 344 345 346 rcb->cdbp = OS_GET_CDBP(rcb); 347 348 if(IS_AIO_PATH(devp)) { 349 /** IO for Physical Drive **/ 350 /** Send in AIO PATH**/ 351 rcb->ioaccel_handle = devp->ioaccel_handle; 352 } else { 353 int ret = PQI_STATUS_FAILURE; 354 /** IO for RAID Volume **/ 355 if (devp->offload_enabled) { 356 /** ByPass IO ,Send in AIO PATH **/ 357 ret = pqisrc_send_scsi_cmd_raidbypass(softs, 358 devp, rcb, raidbypass_cdb); 359 } 360 361 if (PQI_STATUS_FAILURE == ret) { 362 /** Send in RAID PATH **/ 363 io_path = RAID_PATH; 364 num_op_ib_q = softs->num_op_raid_ibq; 365 ib_q_array = softs->op_raid_ib_q; 366 } else { 367 rcb->cdbp = raidbypass_cdb; 368 } 369 } 370 371 num_elem_needed = pqisrc_num_elem_needed(softs, OS_GET_IO_SG_COUNT(rcb)); 372 DBG_IO("num_elem_needed :%d",num_elem_needed); 373 374 do { 375 uint32_t num_elem_available; 376 ib_q = (ib_q_array + qindex); 377 PQI_LOCK(&ib_q->lock); 378 num_elem_available = pqisrc_contiguous_free_elem(ib_q->pi_local, 379 *(ib_q->ci_virt_addr), ib_q->num_elem); 380 381 DBG_IO("num_elem_avialable :%d\n",num_elem_available); 382 if(num_elem_available >= num_elem_needed) { 383 num_elem_alloted = num_elem_needed; 384 break; 385 } 386 DBG_IO("Current queue is busy! Hop to next queue\n"); 387 388 PQI_UNLOCK(&ib_q->lock); 389 qindex = (qindex + 1) % num_op_ib_q; 390 if(qindex == first_qindex) { 391 if (num_elem_needed == 1) 392 break; 393 TraverseCount += 1; 394 num_elem_needed = 1; 395 } 396 }while(TraverseCount < 2); 397 398 DBG_IO("num_elem_alloted :%d",num_elem_alloted); 399 if (num_elem_alloted == 0) { 400 DBG_WARN("OUT: IB Queues were full\n"); 401 return PQI_STATUS_QFULL; 402 } 403 404 /* Get IB Queue Slot address to build IU */ 405 ib_iu = ib_q->array_virt_addr + (ib_q->pi_local * ib_q->elem_size); 406 407 if(io_path == AIO_PATH) { 408 /** Build AIO structure **/ 409 pqisrc_build_aio_io(softs, rcb, (pqi_aio_req_t*)ib_iu, 410 num_elem_alloted); 411 } else { 412 /** Build RAID structure **/ 413 pqisrc_build_raid_io(softs, rcb, (pqisrc_raid_req_t*)ib_iu, 414 num_elem_alloted); 415 } 416 417 rcb->req_pending = true; 418 419 /* Update the local PI */ 420 ib_q->pi_local = (ib_q->pi_local + num_elem_alloted) % ib_q->num_elem; 421 422 DBG_INFO("ib_q->pi_local : %x\n", ib_q->pi_local); 423 DBG_INFO("*ib_q->ci_virt_addr: %x\n",*(ib_q->ci_virt_addr)); 424 425 /* Inform the fw about the new IU */ 426 PCI_MEM_PUT32(softs, ib_q->pi_register_abs, ib_q->pi_register_offset, ib_q->pi_local); 427 428 PQI_UNLOCK(&ib_q->lock); 429 DBG_FUNC(" OUT "); 430 return PQI_STATUS_SUCCESS; 431 } 432 433 /* Subroutine used to set encryption info as part of RAID bypass IO*/ 434 static inline void pqisrc_set_enc_info( 435 struct pqi_enc_info *enc_info, struct raid_map *raid_map, 436 uint64_t first_block) 437 { 438 uint32_t volume_blk_size; 439 440 /* 441 * Set the encryption tweak values based on logical block address. 442 * If the block size is 512, the tweak value is equal to the LBA. 443 * For other block sizes, tweak value is (LBA * block size) / 512. 444 */ 445 volume_blk_size = GET_LE32((uint8_t *)&raid_map->volume_blk_size); 446 if (volume_blk_size != 512) 447 first_block = (first_block * volume_blk_size) / 512; 448 449 enc_info->data_enc_key_index = 450 GET_LE16((uint8_t *)&raid_map->data_encryption_key_index); 451 enc_info->encrypt_tweak_upper = ((uint32_t)(((first_block) >> 16) >> 16)); 452 enc_info->encrypt_tweak_lower = ((uint32_t)(first_block)); 453 } 454 455 456 /* 457 * Attempt to perform offload RAID mapping for a logical volume I/O. 458 */ 459 460 #define HPSA_RAID_0 0 461 #define HPSA_RAID_4 1 462 #define HPSA_RAID_1 2 /* also used for RAID 10 */ 463 #define HPSA_RAID_5 3 /* also used for RAID 50 */ 464 #define HPSA_RAID_51 4 465 #define HPSA_RAID_6 5 /* also used for RAID 60 */ 466 #define HPSA_RAID_ADM 6 /* also used for RAID 1+0 ADM */ 467 #define HPSA_RAID_MAX HPSA_RAID_ADM 468 #define HPSA_RAID_UNKNOWN 0xff 469 470 /* Subroutine used to parse the scsi opcode and build the CDB for RAID bypass*/ 471 int check_for_scsi_opcode(uint8_t *cdb, boolean_t *is_write, uint64_t *fst_blk, 472 uint32_t *blk_cnt) { 473 474 switch (cdb[0]) { 475 case SCMD_WRITE_6: 476 *is_write = true; 477 case SCMD_READ_6: 478 *fst_blk = (uint64_t)(((cdb[1] & 0x1F) << 16) | 479 (cdb[2] << 8) | cdb[3]); 480 *blk_cnt = (uint32_t)cdb[4]; 481 if (*blk_cnt == 0) 482 *blk_cnt = 256; 483 break; 484 case SCMD_WRITE_10: 485 *is_write = true; 486 case SCMD_READ_10: 487 *fst_blk = (uint64_t)GET_BE32(&cdb[2]); 488 *blk_cnt = (uint32_t)GET_BE16(&cdb[7]); 489 break; 490 case SCMD_WRITE_12: 491 *is_write = true; 492 case SCMD_READ_12: 493 *fst_blk = (uint64_t)GET_BE32(&cdb[2]); 494 *blk_cnt = GET_BE32(&cdb[6]); 495 break; 496 case SCMD_WRITE_16: 497 *is_write = true; 498 case SCMD_READ_16: 499 *fst_blk = GET_BE64(&cdb[2]); 500 *blk_cnt = GET_BE32(&cdb[10]); 501 break; 502 default: 503 /* Process via normal I/O path. */ 504 return PQI_STATUS_FAILURE; 505 } 506 return PQI_STATUS_SUCCESS; 507 } 508 509 /* 510 * Function used to build and send RAID bypass request to the adapter 511 */ 512 int pqisrc_send_scsi_cmd_raidbypass(pqisrc_softstate_t *softs, 513 pqi_scsi_dev_t *device, rcb_t *rcb, uint8_t *cdb) 514 { 515 struct raid_map *raid_map; 516 boolean_t is_write = false; 517 uint32_t map_idx; 518 uint64_t fst_blk, lst_blk; 519 uint32_t blk_cnt, blks_per_row; 520 uint64_t fst_row, lst_row; 521 uint32_t fst_row_offset, lst_row_offset; 522 uint32_t fst_col, lst_col; 523 uint32_t r5or6_blks_per_row; 524 uint64_t r5or6_fst_row, r5or6_lst_row; 525 uint32_t r5or6_fst_row_offset, r5or6_lst_row_offset; 526 uint32_t r5or6_fst_col, r5or6_lst_col; 527 uint16_t data_disks_per_row, total_disks_per_row; 528 uint16_t layout_map_count; 529 uint32_t stripesz; 530 uint16_t strip_sz; 531 uint32_t fst_grp, lst_grp, cur_grp; 532 uint32_t map_row; 533 uint64_t disk_block; 534 uint32_t disk_blk_cnt; 535 uint8_t cdb_length; 536 int offload_to_mirror; 537 int i; 538 DBG_FUNC(" IN \n"); 539 DBG_IO("!!!!!\n"); 540 541 /* Check for eligible opcode, get LBA and block count. */ 542 memcpy(cdb, OS_GET_CDBP(rcb), rcb->cmdlen); 543 544 for(i = 0; i < rcb->cmdlen ; i++) 545 DBG_IO(" CDB [ %d ] : %x\n",i,cdb[i]); 546 if(check_for_scsi_opcode(cdb, &is_write, 547 &fst_blk, &blk_cnt) == PQI_STATUS_FAILURE) 548 return PQI_STATUS_FAILURE; 549 /* Check for write to non-RAID-0. */ 550 if (is_write && device->raid_level != SA_RAID_0) 551 return PQI_STATUS_FAILURE; 552 553 if(blk_cnt == 0) 554 return PQI_STATUS_FAILURE; 555 556 lst_blk = fst_blk + blk_cnt - 1; 557 raid_map = device->raid_map; 558 559 /* Check for invalid block or wraparound. */ 560 if (lst_blk >= GET_LE64((uint8_t *)&raid_map->volume_blk_cnt) || 561 lst_blk < fst_blk) 562 return PQI_STATUS_FAILURE; 563 564 data_disks_per_row = GET_LE16((uint8_t *)&raid_map->data_disks_per_row); 565 strip_sz = GET_LE16((uint8_t *)(&raid_map->strip_size)); 566 layout_map_count = GET_LE16((uint8_t *)(&raid_map->layout_map_count)); 567 568 /* Calculate stripe information for the request. */ 569 blks_per_row = data_disks_per_row * strip_sz; 570 if (!blks_per_row) 571 return PQI_STATUS_FAILURE; 572 /* use __udivdi3 ? */ 573 fst_row = fst_blk / blks_per_row; 574 lst_row = lst_blk / blks_per_row; 575 fst_row_offset = (uint32_t)(fst_blk - (fst_row * blks_per_row)); 576 lst_row_offset = (uint32_t)(lst_blk - (lst_row * blks_per_row)); 577 fst_col = fst_row_offset / strip_sz; 578 lst_col = lst_row_offset / strip_sz; 579 580 /* If this isn't a single row/column then give to the controller. */ 581 if (fst_row != lst_row || fst_col != lst_col) 582 return PQI_STATUS_FAILURE; 583 584 /* Proceeding with driver mapping. */ 585 total_disks_per_row = data_disks_per_row + 586 GET_LE16((uint8_t *)(&raid_map->metadata_disks_per_row)); 587 map_row = ((uint32_t)(fst_row >> raid_map->parity_rotation_shift)) % 588 GET_LE16((uint8_t *)(&raid_map->row_cnt)); 589 map_idx = (map_row * total_disks_per_row) + fst_col; 590 591 /* RAID 1 */ 592 if (device->raid_level == SA_RAID_1) { 593 if (device->offload_to_mirror) 594 map_idx += data_disks_per_row; 595 device->offload_to_mirror = !device->offload_to_mirror; 596 } else if (device->raid_level == SA_RAID_ADM) { 597 /* RAID ADM */ 598 /* 599 * Handles N-way mirrors (R1-ADM) and R10 with # of drives 600 * divisible by 3. 601 */ 602 offload_to_mirror = device->offload_to_mirror; 603 if (offload_to_mirror == 0) { 604 /* use physical disk in the first mirrored group. */ 605 map_idx %= data_disks_per_row; 606 } else { 607 do { 608 /* 609 * Determine mirror group that map_idx 610 * indicates. 611 */ 612 cur_grp = map_idx / data_disks_per_row; 613 614 if (offload_to_mirror != cur_grp) { 615 if (cur_grp < 616 layout_map_count - 1) { 617 /* 618 * Select raid index from 619 * next group. 620 */ 621 map_idx += data_disks_per_row; 622 cur_grp++; 623 } else { 624 /* 625 * Select raid index from first 626 * group. 627 */ 628 map_idx %= data_disks_per_row; 629 cur_grp = 0; 630 } 631 } 632 } while (offload_to_mirror != cur_grp); 633 } 634 635 /* Set mirror group to use next time. */ 636 offload_to_mirror = 637 (offload_to_mirror >= layout_map_count - 1) ? 638 0 : offload_to_mirror + 1; 639 if(offload_to_mirror >= layout_map_count) 640 return PQI_STATUS_FAILURE; 641 642 device->offload_to_mirror = offload_to_mirror; 643 /* 644 * Avoid direct use of device->offload_to_mirror within this 645 * function since multiple threads might simultaneously 646 * increment it beyond the range of device->layout_map_count -1. 647 */ 648 } else if ((device->raid_level == SA_RAID_5 || 649 device->raid_level == SA_RAID_6) && layout_map_count > 1) { 650 /* RAID 50/60 */ 651 /* Verify first and last block are in same RAID group */ 652 r5or6_blks_per_row = strip_sz * data_disks_per_row; 653 stripesz = r5or6_blks_per_row * layout_map_count; 654 655 fst_grp = (fst_blk % stripesz) / r5or6_blks_per_row; 656 lst_grp = (lst_blk % stripesz) / r5or6_blks_per_row; 657 658 if (fst_grp != lst_grp) 659 return PQI_STATUS_FAILURE; 660 661 /* Verify request is in a single row of RAID 5/6 */ 662 fst_row = r5or6_fst_row = 663 fst_blk / stripesz; 664 r5or6_lst_row = lst_blk / stripesz; 665 666 if (r5or6_fst_row != r5or6_lst_row) 667 return PQI_STATUS_FAILURE; 668 669 /* Verify request is in a single column */ 670 fst_row_offset = r5or6_fst_row_offset = 671 (uint32_t)((fst_blk % stripesz) % 672 r5or6_blks_per_row); 673 674 r5or6_lst_row_offset = 675 (uint32_t)((lst_blk % stripesz) % 676 r5or6_blks_per_row); 677 678 fst_col = r5or6_fst_row_offset / strip_sz; 679 r5or6_fst_col = fst_col; 680 r5or6_lst_col = r5or6_lst_row_offset / strip_sz; 681 682 if (r5or6_fst_col != r5or6_lst_col) 683 return PQI_STATUS_FAILURE; 684 685 /* Request is eligible */ 686 map_row = 687 ((uint32_t)(fst_row >> raid_map->parity_rotation_shift)) % 688 GET_LE16((uint8_t *)(&raid_map->row_cnt)); 689 690 map_idx = (fst_grp * 691 (GET_LE16((uint8_t *)(&raid_map->row_cnt)) * 692 total_disks_per_row)) + 693 (map_row * total_disks_per_row) + fst_col; 694 } 695 696 if (map_idx >= RAID_MAP_MAX_ENTRIES) 697 return PQI_STATUS_FAILURE; 698 699 rcb->ioaccel_handle = raid_map->dev_data[map_idx].ioaccel_handle; 700 disk_block = GET_LE64((uint8_t *)(&raid_map->disk_starting_blk)) + 701 fst_row * strip_sz + 702 (fst_row_offset - fst_col * strip_sz); 703 disk_blk_cnt = blk_cnt; 704 705 /* Handle differing logical/physical block sizes. */ 706 if (raid_map->phys_blk_shift) { 707 disk_block <<= raid_map->phys_blk_shift; 708 disk_blk_cnt <<= raid_map->phys_blk_shift; 709 } 710 711 if (disk_blk_cnt > 0xffff) 712 return PQI_STATUS_FAILURE; 713 714 /* Build the new CDB for the physical disk I/O. */ 715 if (disk_block > 0xffffffff) { 716 cdb[0] = is_write ? SCMD_WRITE_16 : SCMD_READ_16; 717 cdb[1] = 0; 718 PUT_BE64(disk_block, &cdb[2]); 719 PUT_BE32(disk_blk_cnt, &cdb[10]); 720 cdb[14] = 0; 721 cdb[15] = 0; 722 cdb_length = 16; 723 } else { 724 cdb[0] = is_write ? SCMD_WRITE_10 : SCMD_READ_10; 725 cdb[1] = 0; 726 PUT_BE32(disk_block, &cdb[2]); 727 cdb[6] = 0; 728 PUT_BE16(disk_blk_cnt, &cdb[7]); 729 cdb[9] = 0; 730 cdb_length = 10; 731 } 732 733 if (GET_LE16((uint8_t *)(&raid_map->flags)) & 734 RAID_MAP_ENCRYPTION_ENABLED) { 735 pqisrc_set_enc_info(&rcb->enc_info, raid_map, 736 fst_blk); 737 rcb->encrypt_enable = true; 738 } else { 739 rcb->encrypt_enable = false; 740 } 741 742 rcb->cmdlen = cdb_length; 743 744 745 DBG_FUNC("OUT"); 746 747 return PQI_STATUS_SUCCESS; 748 } 749 750 /* Function used to submit a TMF to the adater */ 751 int pqisrc_send_tmf(pqisrc_softstate_t *softs, pqi_scsi_dev_t *devp, 752 rcb_t *rcb, int req_id, int tmf_type) 753 { 754 int rval = PQI_STATUS_SUCCESS; 755 pqi_tmf_req_t tmf_req; 756 757 memset(&tmf_req, 0, sizeof(pqi_tmf_req_t)); 758 759 DBG_FUNC("IN"); 760 761 tmf_req.header.iu_type = PQI_REQUEST_IU_TASK_MANAGEMENT; 762 tmf_req.header.iu_length = sizeof(tmf_req) - sizeof(iu_header_t); 763 tmf_req.req_id = rcb->tag; 764 765 memcpy(tmf_req.lun, devp->scsi3addr, sizeof(tmf_req.lun)); 766 tmf_req.tmf = tmf_type; 767 tmf_req.req_id_to_manage = req_id; 768 tmf_req.resp_qid = OS_GET_TMF_RESP_QID(softs, rcb); 769 tmf_req.obq_id_to_manage = rcb->resp_qid; 770 771 rcb->req_pending = true; 772 773 rval = pqisrc_submit_cmnd(softs, 774 &softs->op_raid_ib_q[OS_GET_TMF_REQ_QINDEX(softs, rcb)], &tmf_req); 775 if (rval != PQI_STATUS_SUCCESS) { 776 DBG_ERR("Unable to submit command rval=%d\n", rval); 777 return rval; 778 } 779 780 rval = pqisrc_wait_on_condition(softs, rcb); 781 if (rval != PQI_STATUS_SUCCESS){ 782 DBG_ERR("Task Management tmf_type : %d timeout\n", tmf_type); 783 rcb->status = REQUEST_FAILED; 784 } 785 786 if (rcb->status != REQUEST_SUCCESS) { 787 DBG_ERR_BTL(devp, "Task Management failed tmf_type:%d " 788 "stat:0x%x\n", tmf_type, rcb->status); 789 rval = PQI_STATUS_FAILURE; 790 } 791 792 DBG_FUNC("OUT"); 793 return rval; 794 } 795