1 /* 2 * linux/drivers/scsi/esas2r/esas2r_io.c 3 * For use with ATTO ExpressSAS R6xx SAS/SATA RAID controllers 4 * 5 * Copyright (c) 2001-2013 ATTO Technology, Inc. 6 * (mailto:linuxdrivers@attotech.com)mpt3sas/mpt3sas_trigger_diag. 7 * 8 * This program is free software; you can redistribute it and/or 9 * modify it under the terms of the GNU General Public License 10 * as published by the Free Software Foundation; either version 2 11 * of the License, or (at your option) any later version. 12 * 13 * This program is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * GNU General Public License for more details. 17 * 18 * NO WARRANTY 19 * THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR 20 * CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT 21 * LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, 22 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is 23 * solely responsible for determining the appropriateness of using and 24 * distributing the Program and assumes all risks associated with its 25 * exercise of rights under this Agreement, including but not limited to 26 * the risks and costs of program errors, damage to or loss of data, 27 * programs or equipment, and unavailability or interruption of operations. 28 * 29 * DISCLAIMER OF LIABILITY 30 * NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY 31 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 32 * DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND 33 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR 34 * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE 35 * USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED 36 * HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES 37 * 38 * You should have received a copy of the GNU General Public License 39 * along with this program; if not, write to the Free Software 40 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, 41 * USA. 42 */ 43 44 #include "esas2r.h" 45 46 void esas2r_start_request(struct esas2r_adapter *a, struct esas2r_request *rq) 47 { 48 struct esas2r_target *t = NULL; 49 struct esas2r_request *startrq = rq; 50 unsigned long flags; 51 52 if (unlikely(test_bit(AF_DEGRADED_MODE, &a->flags) || 53 test_bit(AF_POWER_DOWN, &a->flags))) { 54 if (rq->vrq->scsi.function == VDA_FUNC_SCSI) 55 rq->req_stat = RS_SEL2; 56 else 57 rq->req_stat = RS_DEGRADED; 58 } else if (likely(rq->vrq->scsi.function == VDA_FUNC_SCSI)) { 59 t = a->targetdb + rq->target_id; 60 61 if (unlikely(t >= a->targetdb_end 62 || !(t->flags & TF_USED))) { 63 rq->req_stat = RS_SEL; 64 } else { 65 /* copy in the target ID. */ 66 rq->vrq->scsi.target_id = cpu_to_le16(t->virt_targ_id); 67 68 /* 69 * Test if we want to report RS_SEL for missing target. 70 * Note that if AF_DISC_PENDING is set than this will 71 * go on the defer queue. 72 */ 73 if (unlikely(t->target_state != TS_PRESENT && 74 !test_bit(AF_DISC_PENDING, &a->flags))) 75 rq->req_stat = RS_SEL; 76 } 77 } 78 79 if (unlikely(rq->req_stat != RS_PENDING)) { 80 esas2r_complete_request(a, rq); 81 return; 82 } 83 84 esas2r_trace("rq=%p", rq); 85 esas2r_trace("rq->vrq->scsi.handle=%x", rq->vrq->scsi.handle); 86 87 if (rq->vrq->scsi.function == VDA_FUNC_SCSI) { 88 esas2r_trace("rq->target_id=%d", rq->target_id); 89 esas2r_trace("rq->vrq->scsi.flags=%x", rq->vrq->scsi.flags); 90 } 91 92 spin_lock_irqsave(&a->queue_lock, flags); 93 94 if (likely(list_empty(&a->defer_list) && 95 !test_bit(AF_CHPRST_PENDING, &a->flags) && 96 !test_bit(AF_FLASHING, &a->flags) && 97 !test_bit(AF_DISC_PENDING, &a->flags))) 98 esas2r_local_start_request(a, startrq); 99 else 100 list_add_tail(&startrq->req_list, &a->defer_list); 101 102 spin_unlock_irqrestore(&a->queue_lock, flags); 103 } 104 105 /* 106 * Starts the specified request. all requests have RS_PENDING set when this 107 * routine is called. The caller is usually esas2r_start_request, but 108 * esas2r_do_deferred_processes will start request that are deferred. 109 * 110 * The caller must ensure that requests can be started. 111 * 112 * esas2r_start_request will defer a request if there are already requests 113 * waiting or there is a chip reset pending. once the reset condition clears, 114 * esas2r_do_deferred_processes will call this function to start the request. 115 * 116 * When a request is started, it is placed on the active list and queued to 117 * the controller. 118 */ 119 void esas2r_local_start_request(struct esas2r_adapter *a, 120 struct esas2r_request *rq) 121 { 122 esas2r_trace_enter(); 123 esas2r_trace("rq=%p", rq); 124 esas2r_trace("rq->vrq:%p", rq->vrq); 125 esas2r_trace("rq->vrq_md->phys_addr:%x", rq->vrq_md->phys_addr); 126 127 if (unlikely(rq->vrq->scsi.function == VDA_FUNC_FLASH 128 && rq->vrq->flash.sub_func == VDA_FLASH_COMMIT)) 129 set_bit(AF_FLASHING, &a->flags); 130 131 list_add_tail(&rq->req_list, &a->active_list); 132 esas2r_start_vda_request(a, rq); 133 esas2r_trace_exit(); 134 return; 135 } 136 137 void esas2r_start_vda_request(struct esas2r_adapter *a, 138 struct esas2r_request *rq) 139 { 140 struct esas2r_inbound_list_source_entry *element; 141 u32 dw; 142 143 rq->req_stat = RS_STARTED; 144 /* 145 * Calculate the inbound list entry location and the current state of 146 * toggle bit. 147 */ 148 a->last_write++; 149 if (a->last_write >= a->list_size) { 150 a->last_write = 0; 151 /* update the toggle bit */ 152 if (test_bit(AF_COMM_LIST_TOGGLE, &a->flags)) 153 clear_bit(AF_COMM_LIST_TOGGLE, &a->flags); 154 else 155 set_bit(AF_COMM_LIST_TOGGLE, &a->flags); 156 } 157 158 element = 159 (struct esas2r_inbound_list_source_entry *)a->inbound_list_md. 160 virt_addr 161 + a->last_write; 162 163 /* Set the VDA request size if it was never modified */ 164 if (rq->vda_req_sz == RQ_SIZE_DEFAULT) 165 rq->vda_req_sz = (u16)(a->max_vdareq_size / sizeof(u32)); 166 167 element->address = cpu_to_le64(rq->vrq_md->phys_addr); 168 element->length = cpu_to_le32(rq->vda_req_sz); 169 170 /* Update the write pointer */ 171 dw = a->last_write; 172 173 if (test_bit(AF_COMM_LIST_TOGGLE, &a->flags)) 174 dw |= MU_ILW_TOGGLE; 175 176 esas2r_trace("rq->vrq->scsi.handle:%x", rq->vrq->scsi.handle); 177 esas2r_trace("dw:%x", dw); 178 esas2r_trace("rq->vda_req_sz:%x", rq->vda_req_sz); 179 esas2r_write_register_dword(a, MU_IN_LIST_WRITE, dw); 180 } 181 182 /* 183 * Build the scatter/gather list for an I/O request according to the 184 * specifications placed in the s/g context. The caller must initialize 185 * context prior to the initial call by calling esas2r_sgc_init(). 186 */ 187 bool esas2r_build_sg_list_sge(struct esas2r_adapter *a, 188 struct esas2r_sg_context *sgc) 189 { 190 struct esas2r_request *rq = sgc->first_req; 191 union atto_vda_req *vrq = rq->vrq; 192 193 while (sgc->length) { 194 u32 rem = 0; 195 u64 addr; 196 u32 len; 197 198 len = (*sgc->get_phys_addr)(sgc, &addr); 199 200 if (unlikely(len == 0)) 201 return false; 202 203 /* if current length is more than what's left, stop there */ 204 if (unlikely(len > sgc->length)) 205 len = sgc->length; 206 207 another_entry: 208 /* limit to a round number less than the maximum length */ 209 if (len > SGE_LEN_MAX) { 210 /* 211 * Save the remainder of the split. Whenever we limit 212 * an entry we come back around to build entries out 213 * of the leftover. We do this to prevent multiple 214 * calls to the get_phys_addr() function for an SGE 215 * that is too large. 216 */ 217 rem = len - SGE_LEN_MAX; 218 len = SGE_LEN_MAX; 219 } 220 221 /* See if we need to allocate a new SGL */ 222 if (unlikely(sgc->sge.a64.curr > sgc->sge.a64.limit)) { 223 u8 sgelen; 224 struct esas2r_mem_desc *sgl; 225 226 /* 227 * If no SGls are available, return failure. The 228 * caller can call us later with the current context 229 * to pick up here. 230 */ 231 sgl = esas2r_alloc_sgl(a); 232 233 if (unlikely(sgl == NULL)) 234 return false; 235 236 /* Calculate the length of the last SGE filled in */ 237 sgelen = (u8)((u8 *)sgc->sge.a64.curr 238 - (u8 *)sgc->sge.a64.last); 239 240 /* 241 * Copy the last SGE filled in to the first entry of 242 * the new SGL to make room for the chain entry. 243 */ 244 memcpy(sgl->virt_addr, sgc->sge.a64.last, sgelen); 245 246 /* Figure out the new curr pointer in the new segment */ 247 sgc->sge.a64.curr = 248 (struct atto_vda_sge *)((u8 *)sgl->virt_addr + 249 sgelen); 250 251 /* Set the limit pointer and build the chain entry */ 252 sgc->sge.a64.limit = 253 (struct atto_vda_sge *)((u8 *)sgl->virt_addr 254 + sgl_page_size 255 - sizeof(struct 256 atto_vda_sge)); 257 sgc->sge.a64.last->length = cpu_to_le32( 258 SGE_CHAIN | SGE_ADDR_64); 259 sgc->sge.a64.last->address = 260 cpu_to_le64(sgl->phys_addr); 261 262 /* 263 * Now, if there was a previous chain entry, then 264 * update it to contain the length of this segment 265 * and size of this chain. otherwise this is the 266 * first SGL, so set the chain_offset in the request. 267 */ 268 if (sgc->sge.a64.chain) { 269 sgc->sge.a64.chain->length |= 270 cpu_to_le32( 271 ((u8 *)(sgc->sge.a64. 272 last + 1) 273 - (u8 *)rq->sg_table-> 274 virt_addr) 275 + sizeof(struct atto_vda_sge) * 276 LOBIT(SGE_CHAIN_SZ)); 277 } else { 278 vrq->scsi.chain_offset = (u8) 279 ((u8 *)sgc-> 280 sge.a64.last - 281 (u8 *)vrq); 282 283 /* 284 * This is the first SGL, so set the 285 * chain_offset and the VDA request size in 286 * the request. 287 */ 288 rq->vda_req_sz = 289 (vrq->scsi.chain_offset + 290 sizeof(struct atto_vda_sge) + 291 3) 292 / sizeof(u32); 293 } 294 295 /* 296 * Remember this so when we get a new SGL filled in we 297 * can update the length of this chain entry. 298 */ 299 sgc->sge.a64.chain = sgc->sge.a64.last; 300 301 /* Now link the new SGL onto the primary request. */ 302 list_add(&sgl->next_desc, &rq->sg_table_head); 303 } 304 305 /* Update last one filled in */ 306 sgc->sge.a64.last = sgc->sge.a64.curr; 307 308 /* Build the new SGE and update the S/G context */ 309 sgc->sge.a64.curr->length = cpu_to_le32(SGE_ADDR_64 | len); 310 sgc->sge.a64.curr->address = cpu_to_le32(addr); 311 sgc->sge.a64.curr++; 312 sgc->cur_offset += len; 313 sgc->length -= len; 314 315 /* 316 * Check if we previously split an entry. If so we have to 317 * pick up where we left off. 318 */ 319 if (rem) { 320 addr += len; 321 len = rem; 322 rem = 0; 323 goto another_entry; 324 } 325 } 326 327 /* Mark the end of the SGL */ 328 sgc->sge.a64.last->length |= cpu_to_le32(SGE_LAST); 329 330 /* 331 * If there was a previous chain entry, update the length to indicate 332 * the length of this last segment. 333 */ 334 if (sgc->sge.a64.chain) { 335 sgc->sge.a64.chain->length |= cpu_to_le32( 336 ((u8 *)(sgc->sge.a64.curr) - 337 (u8 *)rq->sg_table->virt_addr)); 338 } else { 339 u16 reqsize; 340 341 /* 342 * The entire VDA request was not used so lets 343 * set the size of the VDA request to be DMA'd 344 */ 345 reqsize = 346 ((u16)((u8 *)sgc->sge.a64.last - (u8 *)vrq) 347 + sizeof(struct atto_vda_sge) + 3) / sizeof(u32); 348 349 /* 350 * Only update the request size if it is bigger than what is 351 * already there. We can come in here twice for some management 352 * commands. 353 */ 354 if (reqsize > rq->vda_req_sz) 355 rq->vda_req_sz = reqsize; 356 } 357 return true; 358 } 359 360 361 /* 362 * Create PRD list for each I-block consumed by the command. This routine 363 * determines how much data is required from each I-block being consumed 364 * by the command. The first and last I-blocks can be partials and all of 365 * the I-blocks in between are for a full I-block of data. 366 * 367 * The interleave size is used to determine the number of bytes in the 1st 368 * I-block and the remaining I-blocks are what remeains. 369 */ 370 static bool esas2r_build_prd_iblk(struct esas2r_adapter *a, 371 struct esas2r_sg_context *sgc) 372 { 373 struct esas2r_request *rq = sgc->first_req; 374 u64 addr; 375 u32 len; 376 struct esas2r_mem_desc *sgl; 377 u32 numchain = 1; 378 u32 rem = 0; 379 380 while (sgc->length) { 381 /* Get the next address/length pair */ 382 383 len = (*sgc->get_phys_addr)(sgc, &addr); 384 385 if (unlikely(len == 0)) 386 return false; 387 388 /* If current length is more than what's left, stop there */ 389 390 if (unlikely(len > sgc->length)) 391 len = sgc->length; 392 393 another_entry: 394 /* Limit to a round number less than the maximum length */ 395 396 if (len > PRD_LEN_MAX) { 397 /* 398 * Save the remainder of the split. whenever we limit 399 * an entry we come back around to build entries out 400 * of the leftover. We do this to prevent multiple 401 * calls to the get_phys_addr() function for an SGE 402 * that is too large. 403 */ 404 rem = len - PRD_LEN_MAX; 405 len = PRD_LEN_MAX; 406 } 407 408 /* See if we need to allocate a new SGL */ 409 if (sgc->sge.prd.sge_cnt == 0) { 410 if (len == sgc->length) { 411 /* 412 * We only have 1 PRD entry left. 413 * It can be placed where the chain 414 * entry would have gone 415 */ 416 417 /* Build the simple SGE */ 418 sgc->sge.prd.curr->ctl_len = cpu_to_le32( 419 PRD_DATA | len); 420 sgc->sge.prd.curr->address = cpu_to_le64(addr); 421 422 /* Adjust length related fields */ 423 sgc->cur_offset += len; 424 sgc->length -= len; 425 426 /* We use the reserved chain entry for data */ 427 numchain = 0; 428 429 break; 430 } 431 432 if (sgc->sge.prd.chain) { 433 /* 434 * Fill # of entries of current SGL in previous 435 * chain the length of this current SGL may not 436 * full. 437 */ 438 439 sgc->sge.prd.chain->ctl_len |= cpu_to_le32( 440 sgc->sge.prd.sgl_max_cnt); 441 } 442 443 /* 444 * If no SGls are available, return failure. The 445 * caller can call us later with the current context 446 * to pick up here. 447 */ 448 449 sgl = esas2r_alloc_sgl(a); 450 451 if (unlikely(sgl == NULL)) 452 return false; 453 454 /* 455 * Link the new SGL onto the chain 456 * They are in reverse order 457 */ 458 list_add(&sgl->next_desc, &rq->sg_table_head); 459 460 /* 461 * An SGL was just filled in and we are starting 462 * a new SGL. Prime the chain of the ending SGL with 463 * info that points to the new SGL. The length gets 464 * filled in when the new SGL is filled or ended 465 */ 466 467 sgc->sge.prd.chain = sgc->sge.prd.curr; 468 469 sgc->sge.prd.chain->ctl_len = cpu_to_le32(PRD_CHAIN); 470 sgc->sge.prd.chain->address = 471 cpu_to_le64(sgl->phys_addr); 472 473 /* 474 * Start a new segment. 475 * Take one away and save for chain SGE 476 */ 477 478 sgc->sge.prd.curr = 479 (struct atto_physical_region_description *)sgl 480 -> 481 virt_addr; 482 sgc->sge.prd.sge_cnt = sgc->sge.prd.sgl_max_cnt - 1; 483 } 484 485 sgc->sge.prd.sge_cnt--; 486 /* Build the simple SGE */ 487 sgc->sge.prd.curr->ctl_len = cpu_to_le32(PRD_DATA | len); 488 sgc->sge.prd.curr->address = cpu_to_le64(addr); 489 490 /* Used another element. Point to the next one */ 491 492 sgc->sge.prd.curr++; 493 494 /* Adjust length related fields */ 495 496 sgc->cur_offset += len; 497 sgc->length -= len; 498 499 /* 500 * Check if we previously split an entry. If so we have to 501 * pick up where we left off. 502 */ 503 504 if (rem) { 505 addr += len; 506 len = rem; 507 rem = 0; 508 goto another_entry; 509 } 510 } 511 512 if (!list_empty(&rq->sg_table_head)) { 513 if (sgc->sge.prd.chain) { 514 sgc->sge.prd.chain->ctl_len |= 515 cpu_to_le32(sgc->sge.prd.sgl_max_cnt 516 - sgc->sge.prd.sge_cnt 517 - numchain); 518 } 519 } 520 521 return true; 522 } 523 524 bool esas2r_build_sg_list_prd(struct esas2r_adapter *a, 525 struct esas2r_sg_context *sgc) 526 { 527 struct esas2r_request *rq = sgc->first_req; 528 u32 len = sgc->length; 529 struct esas2r_target *t = a->targetdb + rq->target_id; 530 u8 is_i_o = 0; 531 u16 reqsize; 532 struct atto_physical_region_description *curr_iblk_chn; 533 u8 *cdb = (u8 *)&rq->vrq->scsi.cdb[0]; 534 535 /* 536 * extract LBA from command so we can determine 537 * the I-Block boundary 538 */ 539 540 if (rq->vrq->scsi.function == VDA_FUNC_SCSI 541 && t->target_state == TS_PRESENT 542 && !(t->flags & TF_PASS_THRU)) { 543 u32 lbalo = 0; 544 545 switch (rq->vrq->scsi.cdb[0]) { 546 case READ_16: 547 case WRITE_16: 548 { 549 lbalo = 550 MAKEDWORD(MAKEWORD(cdb[9], 551 cdb[8]), 552 MAKEWORD(cdb[7], 553 cdb[6])); 554 is_i_o = 1; 555 break; 556 } 557 558 case READ_12: 559 case WRITE_12: 560 case READ_10: 561 case WRITE_10: 562 { 563 lbalo = 564 MAKEDWORD(MAKEWORD(cdb[5], 565 cdb[4]), 566 MAKEWORD(cdb[3], 567 cdb[2])); 568 is_i_o = 1; 569 break; 570 } 571 572 case READ_6: 573 case WRITE_6: 574 { 575 lbalo = 576 MAKEDWORD(MAKEWORD(cdb[3], 577 cdb[2]), 578 MAKEWORD(cdb[1] & 0x1F, 579 0)); 580 is_i_o = 1; 581 break; 582 } 583 584 default: 585 break; 586 } 587 588 if (is_i_o) { 589 u32 startlba; 590 591 rq->vrq->scsi.iblk_cnt_prd = 0; 592 593 /* Determine size of 1st I-block PRD list */ 594 startlba = t->inter_block - (lbalo & (t->inter_block - 595 1)); 596 sgc->length = startlba * t->block_size; 597 598 /* Chk if the 1st iblk chain starts at base of Iblock */ 599 if ((lbalo & (t->inter_block - 1)) == 0) 600 rq->flags |= RF_1ST_IBLK_BASE; 601 602 if (sgc->length > len) 603 sgc->length = len; 604 } else { 605 sgc->length = len; 606 } 607 } else { 608 sgc->length = len; 609 } 610 611 /* get our starting chain address */ 612 613 curr_iblk_chn = 614 (struct atto_physical_region_description *)sgc->sge.a64.curr; 615 616 sgc->sge.prd.sgl_max_cnt = sgl_page_size / 617 sizeof(struct 618 atto_physical_region_description); 619 620 /* create all of the I-block PRD lists */ 621 622 while (len) { 623 sgc->sge.prd.sge_cnt = 0; 624 sgc->sge.prd.chain = NULL; 625 sgc->sge.prd.curr = curr_iblk_chn; 626 627 /* increment to next I-Block */ 628 629 len -= sgc->length; 630 631 /* go build the next I-Block PRD list */ 632 633 if (unlikely(!esas2r_build_prd_iblk(a, sgc))) 634 return false; 635 636 curr_iblk_chn++; 637 638 if (is_i_o) { 639 rq->vrq->scsi.iblk_cnt_prd++; 640 641 if (len > t->inter_byte) 642 sgc->length = t->inter_byte; 643 else 644 sgc->length = len; 645 } 646 } 647 648 /* figure out the size used of the VDA request */ 649 650 reqsize = ((u16)((u8 *)curr_iblk_chn - (u8 *)rq->vrq)) 651 / sizeof(u32); 652 653 /* 654 * only update the request size if it is bigger than what is 655 * already there. we can come in here twice for some management 656 * commands. 657 */ 658 659 if (reqsize > rq->vda_req_sz) 660 rq->vda_req_sz = reqsize; 661 662 return true; 663 } 664 665 static void esas2r_handle_pending_reset(struct esas2r_adapter *a, u32 currtime) 666 { 667 u32 delta = currtime - a->chip_init_time; 668 669 if (delta <= ESAS2R_CHPRST_WAIT_TIME) { 670 /* Wait before accessing registers */ 671 } else if (delta >= ESAS2R_CHPRST_TIME) { 672 /* 673 * The last reset failed so try again. Reset 674 * processing will give up after three tries. 675 */ 676 esas2r_local_reset_adapter(a); 677 } else { 678 /* We can now see if the firmware is ready */ 679 u32 doorbell; 680 681 doorbell = esas2r_read_register_dword(a, MU_DOORBELL_OUT); 682 if (doorbell == 0xFFFFFFFF || !(doorbell & DRBL_FORCE_INT)) { 683 esas2r_force_interrupt(a); 684 } else { 685 u32 ver = (doorbell & DRBL_FW_VER_MSK); 686 687 /* Driver supports API version 0 and 1 */ 688 esas2r_write_register_dword(a, MU_DOORBELL_OUT, 689 doorbell); 690 if (ver == DRBL_FW_VER_0) { 691 set_bit(AF_CHPRST_DETECTED, &a->flags); 692 set_bit(AF_LEGACY_SGE_MODE, &a->flags); 693 694 a->max_vdareq_size = 128; 695 a->build_sgl = esas2r_build_sg_list_sge; 696 } else if (ver == DRBL_FW_VER_1) { 697 set_bit(AF_CHPRST_DETECTED, &a->flags); 698 clear_bit(AF_LEGACY_SGE_MODE, &a->flags); 699 700 a->max_vdareq_size = 1024; 701 a->build_sgl = esas2r_build_sg_list_prd; 702 } else { 703 esas2r_local_reset_adapter(a); 704 } 705 } 706 } 707 } 708 709 710 /* This function must be called once per timer tick */ 711 void esas2r_timer_tick(struct esas2r_adapter *a) 712 { 713 u32 currtime = jiffies_to_msecs(jiffies); 714 u32 deltatime = currtime - a->last_tick_time; 715 716 a->last_tick_time = currtime; 717 718 /* count down the uptime */ 719 if (a->chip_uptime && 720 !test_bit(AF_CHPRST_PENDING, &a->flags) && 721 !test_bit(AF_DISC_PENDING, &a->flags)) { 722 if (deltatime >= a->chip_uptime) 723 a->chip_uptime = 0; 724 else 725 a->chip_uptime -= deltatime; 726 } 727 728 if (test_bit(AF_CHPRST_PENDING, &a->flags)) { 729 if (!test_bit(AF_CHPRST_NEEDED, &a->flags) && 730 !test_bit(AF_CHPRST_DETECTED, &a->flags)) 731 esas2r_handle_pending_reset(a, currtime); 732 } else { 733 if (test_bit(AF_DISC_PENDING, &a->flags)) 734 esas2r_disc_check_complete(a); 735 if (test_bit(AF_HEARTBEAT_ENB, &a->flags)) { 736 if (test_bit(AF_HEARTBEAT, &a->flags)) { 737 if ((currtime - a->heartbeat_time) >= 738 ESAS2R_HEARTBEAT_TIME) { 739 clear_bit(AF_HEARTBEAT, &a->flags); 740 esas2r_hdebug("heartbeat failed"); 741 esas2r_log(ESAS2R_LOG_CRIT, 742 "heartbeat failed"); 743 esas2r_bugon(); 744 esas2r_local_reset_adapter(a); 745 } 746 } else { 747 set_bit(AF_HEARTBEAT, &a->flags); 748 a->heartbeat_time = currtime; 749 esas2r_force_interrupt(a); 750 } 751 } 752 } 753 754 if (atomic_read(&a->disable_cnt) == 0) 755 esas2r_do_deferred_processes(a); 756 } 757 758 /* 759 * Send the specified task management function to the target and LUN 760 * specified in rqaux. in addition, immediately abort any commands that 761 * are queued but not sent to the device according to the rules specified 762 * by the task management function. 763 */ 764 bool esas2r_send_task_mgmt(struct esas2r_adapter *a, 765 struct esas2r_request *rqaux, u8 task_mgt_func) 766 { 767 u16 targetid = rqaux->target_id; 768 u8 lun = (u8)le32_to_cpu(rqaux->vrq->scsi.flags); 769 bool ret = false; 770 struct esas2r_request *rq; 771 struct list_head *next, *element; 772 unsigned long flags; 773 774 LIST_HEAD(comp_list); 775 776 esas2r_trace_enter(); 777 esas2r_trace("rqaux:%p", rqaux); 778 esas2r_trace("task_mgt_func:%x", task_mgt_func); 779 spin_lock_irqsave(&a->queue_lock, flags); 780 781 /* search the defer queue looking for requests for the device */ 782 list_for_each_safe(element, next, &a->defer_list) { 783 rq = list_entry(element, struct esas2r_request, req_list); 784 785 if (rq->vrq->scsi.function == VDA_FUNC_SCSI 786 && rq->target_id == targetid 787 && (((u8)le32_to_cpu(rq->vrq->scsi.flags)) == lun 788 || task_mgt_func == 0x20)) { /* target reset */ 789 /* Found a request affected by the task management */ 790 if (rq->req_stat == RS_PENDING) { 791 /* 792 * The request is pending or waiting. We can 793 * safelycomplete the request now. 794 */ 795 if (esas2r_ioreq_aborted(a, rq, RS_ABORTED)) 796 list_add_tail(&rq->comp_list, 797 &comp_list); 798 } 799 } 800 } 801 802 /* Send the task management request to the firmware */ 803 rqaux->sense_len = 0; 804 rqaux->vrq->scsi.length = 0; 805 rqaux->target_id = targetid; 806 rqaux->vrq->scsi.flags |= cpu_to_le32(lun); 807 memset(rqaux->vrq->scsi.cdb, 0, sizeof(rqaux->vrq->scsi.cdb)); 808 rqaux->vrq->scsi.flags |= 809 cpu_to_le16(task_mgt_func * LOBIT(FCP_CMND_TM_MASK)); 810 811 if (test_bit(AF_FLASHING, &a->flags)) { 812 /* Assume success. if there are active requests, return busy */ 813 rqaux->req_stat = RS_SUCCESS; 814 815 list_for_each_safe(element, next, &a->active_list) { 816 rq = list_entry(element, struct esas2r_request, 817 req_list); 818 if (rq->vrq->scsi.function == VDA_FUNC_SCSI 819 && rq->target_id == targetid 820 && (((u8)le32_to_cpu(rq->vrq->scsi.flags)) == lun 821 || task_mgt_func == 0x20)) /* target reset */ 822 rqaux->req_stat = RS_BUSY; 823 } 824 825 ret = true; 826 } 827 828 spin_unlock_irqrestore(&a->queue_lock, flags); 829 830 if (!test_bit(AF_FLASHING, &a->flags)) 831 esas2r_start_request(a, rqaux); 832 833 esas2r_comp_list_drain(a, &comp_list); 834 835 if (atomic_read(&a->disable_cnt) == 0) 836 esas2r_do_deferred_processes(a); 837 838 esas2r_trace_exit(); 839 840 return ret; 841 } 842 843 void esas2r_reset_bus(struct esas2r_adapter *a) 844 { 845 esas2r_log(ESAS2R_LOG_INFO, "performing a bus reset"); 846 847 if (!test_bit(AF_DEGRADED_MODE, &a->flags) && 848 !test_bit(AF_CHPRST_PENDING, &a->flags) && 849 !test_bit(AF_DISC_PENDING, &a->flags)) { 850 set_bit(AF_BUSRST_NEEDED, &a->flags); 851 set_bit(AF_BUSRST_PENDING, &a->flags); 852 set_bit(AF_OS_RESET, &a->flags); 853 854 esas2r_schedule_tasklet(a); 855 } 856 } 857 858 bool esas2r_ioreq_aborted(struct esas2r_adapter *a, struct esas2r_request *rq, 859 u8 status) 860 { 861 esas2r_trace_enter(); 862 esas2r_trace("rq:%p", rq); 863 list_del_init(&rq->req_list); 864 if (rq->timeout > RQ_MAX_TIMEOUT) { 865 /* 866 * The request timed out, but we could not abort it because a 867 * chip reset occurred. Return busy status. 868 */ 869 rq->req_stat = RS_BUSY; 870 esas2r_trace_exit(); 871 return true; 872 } 873 874 rq->req_stat = status; 875 esas2r_trace_exit(); 876 return true; 877 } 878