1 /******************************************************************************* 2 * IBM Virtual SCSI Target Driver 3 * Copyright (C) 2003-2005 Dave Boutcher (boutcher@us.ibm.com) IBM Corp. 4 * Santiago Leon (santil@us.ibm.com) IBM Corp. 5 * Linda Xie (lxie@us.ibm.com) IBM Corp. 6 * 7 * Copyright (C) 2005-2011 FUJITA Tomonori <tomof@acm.org> 8 * Copyright (C) 2010 Nicholas A. Bellinger <nab@kernel.org> 9 * 10 * Authors: Bryant G. Ly <bryantly@linux.vnet.ibm.com> 11 * Authors: Michael Cyr <mikecyr@linux.vnet.ibm.com> 12 * 13 * This program is free software; you can redistribute it and/or modify 14 * it under the terms of the GNU General Public License as published by 15 * the Free Software Foundation; either version 2 of the License, or 16 * (at your option) any later version. 17 * 18 * This program is distributed in the hope that it will be useful, 19 * but WITHOUT ANY WARRANTY; without even the implied warranty of 20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 21 * GNU General Public License for more details. 22 * 23 ****************************************************************************/ 24 25 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 26 27 #include <linux/module.h> 28 #include <linux/kernel.h> 29 #include <linux/slab.h> 30 #include <linux/types.h> 31 #include <linux/list.h> 32 #include <linux/string.h> 33 34 #include <target/target_core_base.h> 35 #include <target/target_core_fabric.h> 36 37 #include <asm/hvcall.h> 38 #include <asm/vio.h> 39 40 #include <scsi/viosrp.h> 41 42 #include "ibmvscsi_tgt.h" 43 44 #define IBMVSCSIS_VERSION "v0.2" 45 46 #define INITIAL_SRP_LIMIT 800 47 #define DEFAULT_MAX_SECTORS 256 48 49 static uint max_vdma_size = MAX_H_COPY_RDMA; 50 51 static char system_id[SYS_ID_NAME_LEN] = ""; 52 static char partition_name[PARTITION_NAMELEN] = "UNKNOWN"; 53 static uint partition_number = -1; 54 55 /* Adapter list and lock to control it */ 56 static DEFINE_SPINLOCK(ibmvscsis_dev_lock); 57 static LIST_HEAD(ibmvscsis_dev_list); 58 59 static long ibmvscsis_parse_command(struct scsi_info *vscsi, 60 struct viosrp_crq *crq); 61 62 static void ibmvscsis_adapter_idle(struct scsi_info *vscsi); 63 64 static void ibmvscsis_determine_resid(struct se_cmd *se_cmd, 65 struct srp_rsp *rsp) 66 { 67 u32 residual_count = se_cmd->residual_count; 68 69 if (!residual_count) 70 return; 71 72 if (se_cmd->se_cmd_flags & SCF_UNDERFLOW_BIT) { 73 if (se_cmd->data_direction == DMA_TO_DEVICE) { 74 /* residual data from an underflow write */ 75 rsp->flags = SRP_RSP_FLAG_DOUNDER; 76 rsp->data_out_res_cnt = cpu_to_be32(residual_count); 77 } else if (se_cmd->data_direction == DMA_FROM_DEVICE) { 78 /* residual data from an underflow read */ 79 rsp->flags = SRP_RSP_FLAG_DIUNDER; 80 rsp->data_in_res_cnt = cpu_to_be32(residual_count); 81 } 82 } else if (se_cmd->se_cmd_flags & SCF_OVERFLOW_BIT) { 83 if (se_cmd->data_direction == DMA_TO_DEVICE) { 84 /* residual data from an overflow write */ 85 rsp->flags = SRP_RSP_FLAG_DOOVER; 86 rsp->data_out_res_cnt = cpu_to_be32(residual_count); 87 } else if (se_cmd->data_direction == DMA_FROM_DEVICE) { 88 /* residual data from an overflow read */ 89 rsp->flags = SRP_RSP_FLAG_DIOVER; 90 rsp->data_in_res_cnt = cpu_to_be32(residual_count); 91 } 92 } 93 } 94 95 /** 96 * connection_broken() - Determine if the connection to the client is good 97 * @vscsi: Pointer to our adapter structure 98 * 99 * This function attempts to send a ping MAD to the client. If the call to 100 * queue the request returns H_CLOSED then the connection has been broken 101 * and the function returns TRUE. 102 * 103 * EXECUTION ENVIRONMENT: 104 * Interrupt or Process environment 105 */ 106 static bool connection_broken(struct scsi_info *vscsi) 107 { 108 struct viosrp_crq *crq; 109 u64 buffer[2] = { 0, 0 }; 110 long h_return_code; 111 bool rc = false; 112 113 /* create a PING crq */ 114 crq = (struct viosrp_crq *)&buffer; 115 crq->valid = VALID_CMD_RESP_EL; 116 crq->format = MESSAGE_IN_CRQ; 117 crq->status = PING; 118 119 h_return_code = h_send_crq(vscsi->dds.unit_id, 120 cpu_to_be64(buffer[MSG_HI]), 121 cpu_to_be64(buffer[MSG_LOW])); 122 123 pr_debug("connection_broken: rc %ld\n", h_return_code); 124 125 if (h_return_code == H_CLOSED) 126 rc = true; 127 128 return rc; 129 } 130 131 /** 132 * ibmvscsis_unregister_command_q() - Helper Function-Unregister Command Queue 133 * @vscsi: Pointer to our adapter structure 134 * 135 * This function calls h_free_q then frees the interrupt bit etc. 136 * It must release the lock before doing so because of the time it can take 137 * for h_free_crq in PHYP 138 * NOTE: the caller must make sure that state and or flags will prevent 139 * interrupt handler from scheduling work. 140 * NOTE: anyone calling this function may need to set the CRQ_CLOSED flag 141 * we can't do it here, because we don't have the lock 142 * 143 * EXECUTION ENVIRONMENT: 144 * Process level 145 */ 146 static long ibmvscsis_unregister_command_q(struct scsi_info *vscsi) 147 { 148 long qrc; 149 long rc = ADAPT_SUCCESS; 150 int ticks = 0; 151 152 do { 153 qrc = h_free_crq(vscsi->dds.unit_id); 154 switch (qrc) { 155 case H_SUCCESS: 156 break; 157 158 case H_HARDWARE: 159 case H_PARAMETER: 160 dev_err(&vscsi->dev, "unregister_command_q: error from h_free_crq %ld\n", 161 qrc); 162 rc = ERROR; 163 break; 164 165 case H_BUSY: 166 case H_LONG_BUSY_ORDER_1_MSEC: 167 /* msleep not good for small values */ 168 usleep_range(1000, 2000); 169 ticks += 1; 170 break; 171 case H_LONG_BUSY_ORDER_10_MSEC: 172 usleep_range(10000, 20000); 173 ticks += 10; 174 break; 175 case H_LONG_BUSY_ORDER_100_MSEC: 176 msleep(100); 177 ticks += 100; 178 break; 179 case H_LONG_BUSY_ORDER_1_SEC: 180 ssleep(1); 181 ticks += 1000; 182 break; 183 case H_LONG_BUSY_ORDER_10_SEC: 184 ssleep(10); 185 ticks += 10000; 186 break; 187 case H_LONG_BUSY_ORDER_100_SEC: 188 ssleep(100); 189 ticks += 100000; 190 break; 191 default: 192 dev_err(&vscsi->dev, "unregister_command_q: unknown error %ld from h_free_crq\n", 193 qrc); 194 rc = ERROR; 195 break; 196 } 197 198 /* 199 * dont wait more then 300 seconds 200 * ticks are in milliseconds more or less 201 */ 202 if (ticks > 300000 && qrc != H_SUCCESS) { 203 rc = ERROR; 204 dev_err(&vscsi->dev, "Excessive wait for h_free_crq\n"); 205 } 206 } while (qrc != H_SUCCESS && rc == ADAPT_SUCCESS); 207 208 pr_debug("Freeing CRQ: phyp rc %ld, rc %ld\n", qrc, rc); 209 210 return rc; 211 } 212 213 /** 214 * ibmvscsis_delete_client_info() - Helper function to Delete Client Info 215 * @vscsi: Pointer to our adapter structure 216 * @client_closed: True if client closed its queue 217 * 218 * Deletes information specific to the client when the client goes away 219 * 220 * EXECUTION ENVIRONMENT: 221 * Interrupt or Process 222 */ 223 static void ibmvscsis_delete_client_info(struct scsi_info *vscsi, 224 bool client_closed) 225 { 226 vscsi->client_cap = 0; 227 228 /* 229 * Some things we don't want to clear if we're closing the queue, 230 * because some clients don't resend the host handshake when they 231 * get a transport event. 232 */ 233 if (client_closed) 234 vscsi->client_data.os_type = 0; 235 } 236 237 /** 238 * ibmvscsis_free_command_q() - Free Command Queue 239 * @vscsi: Pointer to our adapter structure 240 * 241 * This function calls unregister_command_q, then clears interrupts and 242 * any pending interrupt acknowledgments associated with the command q. 243 * It also clears memory if there is no error. 244 * 245 * PHYP did not meet the PAPR architecture so that we must give up the 246 * lock. This causes a timing hole regarding state change. To close the 247 * hole this routine does accounting on any change that occurred during 248 * the time the lock is not held. 249 * NOTE: must give up and then acquire the interrupt lock, the caller must 250 * make sure that state and or flags will prevent interrupt handler from 251 * scheduling work. 252 * 253 * EXECUTION ENVIRONMENT: 254 * Process level, interrupt lock is held 255 */ 256 static long ibmvscsis_free_command_q(struct scsi_info *vscsi) 257 { 258 int bytes; 259 u32 flags_under_lock; 260 u16 state_under_lock; 261 long rc = ADAPT_SUCCESS; 262 263 if (!(vscsi->flags & CRQ_CLOSED)) { 264 vio_disable_interrupts(vscsi->dma_dev); 265 266 state_under_lock = vscsi->new_state; 267 flags_under_lock = vscsi->flags; 268 vscsi->phyp_acr_state = 0; 269 vscsi->phyp_acr_flags = 0; 270 271 spin_unlock_bh(&vscsi->intr_lock); 272 rc = ibmvscsis_unregister_command_q(vscsi); 273 spin_lock_bh(&vscsi->intr_lock); 274 275 if (state_under_lock != vscsi->new_state) 276 vscsi->phyp_acr_state = vscsi->new_state; 277 278 vscsi->phyp_acr_flags = ((~flags_under_lock) & vscsi->flags); 279 280 if (rc == ADAPT_SUCCESS) { 281 bytes = vscsi->cmd_q.size * PAGE_SIZE; 282 memset(vscsi->cmd_q.base_addr, 0, bytes); 283 vscsi->cmd_q.index = 0; 284 vscsi->flags |= CRQ_CLOSED; 285 286 ibmvscsis_delete_client_info(vscsi, false); 287 } 288 289 pr_debug("free_command_q: flags 0x%x, state 0x%hx, acr_flags 0x%x, acr_state 0x%hx\n", 290 vscsi->flags, vscsi->state, vscsi->phyp_acr_flags, 291 vscsi->phyp_acr_state); 292 } 293 return rc; 294 } 295 296 /** 297 * ibmvscsis_cmd_q_dequeue() - Get valid Command element 298 * @mask: Mask to use in case index wraps 299 * @current_index: Current index into command queue 300 * @base_addr: Pointer to start of command queue 301 * 302 * Returns a pointer to a valid command element or NULL, if the command 303 * queue is empty 304 * 305 * EXECUTION ENVIRONMENT: 306 * Interrupt environment, interrupt lock held 307 */ 308 static struct viosrp_crq *ibmvscsis_cmd_q_dequeue(uint mask, 309 uint *current_index, 310 struct viosrp_crq *base_addr) 311 { 312 struct viosrp_crq *ptr; 313 314 ptr = base_addr + *current_index; 315 316 if (ptr->valid) { 317 *current_index = (*current_index + 1) & mask; 318 dma_rmb(); 319 } else { 320 ptr = NULL; 321 } 322 323 return ptr; 324 } 325 326 /** 327 * ibmvscsis_send_init_message() - send initialize message to the client 328 * @vscsi: Pointer to our adapter structure 329 * @format: Which Init Message format to send 330 * 331 * EXECUTION ENVIRONMENT: 332 * Interrupt environment interrupt lock held 333 */ 334 static long ibmvscsis_send_init_message(struct scsi_info *vscsi, u8 format) 335 { 336 struct viosrp_crq *crq; 337 u64 buffer[2] = { 0, 0 }; 338 long rc; 339 340 crq = (struct viosrp_crq *)&buffer; 341 crq->valid = VALID_INIT_MSG; 342 crq->format = format; 343 rc = h_send_crq(vscsi->dds.unit_id, cpu_to_be64(buffer[MSG_HI]), 344 cpu_to_be64(buffer[MSG_LOW])); 345 346 return rc; 347 } 348 349 /** 350 * ibmvscsis_check_init_msg() - Check init message valid 351 * @vscsi: Pointer to our adapter structure 352 * @format: Pointer to return format of Init Message, if any. 353 * Set to UNUSED_FORMAT if no Init Message in queue. 354 * 355 * Checks if an initialize message was queued by the initiatior 356 * after the queue was created and before the interrupt was enabled. 357 * 358 * EXECUTION ENVIRONMENT: 359 * Process level only, interrupt lock held 360 */ 361 static long ibmvscsis_check_init_msg(struct scsi_info *vscsi, uint *format) 362 { 363 struct viosrp_crq *crq; 364 long rc = ADAPT_SUCCESS; 365 366 crq = ibmvscsis_cmd_q_dequeue(vscsi->cmd_q.mask, &vscsi->cmd_q.index, 367 vscsi->cmd_q.base_addr); 368 if (!crq) { 369 *format = (uint)UNUSED_FORMAT; 370 } else if (crq->valid == VALID_INIT_MSG && crq->format == INIT_MSG) { 371 *format = (uint)INIT_MSG; 372 crq->valid = INVALIDATE_CMD_RESP_EL; 373 dma_rmb(); 374 375 /* 376 * the caller has ensured no initialize message was 377 * sent after the queue was 378 * created so there should be no other message on the queue. 379 */ 380 crq = ibmvscsis_cmd_q_dequeue(vscsi->cmd_q.mask, 381 &vscsi->cmd_q.index, 382 vscsi->cmd_q.base_addr); 383 if (crq) { 384 *format = (uint)(crq->format); 385 rc = ERROR; 386 crq->valid = INVALIDATE_CMD_RESP_EL; 387 dma_rmb(); 388 } 389 } else { 390 *format = (uint)(crq->format); 391 rc = ERROR; 392 crq->valid = INVALIDATE_CMD_RESP_EL; 393 dma_rmb(); 394 } 395 396 return rc; 397 } 398 399 /** 400 * ibmvscsis_disconnect() - Helper function to disconnect 401 * @work: Pointer to work_struct, gives access to our adapter structure 402 * 403 * An error has occurred or the driver received a Transport event, 404 * and the driver is requesting that the command queue be de-registered 405 * in a safe manner. If there is no outstanding I/O then we can stop the 406 * queue. If we are restarting the queue it will be reflected in the 407 * the state of the adapter. 408 * 409 * EXECUTION ENVIRONMENT: 410 * Process environment 411 */ 412 static void ibmvscsis_disconnect(struct work_struct *work) 413 { 414 struct scsi_info *vscsi = container_of(work, struct scsi_info, 415 proc_work); 416 u16 new_state; 417 bool wait_idle = false; 418 419 spin_lock_bh(&vscsi->intr_lock); 420 new_state = vscsi->new_state; 421 vscsi->new_state = 0; 422 423 pr_debug("disconnect: flags 0x%x, state 0x%hx\n", vscsi->flags, 424 vscsi->state); 425 426 /* 427 * check which state we are in and see if we 428 * should transitition to the new state 429 */ 430 switch (vscsi->state) { 431 /* Should never be called while in this state. */ 432 case NO_QUEUE: 433 /* 434 * Can never transition from this state; 435 * igonore errors and logout. 436 */ 437 case UNCONFIGURING: 438 break; 439 440 /* can transition from this state to UNCONFIGURING */ 441 case ERR_DISCONNECT: 442 if (new_state == UNCONFIGURING) 443 vscsi->state = new_state; 444 break; 445 446 /* 447 * Can transition from this state to to unconfiguring 448 * or err disconnect. 449 */ 450 case ERR_DISCONNECT_RECONNECT: 451 switch (new_state) { 452 case UNCONFIGURING: 453 case ERR_DISCONNECT: 454 vscsi->state = new_state; 455 break; 456 457 case WAIT_IDLE: 458 break; 459 default: 460 break; 461 } 462 break; 463 464 /* can transition from this state to UNCONFIGURING */ 465 case ERR_DISCONNECTED: 466 if (new_state == UNCONFIGURING) 467 vscsi->state = new_state; 468 break; 469 470 case WAIT_ENABLED: 471 switch (new_state) { 472 case UNCONFIGURING: 473 vscsi->state = new_state; 474 vscsi->flags |= RESPONSE_Q_DOWN; 475 vscsi->flags &= ~(SCHEDULE_DISCONNECT | 476 DISCONNECT_SCHEDULED); 477 dma_rmb(); 478 if (vscsi->flags & CFG_SLEEPING) { 479 vscsi->flags &= ~CFG_SLEEPING; 480 complete(&vscsi->unconfig); 481 } 482 break; 483 484 /* should never happen */ 485 case ERR_DISCONNECT: 486 case ERR_DISCONNECT_RECONNECT: 487 case WAIT_IDLE: 488 dev_err(&vscsi->dev, "disconnect: invalid state %d for WAIT_IDLE\n", 489 vscsi->state); 490 break; 491 } 492 break; 493 494 case WAIT_IDLE: 495 switch (new_state) { 496 case UNCONFIGURING: 497 vscsi->flags |= RESPONSE_Q_DOWN; 498 vscsi->state = new_state; 499 vscsi->flags &= ~(SCHEDULE_DISCONNECT | 500 DISCONNECT_SCHEDULED); 501 ibmvscsis_free_command_q(vscsi); 502 break; 503 case ERR_DISCONNECT: 504 case ERR_DISCONNECT_RECONNECT: 505 vscsi->state = new_state; 506 break; 507 } 508 break; 509 510 /* 511 * Initiator has not done a successful srp login 512 * or has done a successful srp logout ( adapter was not 513 * busy). In the first case there can be responses queued 514 * waiting for space on the initiators response queue (MAD) 515 * The second case the adapter is idle. Assume the worse case, 516 * i.e. the second case. 517 */ 518 case WAIT_CONNECTION: 519 case CONNECTED: 520 case SRP_PROCESSING: 521 wait_idle = true; 522 vscsi->state = new_state; 523 break; 524 525 /* can transition from this state to UNCONFIGURING */ 526 case UNDEFINED: 527 if (new_state == UNCONFIGURING) 528 vscsi->state = new_state; 529 break; 530 default: 531 break; 532 } 533 534 if (wait_idle) { 535 pr_debug("disconnect start wait, active %d, sched %d\n", 536 (int)list_empty(&vscsi->active_q), 537 (int)list_empty(&vscsi->schedule_q)); 538 if (!list_empty(&vscsi->active_q) || 539 !list_empty(&vscsi->schedule_q)) { 540 vscsi->flags |= WAIT_FOR_IDLE; 541 pr_debug("disconnect flags 0x%x\n", vscsi->flags); 542 /* 543 * This routine is can not be called with the interrupt 544 * lock held. 545 */ 546 spin_unlock_bh(&vscsi->intr_lock); 547 wait_for_completion(&vscsi->wait_idle); 548 spin_lock_bh(&vscsi->intr_lock); 549 } 550 pr_debug("disconnect stop wait\n"); 551 552 ibmvscsis_adapter_idle(vscsi); 553 } 554 555 spin_unlock_bh(&vscsi->intr_lock); 556 } 557 558 /** 559 * ibmvscsis_post_disconnect() - Schedule the disconnect 560 * @vscsi: Pointer to our adapter structure 561 * @new_state: State to move to after disconnecting 562 * @flag_bits: Flags to turn on in adapter structure 563 * 564 * If it's already been scheduled, then see if we need to "upgrade" 565 * the new state (if the one passed in is more "severe" than the 566 * previous one). 567 * 568 * PRECONDITION: 569 * interrupt lock is held 570 */ 571 static void ibmvscsis_post_disconnect(struct scsi_info *vscsi, uint new_state, 572 uint flag_bits) 573 { 574 uint state; 575 576 /* check the validity of the new state */ 577 switch (new_state) { 578 case UNCONFIGURING: 579 case ERR_DISCONNECT: 580 case ERR_DISCONNECT_RECONNECT: 581 case WAIT_IDLE: 582 break; 583 584 default: 585 dev_err(&vscsi->dev, "post_disconnect: Invalid new state %d\n", 586 new_state); 587 return; 588 } 589 590 vscsi->flags |= flag_bits; 591 592 pr_debug("post_disconnect: new_state 0x%x, flag_bits 0x%x, vscsi->flags 0x%x, state %hx\n", 593 new_state, flag_bits, vscsi->flags, vscsi->state); 594 595 if (!(vscsi->flags & (DISCONNECT_SCHEDULED | SCHEDULE_DISCONNECT))) { 596 vscsi->flags |= SCHEDULE_DISCONNECT; 597 vscsi->new_state = new_state; 598 599 INIT_WORK(&vscsi->proc_work, ibmvscsis_disconnect); 600 (void)queue_work(vscsi->work_q, &vscsi->proc_work); 601 } else { 602 if (vscsi->new_state) 603 state = vscsi->new_state; 604 else 605 state = vscsi->state; 606 607 switch (state) { 608 case NO_QUEUE: 609 case UNCONFIGURING: 610 break; 611 612 case ERR_DISCONNECTED: 613 case ERR_DISCONNECT: 614 case UNDEFINED: 615 if (new_state == UNCONFIGURING) 616 vscsi->new_state = new_state; 617 break; 618 619 case ERR_DISCONNECT_RECONNECT: 620 switch (new_state) { 621 case UNCONFIGURING: 622 case ERR_DISCONNECT: 623 vscsi->new_state = new_state; 624 break; 625 default: 626 break; 627 } 628 break; 629 630 case WAIT_ENABLED: 631 case WAIT_IDLE: 632 case WAIT_CONNECTION: 633 case CONNECTED: 634 case SRP_PROCESSING: 635 vscsi->new_state = new_state; 636 break; 637 638 default: 639 break; 640 } 641 } 642 643 pr_debug("Leaving post_disconnect: flags 0x%x, new_state 0x%x\n", 644 vscsi->flags, vscsi->new_state); 645 } 646 647 /** 648 * ibmvscsis_handle_init_compl_msg() - Respond to an Init Complete Message 649 * @vscsi: Pointer to our adapter structure 650 * 651 * Must be called with interrupt lock held. 652 */ 653 static long ibmvscsis_handle_init_compl_msg(struct scsi_info *vscsi) 654 { 655 long rc = ADAPT_SUCCESS; 656 657 switch (vscsi->state) { 658 case NO_QUEUE: 659 case ERR_DISCONNECT: 660 case ERR_DISCONNECT_RECONNECT: 661 case ERR_DISCONNECTED: 662 case UNCONFIGURING: 663 case UNDEFINED: 664 rc = ERROR; 665 break; 666 667 case WAIT_CONNECTION: 668 vscsi->state = CONNECTED; 669 break; 670 671 case WAIT_IDLE: 672 case SRP_PROCESSING: 673 case CONNECTED: 674 case WAIT_ENABLED: 675 default: 676 rc = ERROR; 677 dev_err(&vscsi->dev, "init_msg: invalid state %d to get init compl msg\n", 678 vscsi->state); 679 ibmvscsis_post_disconnect(vscsi, ERR_DISCONNECT_RECONNECT, 0); 680 break; 681 } 682 683 return rc; 684 } 685 686 /** 687 * ibmvscsis_handle_init_msg() - Respond to an Init Message 688 * @vscsi: Pointer to our adapter structure 689 * 690 * Must be called with interrupt lock held. 691 */ 692 static long ibmvscsis_handle_init_msg(struct scsi_info *vscsi) 693 { 694 long rc = ADAPT_SUCCESS; 695 696 switch (vscsi->state) { 697 case WAIT_CONNECTION: 698 rc = ibmvscsis_send_init_message(vscsi, INIT_COMPLETE_MSG); 699 switch (rc) { 700 case H_SUCCESS: 701 vscsi->state = CONNECTED; 702 break; 703 704 case H_PARAMETER: 705 dev_err(&vscsi->dev, "init_msg: failed to send, rc %ld\n", 706 rc); 707 ibmvscsis_post_disconnect(vscsi, ERR_DISCONNECT, 0); 708 break; 709 710 case H_DROPPED: 711 dev_err(&vscsi->dev, "init_msg: failed to send, rc %ld\n", 712 rc); 713 rc = ERROR; 714 ibmvscsis_post_disconnect(vscsi, 715 ERR_DISCONNECT_RECONNECT, 0); 716 break; 717 718 case H_CLOSED: 719 pr_warn("init_msg: failed to send, rc %ld\n", rc); 720 rc = 0; 721 break; 722 } 723 break; 724 725 case UNDEFINED: 726 rc = ERROR; 727 break; 728 729 case UNCONFIGURING: 730 break; 731 732 case WAIT_ENABLED: 733 case CONNECTED: 734 case SRP_PROCESSING: 735 case WAIT_IDLE: 736 case NO_QUEUE: 737 case ERR_DISCONNECT: 738 case ERR_DISCONNECT_RECONNECT: 739 case ERR_DISCONNECTED: 740 default: 741 rc = ERROR; 742 dev_err(&vscsi->dev, "init_msg: invalid state %d to get init msg\n", 743 vscsi->state); 744 ibmvscsis_post_disconnect(vscsi, ERR_DISCONNECT_RECONNECT, 0); 745 break; 746 } 747 748 return rc; 749 } 750 751 /** 752 * ibmvscsis_init_msg() - Respond to an init message 753 * @vscsi: Pointer to our adapter structure 754 * @crq: Pointer to CRQ element containing the Init Message 755 * 756 * EXECUTION ENVIRONMENT: 757 * Interrupt, interrupt lock held 758 */ 759 static long ibmvscsis_init_msg(struct scsi_info *vscsi, struct viosrp_crq *crq) 760 { 761 long rc = ADAPT_SUCCESS; 762 763 pr_debug("init_msg: state 0x%hx\n", vscsi->state); 764 765 rc = h_vioctl(vscsi->dds.unit_id, H_GET_PARTNER_INFO, 766 (u64)vscsi->map_ioba | ((u64)PAGE_SIZE << 32), 0, 0, 0, 767 0); 768 if (rc == H_SUCCESS) { 769 vscsi->client_data.partition_number = 770 be64_to_cpu(*(u64 *)vscsi->map_buf); 771 pr_debug("init_msg, part num %d\n", 772 vscsi->client_data.partition_number); 773 } else { 774 pr_debug("init_msg h_vioctl rc %ld\n", rc); 775 rc = ADAPT_SUCCESS; 776 } 777 778 if (crq->format == INIT_MSG) { 779 rc = ibmvscsis_handle_init_msg(vscsi); 780 } else if (crq->format == INIT_COMPLETE_MSG) { 781 rc = ibmvscsis_handle_init_compl_msg(vscsi); 782 } else { 783 rc = ERROR; 784 dev_err(&vscsi->dev, "init_msg: invalid format %d\n", 785 (uint)crq->format); 786 ibmvscsis_post_disconnect(vscsi, ERR_DISCONNECT_RECONNECT, 0); 787 } 788 789 return rc; 790 } 791 792 /** 793 * ibmvscsis_establish_new_q() - Establish new CRQ queue 794 * @vscsi: Pointer to our adapter structure 795 * 796 * Must be called with interrupt lock held. 797 */ 798 static long ibmvscsis_establish_new_q(struct scsi_info *vscsi) 799 { 800 long rc = ADAPT_SUCCESS; 801 uint format; 802 803 vscsi->flags &= PRESERVE_FLAG_FIELDS; 804 vscsi->rsp_q_timer.timer_pops = 0; 805 vscsi->debit = 0; 806 vscsi->credit = 0; 807 808 rc = vio_enable_interrupts(vscsi->dma_dev); 809 if (rc) { 810 pr_warn("establish_new_q: failed to enable interrupts, rc %ld\n", 811 rc); 812 return rc; 813 } 814 815 rc = ibmvscsis_check_init_msg(vscsi, &format); 816 if (rc) { 817 dev_err(&vscsi->dev, "establish_new_q: check_init_msg failed, rc %ld\n", 818 rc); 819 return rc; 820 } 821 822 if (format == UNUSED_FORMAT) { 823 rc = ibmvscsis_send_init_message(vscsi, INIT_MSG); 824 switch (rc) { 825 case H_SUCCESS: 826 case H_DROPPED: 827 case H_CLOSED: 828 rc = ADAPT_SUCCESS; 829 break; 830 831 case H_PARAMETER: 832 case H_HARDWARE: 833 break; 834 835 default: 836 vscsi->state = UNDEFINED; 837 rc = H_HARDWARE; 838 break; 839 } 840 } else if (format == INIT_MSG) { 841 rc = ibmvscsis_handle_init_msg(vscsi); 842 } 843 844 return rc; 845 } 846 847 /** 848 * ibmvscsis_reset_queue() - Reset CRQ Queue 849 * @vscsi: Pointer to our adapter structure 850 * 851 * This function calls h_free_q and then calls h_reg_q and does all 852 * of the bookkeeping to get us back to where we can communicate. 853 * 854 * Actually, we don't always call h_free_crq. A problem was discovered 855 * where one partition would close and reopen his queue, which would 856 * cause his partner to get a transport event, which would cause him to 857 * close and reopen his queue, which would cause the original partition 858 * to get a transport event, etc., etc. To prevent this, we don't 859 * actually close our queue if the client initiated the reset, (i.e. 860 * either we got a transport event or we have detected that the client's 861 * queue is gone) 862 * 863 * EXECUTION ENVIRONMENT: 864 * Process environment, called with interrupt lock held 865 */ 866 static void ibmvscsis_reset_queue(struct scsi_info *vscsi) 867 { 868 int bytes; 869 long rc = ADAPT_SUCCESS; 870 871 pr_debug("reset_queue: flags 0x%x\n", vscsi->flags); 872 873 /* don't reset, the client did it for us */ 874 if (vscsi->flags & (CLIENT_FAILED | TRANS_EVENT)) { 875 vscsi->flags &= PRESERVE_FLAG_FIELDS; 876 vscsi->rsp_q_timer.timer_pops = 0; 877 vscsi->debit = 0; 878 vscsi->credit = 0; 879 vscsi->state = WAIT_CONNECTION; 880 vio_enable_interrupts(vscsi->dma_dev); 881 } else { 882 rc = ibmvscsis_free_command_q(vscsi); 883 if (rc == ADAPT_SUCCESS) { 884 vscsi->state = WAIT_CONNECTION; 885 886 bytes = vscsi->cmd_q.size * PAGE_SIZE; 887 rc = h_reg_crq(vscsi->dds.unit_id, 888 vscsi->cmd_q.crq_token, bytes); 889 if (rc == H_CLOSED || rc == H_SUCCESS) { 890 rc = ibmvscsis_establish_new_q(vscsi); 891 } 892 893 if (rc != ADAPT_SUCCESS) { 894 pr_debug("reset_queue: reg_crq rc %ld\n", rc); 895 896 vscsi->state = ERR_DISCONNECTED; 897 vscsi->flags |= RESPONSE_Q_DOWN; 898 ibmvscsis_free_command_q(vscsi); 899 } 900 } else { 901 vscsi->state = ERR_DISCONNECTED; 902 vscsi->flags |= RESPONSE_Q_DOWN; 903 } 904 } 905 } 906 907 /** 908 * ibmvscsis_free_cmd_resources() - Free command resources 909 * @vscsi: Pointer to our adapter structure 910 * @cmd: Command which is not longer in use 911 * 912 * Must be called with interrupt lock held. 913 */ 914 static void ibmvscsis_free_cmd_resources(struct scsi_info *vscsi, 915 struct ibmvscsis_cmd *cmd) 916 { 917 struct iu_entry *iue = cmd->iue; 918 919 switch (cmd->type) { 920 case TASK_MANAGEMENT: 921 case SCSI_CDB: 922 /* 923 * When the queue goes down this value is cleared, so it 924 * cannot be cleared in this general purpose function. 925 */ 926 if (vscsi->debit) 927 vscsi->debit -= 1; 928 break; 929 case ADAPTER_MAD: 930 vscsi->flags &= ~PROCESSING_MAD; 931 break; 932 case UNSET_TYPE: 933 break; 934 default: 935 dev_err(&vscsi->dev, "free_cmd_resources unknown type %d\n", 936 cmd->type); 937 break; 938 } 939 940 cmd->iue = NULL; 941 list_add_tail(&cmd->list, &vscsi->free_cmd); 942 srp_iu_put(iue); 943 944 if (list_empty(&vscsi->active_q) && list_empty(&vscsi->schedule_q) && 945 list_empty(&vscsi->waiting_rsp) && (vscsi->flags & WAIT_FOR_IDLE)) { 946 vscsi->flags &= ~WAIT_FOR_IDLE; 947 complete(&vscsi->wait_idle); 948 } 949 } 950 951 /** 952 * ibmvscsis_trans_event() - Handle a Transport Event 953 * @vscsi: Pointer to our adapter structure 954 * @crq: Pointer to CRQ entry containing the Transport Event 955 * 956 * Do the logic to close the I_T nexus. This function may not 957 * behave to specification. 958 * 959 * EXECUTION ENVIRONMENT: 960 * Interrupt, interrupt lock held 961 */ 962 static long ibmvscsis_trans_event(struct scsi_info *vscsi, 963 struct viosrp_crq *crq) 964 { 965 long rc = ADAPT_SUCCESS; 966 967 pr_debug("trans_event: format %d, flags 0x%x, state 0x%hx\n", 968 (int)crq->format, vscsi->flags, vscsi->state); 969 970 switch (crq->format) { 971 case MIGRATED: 972 case PARTNER_FAILED: 973 case PARTNER_DEREGISTER: 974 ibmvscsis_delete_client_info(vscsi, true); 975 break; 976 977 default: 978 rc = ERROR; 979 dev_err(&vscsi->dev, "trans_event: invalid format %d\n", 980 (uint)crq->format); 981 ibmvscsis_post_disconnect(vscsi, ERR_DISCONNECT, 982 RESPONSE_Q_DOWN); 983 break; 984 } 985 986 if (rc == ADAPT_SUCCESS) { 987 switch (vscsi->state) { 988 case NO_QUEUE: 989 case ERR_DISCONNECTED: 990 case UNDEFINED: 991 break; 992 993 case UNCONFIGURING: 994 vscsi->flags |= (RESPONSE_Q_DOWN | TRANS_EVENT); 995 break; 996 997 case WAIT_ENABLED: 998 break; 999 1000 case WAIT_CONNECTION: 1001 break; 1002 1003 case CONNECTED: 1004 ibmvscsis_post_disconnect(vscsi, WAIT_IDLE, 1005 (RESPONSE_Q_DOWN | 1006 TRANS_EVENT)); 1007 break; 1008 1009 case SRP_PROCESSING: 1010 if ((vscsi->debit > 0) || 1011 !list_empty(&vscsi->schedule_q) || 1012 !list_empty(&vscsi->waiting_rsp) || 1013 !list_empty(&vscsi->active_q)) { 1014 pr_debug("debit %d, sched %d, wait %d, active %d\n", 1015 vscsi->debit, 1016 (int)list_empty(&vscsi->schedule_q), 1017 (int)list_empty(&vscsi->waiting_rsp), 1018 (int)list_empty(&vscsi->active_q)); 1019 pr_warn("connection lost with outstanding work\n"); 1020 } else { 1021 pr_debug("trans_event: SRP Processing, but no outstanding work\n"); 1022 } 1023 1024 ibmvscsis_post_disconnect(vscsi, WAIT_IDLE, 1025 (RESPONSE_Q_DOWN | 1026 TRANS_EVENT)); 1027 break; 1028 1029 case ERR_DISCONNECT: 1030 case ERR_DISCONNECT_RECONNECT: 1031 case WAIT_IDLE: 1032 vscsi->flags |= (RESPONSE_Q_DOWN | TRANS_EVENT); 1033 break; 1034 } 1035 } 1036 1037 rc = vscsi->flags & SCHEDULE_DISCONNECT; 1038 1039 pr_debug("Leaving trans_event: flags 0x%x, state 0x%hx, rc %ld\n", 1040 vscsi->flags, vscsi->state, rc); 1041 1042 return rc; 1043 } 1044 1045 /** 1046 * ibmvscsis_poll_cmd_q() - Poll Command Queue 1047 * @vscsi: Pointer to our adapter structure 1048 * 1049 * Called to handle command elements that may have arrived while 1050 * interrupts were disabled. 1051 * 1052 * EXECUTION ENVIRONMENT: 1053 * intr_lock must be held 1054 */ 1055 static void ibmvscsis_poll_cmd_q(struct scsi_info *vscsi) 1056 { 1057 struct viosrp_crq *crq; 1058 long rc; 1059 bool ack = true; 1060 volatile u8 valid; 1061 1062 pr_debug("poll_cmd_q: flags 0x%x, state 0x%hx, q index %ud\n", 1063 vscsi->flags, vscsi->state, vscsi->cmd_q.index); 1064 1065 rc = vscsi->flags & SCHEDULE_DISCONNECT; 1066 crq = vscsi->cmd_q.base_addr + vscsi->cmd_q.index; 1067 valid = crq->valid; 1068 dma_rmb(); 1069 1070 while (valid) { 1071 poll_work: 1072 vscsi->cmd_q.index = 1073 (vscsi->cmd_q.index + 1) & vscsi->cmd_q.mask; 1074 1075 if (!rc) { 1076 rc = ibmvscsis_parse_command(vscsi, crq); 1077 } else { 1078 if ((uint)crq->valid == VALID_TRANS_EVENT) { 1079 /* 1080 * must service the transport layer events even 1081 * in an error state, dont break out until all 1082 * the consecutive transport events have been 1083 * processed 1084 */ 1085 rc = ibmvscsis_trans_event(vscsi, crq); 1086 } else if (vscsi->flags & TRANS_EVENT) { 1087 /* 1088 * if a tranport event has occurred leave 1089 * everything but transport events on the queue 1090 */ 1091 pr_debug("poll_cmd_q, ignoring\n"); 1092 1093 /* 1094 * need to decrement the queue index so we can 1095 * look at the elment again 1096 */ 1097 if (vscsi->cmd_q.index) 1098 vscsi->cmd_q.index -= 1; 1099 else 1100 /* 1101 * index is at 0 it just wrapped. 1102 * have it index last element in q 1103 */ 1104 vscsi->cmd_q.index = vscsi->cmd_q.mask; 1105 break; 1106 } 1107 } 1108 1109 crq->valid = INVALIDATE_CMD_RESP_EL; 1110 1111 crq = vscsi->cmd_q.base_addr + vscsi->cmd_q.index; 1112 valid = crq->valid; 1113 dma_rmb(); 1114 } 1115 1116 if (!rc) { 1117 if (ack) { 1118 vio_enable_interrupts(vscsi->dma_dev); 1119 ack = false; 1120 pr_debug("poll_cmd_q, reenabling interrupts\n"); 1121 } 1122 valid = crq->valid; 1123 dma_rmb(); 1124 if (valid) 1125 goto poll_work; 1126 } 1127 1128 pr_debug("Leaving poll_cmd_q: rc %ld\n", rc); 1129 } 1130 1131 /** 1132 * ibmvscsis_free_cmd_qs() - Free elements in queue 1133 * @vscsi: Pointer to our adapter structure 1134 * 1135 * Free all of the elements on all queues that are waiting for 1136 * whatever reason. 1137 * 1138 * PRECONDITION: 1139 * Called with interrupt lock held 1140 */ 1141 static void ibmvscsis_free_cmd_qs(struct scsi_info *vscsi) 1142 { 1143 struct ibmvscsis_cmd *cmd, *nxt; 1144 1145 pr_debug("free_cmd_qs: waiting_rsp empty %d, timer starter %d\n", 1146 (int)list_empty(&vscsi->waiting_rsp), 1147 vscsi->rsp_q_timer.started); 1148 1149 list_for_each_entry_safe(cmd, nxt, &vscsi->waiting_rsp, list) { 1150 list_del(&cmd->list); 1151 ibmvscsis_free_cmd_resources(vscsi, cmd); 1152 } 1153 } 1154 1155 /** 1156 * ibmvscsis_get_free_cmd() - Get free command from list 1157 * @vscsi: Pointer to our adapter structure 1158 * 1159 * Must be called with interrupt lock held. 1160 */ 1161 static struct ibmvscsis_cmd *ibmvscsis_get_free_cmd(struct scsi_info *vscsi) 1162 { 1163 struct ibmvscsis_cmd *cmd = NULL; 1164 struct iu_entry *iue; 1165 1166 iue = srp_iu_get(&vscsi->target); 1167 if (iue) { 1168 cmd = list_first_entry_or_null(&vscsi->free_cmd, 1169 struct ibmvscsis_cmd, list); 1170 if (cmd) { 1171 list_del(&cmd->list); 1172 cmd->iue = iue; 1173 cmd->type = UNSET_TYPE; 1174 memset(&cmd->se_cmd, 0, sizeof(cmd->se_cmd)); 1175 } else { 1176 srp_iu_put(iue); 1177 } 1178 } 1179 1180 return cmd; 1181 } 1182 1183 /** 1184 * ibmvscsis_adapter_idle() - Helper function to handle idle adapter 1185 * @vscsi: Pointer to our adapter structure 1186 * 1187 * This function is called when the adapter is idle when the driver 1188 * is attempting to clear an error condition. 1189 * The adapter is considered busy if any of its cmd queues 1190 * are non-empty. This function can be invoked 1191 * from the off level disconnect function. 1192 * 1193 * EXECUTION ENVIRONMENT: 1194 * Process environment called with interrupt lock held 1195 */ 1196 static void ibmvscsis_adapter_idle(struct scsi_info *vscsi) 1197 { 1198 int free_qs = false; 1199 1200 pr_debug("adapter_idle: flags 0x%x, state 0x%hx\n", vscsi->flags, 1201 vscsi->state); 1202 1203 /* Only need to free qs if we're disconnecting from client */ 1204 if (vscsi->state != WAIT_CONNECTION || vscsi->flags & TRANS_EVENT) 1205 free_qs = true; 1206 1207 switch (vscsi->state) { 1208 case UNCONFIGURING: 1209 ibmvscsis_free_command_q(vscsi); 1210 dma_rmb(); 1211 isync(); 1212 if (vscsi->flags & CFG_SLEEPING) { 1213 vscsi->flags &= ~CFG_SLEEPING; 1214 complete(&vscsi->unconfig); 1215 } 1216 break; 1217 case ERR_DISCONNECT_RECONNECT: 1218 ibmvscsis_reset_queue(vscsi); 1219 pr_debug("adapter_idle, disc_rec: flags 0x%x\n", vscsi->flags); 1220 break; 1221 1222 case ERR_DISCONNECT: 1223 ibmvscsis_free_command_q(vscsi); 1224 vscsi->flags &= ~(SCHEDULE_DISCONNECT | DISCONNECT_SCHEDULED); 1225 vscsi->flags |= RESPONSE_Q_DOWN; 1226 if (vscsi->tport.enabled) 1227 vscsi->state = ERR_DISCONNECTED; 1228 else 1229 vscsi->state = WAIT_ENABLED; 1230 pr_debug("adapter_idle, disc: flags 0x%x, state 0x%hx\n", 1231 vscsi->flags, vscsi->state); 1232 break; 1233 1234 case WAIT_IDLE: 1235 vscsi->rsp_q_timer.timer_pops = 0; 1236 vscsi->debit = 0; 1237 vscsi->credit = 0; 1238 if (vscsi->flags & TRANS_EVENT) { 1239 vscsi->state = WAIT_CONNECTION; 1240 vscsi->flags &= PRESERVE_FLAG_FIELDS; 1241 } else { 1242 vscsi->state = CONNECTED; 1243 vscsi->flags &= ~DISCONNECT_SCHEDULED; 1244 } 1245 1246 pr_debug("adapter_idle, wait: flags 0x%x, state 0x%hx\n", 1247 vscsi->flags, vscsi->state); 1248 ibmvscsis_poll_cmd_q(vscsi); 1249 break; 1250 1251 case ERR_DISCONNECTED: 1252 vscsi->flags &= ~DISCONNECT_SCHEDULED; 1253 pr_debug("adapter_idle, disconnected: flags 0x%x, state 0x%hx\n", 1254 vscsi->flags, vscsi->state); 1255 break; 1256 1257 default: 1258 dev_err(&vscsi->dev, "adapter_idle: in invalid state %d\n", 1259 vscsi->state); 1260 break; 1261 } 1262 1263 if (free_qs) 1264 ibmvscsis_free_cmd_qs(vscsi); 1265 1266 /* 1267 * There is a timing window where we could lose a disconnect request. 1268 * The known path to this window occurs during the DISCONNECT_RECONNECT 1269 * case above: reset_queue calls free_command_q, which will release the 1270 * interrupt lock. During that time, a new post_disconnect call can be 1271 * made with a "more severe" state (DISCONNECT or UNCONFIGURING). 1272 * Because the DISCONNECT_SCHEDULED flag is already set, post_disconnect 1273 * will only set the new_state. Now free_command_q reacquires the intr 1274 * lock and clears the DISCONNECT_SCHEDULED flag (using PRESERVE_FLAG_ 1275 * FIELDS), and the disconnect is lost. This is particularly bad when 1276 * the new disconnect was for UNCONFIGURING, since the unconfigure hangs 1277 * forever. 1278 * Fix is that free command queue sets acr state and acr flags if there 1279 * is a change under the lock 1280 * note free command queue writes to this state it clears it 1281 * before releasing the lock, different drivers call the free command 1282 * queue different times so dont initialize above 1283 */ 1284 if (vscsi->phyp_acr_state != 0) { 1285 /* 1286 * set any bits in flags that may have been cleared by 1287 * a call to free command queue in switch statement 1288 * or reset queue 1289 */ 1290 vscsi->flags |= vscsi->phyp_acr_flags; 1291 ibmvscsis_post_disconnect(vscsi, vscsi->phyp_acr_state, 0); 1292 vscsi->phyp_acr_state = 0; 1293 vscsi->phyp_acr_flags = 0; 1294 1295 pr_debug("adapter_idle: flags 0x%x, state 0x%hx, acr_flags 0x%x, acr_state 0x%hx\n", 1296 vscsi->flags, vscsi->state, vscsi->phyp_acr_flags, 1297 vscsi->phyp_acr_state); 1298 } 1299 1300 pr_debug("Leaving adapter_idle: flags 0x%x, state 0x%hx, new_state 0x%x\n", 1301 vscsi->flags, vscsi->state, vscsi->new_state); 1302 } 1303 1304 /** 1305 * ibmvscsis_copy_crq_packet() - Copy CRQ Packet 1306 * @vscsi: Pointer to our adapter structure 1307 * @cmd: Pointer to command element to use to process the request 1308 * @crq: Pointer to CRQ entry containing the request 1309 * 1310 * Copy the srp information unit from the hosted 1311 * partition using remote dma 1312 * 1313 * EXECUTION ENVIRONMENT: 1314 * Interrupt, interrupt lock held 1315 */ 1316 static long ibmvscsis_copy_crq_packet(struct scsi_info *vscsi, 1317 struct ibmvscsis_cmd *cmd, 1318 struct viosrp_crq *crq) 1319 { 1320 struct iu_entry *iue = cmd->iue; 1321 long rc = 0; 1322 u16 len; 1323 1324 len = be16_to_cpu(crq->IU_length); 1325 if ((len > SRP_MAX_IU_LEN) || (len == 0)) { 1326 dev_err(&vscsi->dev, "copy_crq: Invalid len %d passed", len); 1327 ibmvscsis_post_disconnect(vscsi, ERR_DISCONNECT_RECONNECT, 0); 1328 return SRP_VIOLATION; 1329 } 1330 1331 rc = h_copy_rdma(len, vscsi->dds.window[REMOTE].liobn, 1332 be64_to_cpu(crq->IU_data_ptr), 1333 vscsi->dds.window[LOCAL].liobn, iue->sbuf->dma); 1334 1335 switch (rc) { 1336 case H_SUCCESS: 1337 cmd->init_time = mftb(); 1338 iue->remote_token = crq->IU_data_ptr; 1339 iue->iu_len = len; 1340 pr_debug("copy_crq: ioba 0x%llx, init_time 0x%llx\n", 1341 be64_to_cpu(crq->IU_data_ptr), cmd->init_time); 1342 break; 1343 case H_PERMISSION: 1344 if (connection_broken(vscsi)) 1345 ibmvscsis_post_disconnect(vscsi, 1346 ERR_DISCONNECT_RECONNECT, 1347 (RESPONSE_Q_DOWN | 1348 CLIENT_FAILED)); 1349 else 1350 ibmvscsis_post_disconnect(vscsi, 1351 ERR_DISCONNECT_RECONNECT, 0); 1352 1353 dev_err(&vscsi->dev, "copy_crq: h_copy_rdma failed, rc %ld\n", 1354 rc); 1355 break; 1356 case H_DEST_PARM: 1357 case H_SOURCE_PARM: 1358 default: 1359 dev_err(&vscsi->dev, "copy_crq: h_copy_rdma failed, rc %ld\n", 1360 rc); 1361 ibmvscsis_post_disconnect(vscsi, ERR_DISCONNECT_RECONNECT, 0); 1362 break; 1363 } 1364 1365 return rc; 1366 } 1367 1368 /** 1369 * ibmvscsis_adapter_info - Service an Adapter Info MAnagement Data gram 1370 * @vscsi: Pointer to our adapter structure 1371 * @iue: Information Unit containing the Adapter Info MAD request 1372 * 1373 * EXECUTION ENVIRONMENT: 1374 * Interrupt adapter lock is held 1375 */ 1376 static long ibmvscsis_adapter_info(struct scsi_info *vscsi, 1377 struct iu_entry *iue) 1378 { 1379 struct viosrp_adapter_info *mad = &vio_iu(iue)->mad.adapter_info; 1380 struct mad_adapter_info_data *info; 1381 uint flag_bits = 0; 1382 dma_addr_t token; 1383 long rc; 1384 1385 mad->common.status = cpu_to_be16(VIOSRP_MAD_SUCCESS); 1386 1387 if (be16_to_cpu(mad->common.length) > sizeof(*info)) { 1388 mad->common.status = cpu_to_be16(VIOSRP_MAD_FAILED); 1389 return 0; 1390 } 1391 1392 info = dma_alloc_coherent(&vscsi->dma_dev->dev, sizeof(*info), &token, 1393 GFP_KERNEL); 1394 if (!info) { 1395 dev_err(&vscsi->dev, "bad dma_alloc_coherent %p\n", 1396 iue->target); 1397 mad->common.status = cpu_to_be16(VIOSRP_MAD_FAILED); 1398 return 0; 1399 } 1400 1401 /* Get remote info */ 1402 rc = h_copy_rdma(be16_to_cpu(mad->common.length), 1403 vscsi->dds.window[REMOTE].liobn, 1404 be64_to_cpu(mad->buffer), 1405 vscsi->dds.window[LOCAL].liobn, token); 1406 1407 if (rc != H_SUCCESS) { 1408 if (rc == H_PERMISSION) { 1409 if (connection_broken(vscsi)) 1410 flag_bits = (RESPONSE_Q_DOWN | CLIENT_FAILED); 1411 } 1412 pr_warn("adapter_info: h_copy_rdma from client failed, rc %ld\n", 1413 rc); 1414 pr_debug("adapter_info: ioba 0x%llx, flags 0x%x, flag_bits 0x%x\n", 1415 be64_to_cpu(mad->buffer), vscsi->flags, flag_bits); 1416 ibmvscsis_post_disconnect(vscsi, ERR_DISCONNECT_RECONNECT, 1417 flag_bits); 1418 goto free_dma; 1419 } 1420 1421 /* 1422 * Copy client info, but ignore partition number, which we 1423 * already got from phyp - unless we failed to get it from 1424 * phyp (e.g. if we're running on a p5 system). 1425 */ 1426 if (vscsi->client_data.partition_number == 0) 1427 vscsi->client_data.partition_number = 1428 be32_to_cpu(info->partition_number); 1429 strncpy(vscsi->client_data.srp_version, info->srp_version, 1430 sizeof(vscsi->client_data.srp_version)); 1431 strncpy(vscsi->client_data.partition_name, info->partition_name, 1432 sizeof(vscsi->client_data.partition_name)); 1433 vscsi->client_data.mad_version = be32_to_cpu(info->mad_version); 1434 vscsi->client_data.os_type = be32_to_cpu(info->os_type); 1435 1436 /* Copy our info */ 1437 strncpy(info->srp_version, SRP_VERSION, 1438 sizeof(info->srp_version)); 1439 strncpy(info->partition_name, vscsi->dds.partition_name, 1440 sizeof(info->partition_name)); 1441 info->partition_number = cpu_to_be32(vscsi->dds.partition_num); 1442 info->mad_version = cpu_to_be32(MAD_VERSION_1); 1443 info->os_type = cpu_to_be32(LINUX); 1444 memset(&info->port_max_txu[0], 0, sizeof(info->port_max_txu)); 1445 info->port_max_txu[0] = cpu_to_be32(128 * PAGE_SIZE); 1446 1447 dma_wmb(); 1448 rc = h_copy_rdma(sizeof(*info), vscsi->dds.window[LOCAL].liobn, 1449 token, vscsi->dds.window[REMOTE].liobn, 1450 be64_to_cpu(mad->buffer)); 1451 switch (rc) { 1452 case H_SUCCESS: 1453 break; 1454 1455 case H_SOURCE_PARM: 1456 case H_DEST_PARM: 1457 case H_PERMISSION: 1458 if (connection_broken(vscsi)) 1459 flag_bits = (RESPONSE_Q_DOWN | CLIENT_FAILED); 1460 default: 1461 dev_err(&vscsi->dev, "adapter_info: h_copy_rdma to client failed, rc %ld\n", 1462 rc); 1463 ibmvscsis_post_disconnect(vscsi, 1464 ERR_DISCONNECT_RECONNECT, 1465 flag_bits); 1466 break; 1467 } 1468 1469 free_dma: 1470 dma_free_coherent(&vscsi->dma_dev->dev, sizeof(*info), info, token); 1471 pr_debug("Leaving adapter_info, rc %ld\n", rc); 1472 1473 return rc; 1474 } 1475 1476 /** 1477 * ibmvscsis_cap_mad() - Service a Capabilities MAnagement Data gram 1478 * @vscsi: Pointer to our adapter structure 1479 * @iue: Information Unit containing the Capabilities MAD request 1480 * 1481 * NOTE: if you return an error from this routine you must be 1482 * disconnecting or you will cause a hang 1483 * 1484 * EXECUTION ENVIRONMENT: 1485 * Interrupt called with adapter lock held 1486 */ 1487 static int ibmvscsis_cap_mad(struct scsi_info *vscsi, struct iu_entry *iue) 1488 { 1489 struct viosrp_capabilities *mad = &vio_iu(iue)->mad.capabilities; 1490 struct capabilities *cap; 1491 struct mad_capability_common *common; 1492 dma_addr_t token; 1493 u16 olen, len, status, min_len, cap_len; 1494 u32 flag; 1495 uint flag_bits = 0; 1496 long rc = 0; 1497 1498 olen = be16_to_cpu(mad->common.length); 1499 /* 1500 * struct capabilities hardcodes a couple capabilities after the 1501 * header, but the capabilities can actually be in any order. 1502 */ 1503 min_len = offsetof(struct capabilities, migration); 1504 if ((olen < min_len) || (olen > PAGE_SIZE)) { 1505 pr_warn("cap_mad: invalid len %d\n", olen); 1506 mad->common.status = cpu_to_be16(VIOSRP_MAD_FAILED); 1507 return 0; 1508 } 1509 1510 cap = dma_alloc_coherent(&vscsi->dma_dev->dev, olen, &token, 1511 GFP_KERNEL); 1512 if (!cap) { 1513 dev_err(&vscsi->dev, "bad dma_alloc_coherent %p\n", 1514 iue->target); 1515 mad->common.status = cpu_to_be16(VIOSRP_MAD_FAILED); 1516 return 0; 1517 } 1518 rc = h_copy_rdma(olen, vscsi->dds.window[REMOTE].liobn, 1519 be64_to_cpu(mad->buffer), 1520 vscsi->dds.window[LOCAL].liobn, token); 1521 if (rc == H_SUCCESS) { 1522 strncpy(cap->name, dev_name(&vscsi->dma_dev->dev), 1523 SRP_MAX_LOC_LEN); 1524 1525 len = olen - min_len; 1526 status = VIOSRP_MAD_SUCCESS; 1527 common = (struct mad_capability_common *)&cap->migration; 1528 1529 while ((len > 0) && (status == VIOSRP_MAD_SUCCESS) && !rc) { 1530 pr_debug("cap_mad: len left %hd, cap type %d, cap len %hd\n", 1531 len, be32_to_cpu(common->cap_type), 1532 be16_to_cpu(common->length)); 1533 1534 cap_len = be16_to_cpu(common->length); 1535 if (cap_len > len) { 1536 dev_err(&vscsi->dev, "cap_mad: cap len mismatch with total len\n"); 1537 status = VIOSRP_MAD_FAILED; 1538 break; 1539 } 1540 1541 if (cap_len == 0) { 1542 dev_err(&vscsi->dev, "cap_mad: cap len is 0\n"); 1543 status = VIOSRP_MAD_FAILED; 1544 break; 1545 } 1546 1547 switch (common->cap_type) { 1548 default: 1549 pr_debug("cap_mad: unsupported capability\n"); 1550 common->server_support = 0; 1551 flag = cpu_to_be32((u32)CAP_LIST_SUPPORTED); 1552 cap->flags &= ~flag; 1553 break; 1554 } 1555 1556 len = len - cap_len; 1557 common = (struct mad_capability_common *) 1558 ((char *)common + cap_len); 1559 } 1560 1561 mad->common.status = cpu_to_be16(status); 1562 1563 dma_wmb(); 1564 rc = h_copy_rdma(olen, vscsi->dds.window[LOCAL].liobn, token, 1565 vscsi->dds.window[REMOTE].liobn, 1566 be64_to_cpu(mad->buffer)); 1567 1568 if (rc != H_SUCCESS) { 1569 pr_debug("cap_mad: failed to copy to client, rc %ld\n", 1570 rc); 1571 1572 if (rc == H_PERMISSION) { 1573 if (connection_broken(vscsi)) 1574 flag_bits = (RESPONSE_Q_DOWN | 1575 CLIENT_FAILED); 1576 } 1577 1578 pr_warn("cap_mad: error copying data to client, rc %ld\n", 1579 rc); 1580 ibmvscsis_post_disconnect(vscsi, 1581 ERR_DISCONNECT_RECONNECT, 1582 flag_bits); 1583 } 1584 } 1585 1586 dma_free_coherent(&vscsi->dma_dev->dev, olen, cap, token); 1587 1588 pr_debug("Leaving cap_mad, rc %ld, client_cap 0x%x\n", 1589 rc, vscsi->client_cap); 1590 1591 return rc; 1592 } 1593 1594 /** 1595 * ibmvscsis_process_mad() - Service a MAnagement Data gram 1596 * @vscsi: Pointer to our adapter structure 1597 * @iue: Information Unit containing the MAD request 1598 * 1599 * Must be called with interrupt lock held. 1600 */ 1601 static long ibmvscsis_process_mad(struct scsi_info *vscsi, struct iu_entry *iue) 1602 { 1603 struct mad_common *mad = (struct mad_common *)&vio_iu(iue)->mad; 1604 struct viosrp_empty_iu *empty; 1605 long rc = ADAPT_SUCCESS; 1606 1607 switch (be32_to_cpu(mad->type)) { 1608 case VIOSRP_EMPTY_IU_TYPE: 1609 empty = &vio_iu(iue)->mad.empty_iu; 1610 vscsi->empty_iu_id = be64_to_cpu(empty->buffer); 1611 vscsi->empty_iu_tag = be64_to_cpu(empty->common.tag); 1612 mad->status = cpu_to_be16(VIOSRP_MAD_SUCCESS); 1613 break; 1614 case VIOSRP_ADAPTER_INFO_TYPE: 1615 rc = ibmvscsis_adapter_info(vscsi, iue); 1616 break; 1617 case VIOSRP_CAPABILITIES_TYPE: 1618 rc = ibmvscsis_cap_mad(vscsi, iue); 1619 break; 1620 case VIOSRP_ENABLE_FAST_FAIL: 1621 if (vscsi->state == CONNECTED) { 1622 vscsi->fast_fail = true; 1623 mad->status = cpu_to_be16(VIOSRP_MAD_SUCCESS); 1624 } else { 1625 pr_warn("fast fail mad sent after login\n"); 1626 mad->status = cpu_to_be16(VIOSRP_MAD_FAILED); 1627 } 1628 break; 1629 default: 1630 mad->status = cpu_to_be16(VIOSRP_MAD_NOT_SUPPORTED); 1631 break; 1632 } 1633 1634 return rc; 1635 } 1636 1637 /** 1638 * srp_snd_msg_failed() - Handle an error when sending a response 1639 * @vscsi: Pointer to our adapter structure 1640 * @rc: The return code from the h_send_crq command 1641 * 1642 * Must be called with interrupt lock held. 1643 */ 1644 static void srp_snd_msg_failed(struct scsi_info *vscsi, long rc) 1645 { 1646 ktime_t kt; 1647 1648 if (rc != H_DROPPED) { 1649 ibmvscsis_free_cmd_qs(vscsi); 1650 1651 if (rc == H_CLOSED) 1652 vscsi->flags |= CLIENT_FAILED; 1653 1654 /* don't flag the same problem multiple times */ 1655 if (!(vscsi->flags & RESPONSE_Q_DOWN)) { 1656 vscsi->flags |= RESPONSE_Q_DOWN; 1657 if (!(vscsi->state & (ERR_DISCONNECT | 1658 ERR_DISCONNECT_RECONNECT | 1659 ERR_DISCONNECTED | UNDEFINED))) { 1660 dev_err(&vscsi->dev, "snd_msg_failed: setting RESPONSE_Q_DOWN, state 0x%hx, flags 0x%x, rc %ld\n", 1661 vscsi->state, vscsi->flags, rc); 1662 } 1663 ibmvscsis_post_disconnect(vscsi, 1664 ERR_DISCONNECT_RECONNECT, 0); 1665 } 1666 return; 1667 } 1668 1669 /* 1670 * The response queue is full. 1671 * If the server is processing SRP requests, i.e. 1672 * the client has successfully done an 1673 * SRP_LOGIN, then it will wait forever for room in 1674 * the queue. However if the system admin 1675 * is attempting to unconfigure the server then one 1676 * or more children will be in a state where 1677 * they are being removed. So if there is even one 1678 * child being removed then the driver assumes 1679 * the system admin is attempting to break the 1680 * connection with the client and MAX_TIMER_POPS 1681 * is honored. 1682 */ 1683 if ((vscsi->rsp_q_timer.timer_pops < MAX_TIMER_POPS) || 1684 (vscsi->state == SRP_PROCESSING)) { 1685 pr_debug("snd_msg_failed: response queue full, flags 0x%x, timer started %d, pops %d\n", 1686 vscsi->flags, (int)vscsi->rsp_q_timer.started, 1687 vscsi->rsp_q_timer.timer_pops); 1688 1689 /* 1690 * Check if the timer is running; if it 1691 * is not then start it up. 1692 */ 1693 if (!vscsi->rsp_q_timer.started) { 1694 if (vscsi->rsp_q_timer.timer_pops < 1695 MAX_TIMER_POPS) { 1696 kt = ktime_set(0, WAIT_NANO_SECONDS); 1697 } else { 1698 /* 1699 * slide the timeslice if the maximum 1700 * timer pops have already happened 1701 */ 1702 kt = ktime_set(WAIT_SECONDS, 0); 1703 } 1704 1705 vscsi->rsp_q_timer.started = true; 1706 hrtimer_start(&vscsi->rsp_q_timer.timer, kt, 1707 HRTIMER_MODE_REL); 1708 } 1709 } else { 1710 /* 1711 * TBD: Do we need to worry about this? Need to get 1712 * remove working. 1713 */ 1714 /* 1715 * waited a long time and it appears the system admin 1716 * is bring this driver down 1717 */ 1718 vscsi->flags |= RESPONSE_Q_DOWN; 1719 ibmvscsis_free_cmd_qs(vscsi); 1720 /* 1721 * if the driver is already attempting to disconnect 1722 * from the client and has already logged an error 1723 * trace this event but don't put it in the error log 1724 */ 1725 if (!(vscsi->state & (ERR_DISCONNECT | 1726 ERR_DISCONNECT_RECONNECT | 1727 ERR_DISCONNECTED | UNDEFINED))) { 1728 dev_err(&vscsi->dev, "client crq full too long\n"); 1729 ibmvscsis_post_disconnect(vscsi, 1730 ERR_DISCONNECT_RECONNECT, 1731 0); 1732 } 1733 } 1734 } 1735 1736 /** 1737 * ibmvscsis_send_messages() - Send a Response 1738 * @vscsi: Pointer to our adapter structure 1739 * 1740 * Send a response, first checking the waiting queue. Responses are 1741 * sent in order they are received. If the response cannot be sent, 1742 * because the client queue is full, it stays on the waiting queue. 1743 * 1744 * PRECONDITION: 1745 * Called with interrupt lock held 1746 */ 1747 static void ibmvscsis_send_messages(struct scsi_info *vscsi) 1748 { 1749 u64 msg_hi = 0; 1750 /* note do not attmempt to access the IU_data_ptr with this pointer 1751 * it is not valid 1752 */ 1753 struct viosrp_crq *crq = (struct viosrp_crq *)&msg_hi; 1754 struct ibmvscsis_cmd *cmd, *nxt; 1755 struct iu_entry *iue; 1756 long rc = ADAPT_SUCCESS; 1757 1758 if (!(vscsi->flags & RESPONSE_Q_DOWN)) { 1759 list_for_each_entry_safe(cmd, nxt, &vscsi->waiting_rsp, list) { 1760 iue = cmd->iue; 1761 1762 crq->valid = VALID_CMD_RESP_EL; 1763 crq->format = cmd->rsp.format; 1764 1765 if (cmd->flags & CMD_FAST_FAIL) 1766 crq->status = VIOSRP_ADAPTER_FAIL; 1767 1768 crq->IU_length = cpu_to_be16(cmd->rsp.len); 1769 1770 rc = h_send_crq(vscsi->dma_dev->unit_address, 1771 be64_to_cpu(msg_hi), 1772 be64_to_cpu(cmd->rsp.tag)); 1773 1774 pr_debug("send_messages: cmd %p, tag 0x%llx, rc %ld\n", 1775 cmd, be64_to_cpu(cmd->rsp.tag), rc); 1776 1777 /* if all ok free up the command element resources */ 1778 if (rc == H_SUCCESS) { 1779 /* some movement has occurred */ 1780 vscsi->rsp_q_timer.timer_pops = 0; 1781 list_del(&cmd->list); 1782 1783 ibmvscsis_free_cmd_resources(vscsi, cmd); 1784 } else { 1785 srp_snd_msg_failed(vscsi, rc); 1786 break; 1787 } 1788 } 1789 1790 if (!rc) { 1791 /* 1792 * The timer could pop with the queue empty. If 1793 * this happens, rc will always indicate a 1794 * success; clear the pop count. 1795 */ 1796 vscsi->rsp_q_timer.timer_pops = 0; 1797 } 1798 } else { 1799 ibmvscsis_free_cmd_qs(vscsi); 1800 } 1801 } 1802 1803 /* Called with intr lock held */ 1804 static void ibmvscsis_send_mad_resp(struct scsi_info *vscsi, 1805 struct ibmvscsis_cmd *cmd, 1806 struct viosrp_crq *crq) 1807 { 1808 struct iu_entry *iue = cmd->iue; 1809 struct mad_common *mad = (struct mad_common *)&vio_iu(iue)->mad; 1810 uint flag_bits = 0; 1811 long rc; 1812 1813 dma_wmb(); 1814 rc = h_copy_rdma(sizeof(struct mad_common), 1815 vscsi->dds.window[LOCAL].liobn, iue->sbuf->dma, 1816 vscsi->dds.window[REMOTE].liobn, 1817 be64_to_cpu(crq->IU_data_ptr)); 1818 if (!rc) { 1819 cmd->rsp.format = VIOSRP_MAD_FORMAT; 1820 cmd->rsp.len = sizeof(struct mad_common); 1821 cmd->rsp.tag = mad->tag; 1822 list_add_tail(&cmd->list, &vscsi->waiting_rsp); 1823 ibmvscsis_send_messages(vscsi); 1824 } else { 1825 pr_debug("Error sending mad response, rc %ld\n", rc); 1826 if (rc == H_PERMISSION) { 1827 if (connection_broken(vscsi)) 1828 flag_bits = (RESPONSE_Q_DOWN | CLIENT_FAILED); 1829 } 1830 dev_err(&vscsi->dev, "mad: failed to copy to client, rc %ld\n", 1831 rc); 1832 1833 ibmvscsis_free_cmd_resources(vscsi, cmd); 1834 ibmvscsis_post_disconnect(vscsi, ERR_DISCONNECT_RECONNECT, 1835 flag_bits); 1836 } 1837 } 1838 1839 /** 1840 * ibmvscsis_mad() - Service a MAnagement Data gram. 1841 * @vscsi: Pointer to our adapter structure 1842 * @crq: Pointer to the CRQ entry containing the MAD request 1843 * 1844 * EXECUTION ENVIRONMENT: 1845 * Interrupt, called with adapter lock held 1846 */ 1847 static long ibmvscsis_mad(struct scsi_info *vscsi, struct viosrp_crq *crq) 1848 { 1849 struct iu_entry *iue; 1850 struct ibmvscsis_cmd *cmd; 1851 struct mad_common *mad; 1852 long rc = ADAPT_SUCCESS; 1853 1854 switch (vscsi->state) { 1855 /* 1856 * We have not exchanged Init Msgs yet, so this MAD was sent 1857 * before the last Transport Event; client will not be 1858 * expecting a response. 1859 */ 1860 case WAIT_CONNECTION: 1861 pr_debug("mad: in Wait Connection state, ignoring MAD, flags %d\n", 1862 vscsi->flags); 1863 return ADAPT_SUCCESS; 1864 1865 case SRP_PROCESSING: 1866 case CONNECTED: 1867 break; 1868 1869 /* 1870 * We should never get here while we're in these states. 1871 * Just log an error and get out. 1872 */ 1873 case UNCONFIGURING: 1874 case WAIT_IDLE: 1875 case ERR_DISCONNECT: 1876 case ERR_DISCONNECT_RECONNECT: 1877 default: 1878 dev_err(&vscsi->dev, "mad: invalid adapter state %d for mad\n", 1879 vscsi->state); 1880 return ADAPT_SUCCESS; 1881 } 1882 1883 cmd = ibmvscsis_get_free_cmd(vscsi); 1884 if (!cmd) { 1885 dev_err(&vscsi->dev, "mad: failed to get cmd, debit %d\n", 1886 vscsi->debit); 1887 ibmvscsis_post_disconnect(vscsi, ERR_DISCONNECT_RECONNECT, 0); 1888 return ERROR; 1889 } 1890 iue = cmd->iue; 1891 cmd->type = ADAPTER_MAD; 1892 1893 rc = ibmvscsis_copy_crq_packet(vscsi, cmd, crq); 1894 if (!rc) { 1895 mad = (struct mad_common *)&vio_iu(iue)->mad; 1896 1897 pr_debug("mad: type %d\n", be32_to_cpu(mad->type)); 1898 1899 rc = ibmvscsis_process_mad(vscsi, iue); 1900 1901 pr_debug("mad: status %hd, rc %ld\n", be16_to_cpu(mad->status), 1902 rc); 1903 1904 if (!rc) 1905 ibmvscsis_send_mad_resp(vscsi, cmd, crq); 1906 } else { 1907 ibmvscsis_free_cmd_resources(vscsi, cmd); 1908 } 1909 1910 pr_debug("Leaving mad, rc %ld\n", rc); 1911 return rc; 1912 } 1913 1914 /** 1915 * ibmvscsis_login_rsp() - Create/copy a login response notice to the client 1916 * @vscsi: Pointer to our adapter structure 1917 * @cmd: Pointer to the command for the SRP Login request 1918 * 1919 * EXECUTION ENVIRONMENT: 1920 * Interrupt, interrupt lock held 1921 */ 1922 static long ibmvscsis_login_rsp(struct scsi_info *vscsi, 1923 struct ibmvscsis_cmd *cmd) 1924 { 1925 struct iu_entry *iue = cmd->iue; 1926 struct srp_login_rsp *rsp = &vio_iu(iue)->srp.login_rsp; 1927 struct format_code *fmt; 1928 uint flag_bits = 0; 1929 long rc = ADAPT_SUCCESS; 1930 1931 memset(rsp, 0, sizeof(struct srp_login_rsp)); 1932 1933 rsp->opcode = SRP_LOGIN_RSP; 1934 rsp->req_lim_delta = cpu_to_be32(vscsi->request_limit); 1935 rsp->tag = cmd->rsp.tag; 1936 rsp->max_it_iu_len = cpu_to_be32(SRP_MAX_IU_LEN); 1937 rsp->max_ti_iu_len = cpu_to_be32(SRP_MAX_IU_LEN); 1938 fmt = (struct format_code *)&rsp->buf_fmt; 1939 fmt->buffers = SUPPORTED_FORMATS; 1940 vscsi->credit = 0; 1941 1942 cmd->rsp.len = sizeof(struct srp_login_rsp); 1943 1944 dma_wmb(); 1945 rc = h_copy_rdma(cmd->rsp.len, vscsi->dds.window[LOCAL].liobn, 1946 iue->sbuf->dma, vscsi->dds.window[REMOTE].liobn, 1947 be64_to_cpu(iue->remote_token)); 1948 1949 switch (rc) { 1950 case H_SUCCESS: 1951 break; 1952 1953 case H_PERMISSION: 1954 if (connection_broken(vscsi)) 1955 flag_bits = RESPONSE_Q_DOWN | CLIENT_FAILED; 1956 dev_err(&vscsi->dev, "login_rsp: error copying to client, rc %ld\n", 1957 rc); 1958 ibmvscsis_post_disconnect(vscsi, ERR_DISCONNECT_RECONNECT, 1959 flag_bits); 1960 break; 1961 case H_SOURCE_PARM: 1962 case H_DEST_PARM: 1963 default: 1964 dev_err(&vscsi->dev, "login_rsp: error copying to client, rc %ld\n", 1965 rc); 1966 ibmvscsis_post_disconnect(vscsi, ERR_DISCONNECT_RECONNECT, 0); 1967 break; 1968 } 1969 1970 return rc; 1971 } 1972 1973 /** 1974 * ibmvscsis_srp_login_rej() - Create/copy a login rejection notice to client 1975 * @vscsi: Pointer to our adapter structure 1976 * @cmd: Pointer to the command for the SRP Login request 1977 * @reason: The reason the SRP Login is being rejected, per SRP protocol 1978 * 1979 * EXECUTION ENVIRONMENT: 1980 * Interrupt, interrupt lock held 1981 */ 1982 static long ibmvscsis_srp_login_rej(struct scsi_info *vscsi, 1983 struct ibmvscsis_cmd *cmd, u32 reason) 1984 { 1985 struct iu_entry *iue = cmd->iue; 1986 struct srp_login_rej *rej = &vio_iu(iue)->srp.login_rej; 1987 struct format_code *fmt; 1988 uint flag_bits = 0; 1989 long rc = ADAPT_SUCCESS; 1990 1991 memset(rej, 0, sizeof(*rej)); 1992 1993 rej->opcode = SRP_LOGIN_REJ; 1994 rej->reason = cpu_to_be32(reason); 1995 rej->tag = cmd->rsp.tag; 1996 fmt = (struct format_code *)&rej->buf_fmt; 1997 fmt->buffers = SUPPORTED_FORMATS; 1998 1999 cmd->rsp.len = sizeof(*rej); 2000 2001 dma_wmb(); 2002 rc = h_copy_rdma(cmd->rsp.len, vscsi->dds.window[LOCAL].liobn, 2003 iue->sbuf->dma, vscsi->dds.window[REMOTE].liobn, 2004 be64_to_cpu(iue->remote_token)); 2005 2006 switch (rc) { 2007 case H_SUCCESS: 2008 break; 2009 case H_PERMISSION: 2010 if (connection_broken(vscsi)) 2011 flag_bits = RESPONSE_Q_DOWN | CLIENT_FAILED; 2012 dev_err(&vscsi->dev, "login_rej: error copying to client, rc %ld\n", 2013 rc); 2014 ibmvscsis_post_disconnect(vscsi, ERR_DISCONNECT_RECONNECT, 2015 flag_bits); 2016 break; 2017 case H_SOURCE_PARM: 2018 case H_DEST_PARM: 2019 default: 2020 dev_err(&vscsi->dev, "login_rej: error copying to client, rc %ld\n", 2021 rc); 2022 ibmvscsis_post_disconnect(vscsi, ERR_DISCONNECT_RECONNECT, 0); 2023 break; 2024 } 2025 2026 return rc; 2027 } 2028 2029 static int ibmvscsis_make_nexus(struct ibmvscsis_tport *tport) 2030 { 2031 char *name = tport->tport_name; 2032 struct ibmvscsis_nexus *nexus; 2033 int rc; 2034 2035 if (tport->ibmv_nexus) { 2036 pr_debug("tport->ibmv_nexus already exists\n"); 2037 return 0; 2038 } 2039 2040 nexus = kzalloc(sizeof(*nexus), GFP_KERNEL); 2041 if (!nexus) { 2042 pr_err("Unable to allocate struct ibmvscsis_nexus\n"); 2043 return -ENOMEM; 2044 } 2045 2046 nexus->se_sess = target_alloc_session(&tport->se_tpg, 0, 0, 2047 TARGET_PROT_NORMAL, name, nexus, 2048 NULL); 2049 if (IS_ERR(nexus->se_sess)) { 2050 rc = PTR_ERR(nexus->se_sess); 2051 goto transport_init_fail; 2052 } 2053 2054 tport->ibmv_nexus = nexus; 2055 2056 return 0; 2057 2058 transport_init_fail: 2059 kfree(nexus); 2060 return rc; 2061 } 2062 2063 static int ibmvscsis_drop_nexus(struct ibmvscsis_tport *tport) 2064 { 2065 struct se_session *se_sess; 2066 struct ibmvscsis_nexus *nexus; 2067 2068 nexus = tport->ibmv_nexus; 2069 if (!nexus) 2070 return -ENODEV; 2071 2072 se_sess = nexus->se_sess; 2073 if (!se_sess) 2074 return -ENODEV; 2075 2076 /* 2077 * Release the SCSI I_T Nexus to the emulated ibmvscsis Target Port 2078 */ 2079 target_wait_for_sess_cmds(se_sess); 2080 transport_deregister_session_configfs(se_sess); 2081 transport_deregister_session(se_sess); 2082 tport->ibmv_nexus = NULL; 2083 kfree(nexus); 2084 2085 return 0; 2086 } 2087 2088 /** 2089 * ibmvscsis_srp_login() - Process an SRP Login Request 2090 * @vscsi: Pointer to our adapter structure 2091 * @cmd: Command element to use to process the SRP Login request 2092 * @crq: Pointer to CRQ entry containing the SRP Login request 2093 * 2094 * EXECUTION ENVIRONMENT: 2095 * Interrupt, called with interrupt lock held 2096 */ 2097 static long ibmvscsis_srp_login(struct scsi_info *vscsi, 2098 struct ibmvscsis_cmd *cmd, 2099 struct viosrp_crq *crq) 2100 { 2101 struct iu_entry *iue = cmd->iue; 2102 struct srp_login_req *req = &vio_iu(iue)->srp.login_req; 2103 struct port_id { 2104 __be64 id_extension; 2105 __be64 io_guid; 2106 } *iport, *tport; 2107 struct format_code *fmt; 2108 u32 reason = 0x0; 2109 long rc = ADAPT_SUCCESS; 2110 2111 iport = (struct port_id *)req->initiator_port_id; 2112 tport = (struct port_id *)req->target_port_id; 2113 fmt = (struct format_code *)&req->req_buf_fmt; 2114 if (be32_to_cpu(req->req_it_iu_len) > SRP_MAX_IU_LEN) 2115 reason = SRP_LOGIN_REJ_REQ_IT_IU_LENGTH_TOO_LARGE; 2116 else if (be32_to_cpu(req->req_it_iu_len) < 64) 2117 reason = SRP_LOGIN_REJ_UNABLE_ESTABLISH_CHANNEL; 2118 else if ((be64_to_cpu(iport->id_extension) > (MAX_NUM_PORTS - 1)) || 2119 (be64_to_cpu(tport->id_extension) > (MAX_NUM_PORTS - 1))) 2120 reason = SRP_LOGIN_REJ_UNABLE_ASSOCIATE_CHANNEL; 2121 else if (req->req_flags & SRP_MULTICHAN_MULTI) 2122 reason = SRP_LOGIN_REJ_MULTI_CHANNEL_UNSUPPORTED; 2123 else if (fmt->buffers & (~SUPPORTED_FORMATS)) 2124 reason = SRP_LOGIN_REJ_UNSUPPORTED_DESCRIPTOR_FMT; 2125 else if ((fmt->buffers & SUPPORTED_FORMATS) == 0) 2126 reason = SRP_LOGIN_REJ_UNSUPPORTED_DESCRIPTOR_FMT; 2127 2128 if (vscsi->state == SRP_PROCESSING) 2129 reason = SRP_LOGIN_REJ_CHANNEL_LIMIT_REACHED; 2130 2131 rc = ibmvscsis_make_nexus(&vscsi->tport); 2132 if (rc) 2133 reason = SRP_LOGIN_REJ_UNABLE_ESTABLISH_CHANNEL; 2134 2135 cmd->rsp.format = VIOSRP_SRP_FORMAT; 2136 cmd->rsp.tag = req->tag; 2137 2138 pr_debug("srp_login: reason 0x%x\n", reason); 2139 2140 if (reason) 2141 rc = ibmvscsis_srp_login_rej(vscsi, cmd, reason); 2142 else 2143 rc = ibmvscsis_login_rsp(vscsi, cmd); 2144 2145 if (!rc) { 2146 if (!reason) 2147 vscsi->state = SRP_PROCESSING; 2148 2149 list_add_tail(&cmd->list, &vscsi->waiting_rsp); 2150 ibmvscsis_send_messages(vscsi); 2151 } else { 2152 ibmvscsis_free_cmd_resources(vscsi, cmd); 2153 } 2154 2155 pr_debug("Leaving srp_login, rc %ld\n", rc); 2156 return rc; 2157 } 2158 2159 /** 2160 * ibmvscsis_srp_i_logout() - Helper Function to close I_T Nexus 2161 * @vscsi: Pointer to our adapter structure 2162 * @cmd: Command element to use to process the Implicit Logout request 2163 * @crq: Pointer to CRQ entry containing the Implicit Logout request 2164 * 2165 * Do the logic to close the I_T nexus. This function may not 2166 * behave to specification. 2167 * 2168 * EXECUTION ENVIRONMENT: 2169 * Interrupt, interrupt lock held 2170 */ 2171 static long ibmvscsis_srp_i_logout(struct scsi_info *vscsi, 2172 struct ibmvscsis_cmd *cmd, 2173 struct viosrp_crq *crq) 2174 { 2175 struct iu_entry *iue = cmd->iue; 2176 struct srp_i_logout *log_out = &vio_iu(iue)->srp.i_logout; 2177 long rc = ADAPT_SUCCESS; 2178 2179 if ((vscsi->debit > 0) || !list_empty(&vscsi->schedule_q) || 2180 !list_empty(&vscsi->waiting_rsp)) { 2181 dev_err(&vscsi->dev, "i_logout: outstanding work\n"); 2182 ibmvscsis_post_disconnect(vscsi, ERR_DISCONNECT, 0); 2183 } else { 2184 cmd->rsp.format = SRP_FORMAT; 2185 cmd->rsp.tag = log_out->tag; 2186 cmd->rsp.len = sizeof(struct mad_common); 2187 list_add_tail(&cmd->list, &vscsi->waiting_rsp); 2188 ibmvscsis_send_messages(vscsi); 2189 2190 ibmvscsis_post_disconnect(vscsi, WAIT_IDLE, 0); 2191 } 2192 2193 return rc; 2194 } 2195 2196 /* Called with intr lock held */ 2197 static void ibmvscsis_srp_cmd(struct scsi_info *vscsi, struct viosrp_crq *crq) 2198 { 2199 struct ibmvscsis_cmd *cmd; 2200 struct iu_entry *iue; 2201 struct srp_cmd *srp; 2202 struct srp_tsk_mgmt *tsk; 2203 long rc; 2204 2205 if (vscsi->request_limit - vscsi->debit <= 0) { 2206 /* Client has exceeded request limit */ 2207 dev_err(&vscsi->dev, "Client exceeded the request limit (%d), debit %d\n", 2208 vscsi->request_limit, vscsi->debit); 2209 ibmvscsis_post_disconnect(vscsi, ERR_DISCONNECT_RECONNECT, 0); 2210 return; 2211 } 2212 2213 cmd = ibmvscsis_get_free_cmd(vscsi); 2214 if (!cmd) { 2215 dev_err(&vscsi->dev, "srp_cmd failed to get cmd, debit %d\n", 2216 vscsi->debit); 2217 ibmvscsis_post_disconnect(vscsi, ERR_DISCONNECT_RECONNECT, 0); 2218 return; 2219 } 2220 iue = cmd->iue; 2221 srp = &vio_iu(iue)->srp.cmd; 2222 2223 rc = ibmvscsis_copy_crq_packet(vscsi, cmd, crq); 2224 if (rc) { 2225 ibmvscsis_free_cmd_resources(vscsi, cmd); 2226 return; 2227 } 2228 2229 if (vscsi->state == SRP_PROCESSING) { 2230 switch (srp->opcode) { 2231 case SRP_LOGIN_REQ: 2232 rc = ibmvscsis_srp_login(vscsi, cmd, crq); 2233 break; 2234 2235 case SRP_TSK_MGMT: 2236 tsk = &vio_iu(iue)->srp.tsk_mgmt; 2237 pr_debug("tsk_mgmt tag: %llu (0x%llx)\n", tsk->tag, 2238 tsk->tag); 2239 cmd->rsp.tag = tsk->tag; 2240 vscsi->debit += 1; 2241 cmd->type = TASK_MANAGEMENT; 2242 list_add_tail(&cmd->list, &vscsi->schedule_q); 2243 queue_work(vscsi->work_q, &cmd->work); 2244 break; 2245 2246 case SRP_CMD: 2247 pr_debug("srp_cmd tag: %llu (0x%llx)\n", srp->tag, 2248 srp->tag); 2249 cmd->rsp.tag = srp->tag; 2250 vscsi->debit += 1; 2251 cmd->type = SCSI_CDB; 2252 /* 2253 * We want to keep track of work waiting for 2254 * the workqueue. 2255 */ 2256 list_add_tail(&cmd->list, &vscsi->schedule_q); 2257 queue_work(vscsi->work_q, &cmd->work); 2258 break; 2259 2260 case SRP_I_LOGOUT: 2261 rc = ibmvscsis_srp_i_logout(vscsi, cmd, crq); 2262 break; 2263 2264 case SRP_CRED_RSP: 2265 case SRP_AER_RSP: 2266 default: 2267 ibmvscsis_free_cmd_resources(vscsi, cmd); 2268 dev_err(&vscsi->dev, "invalid srp cmd, opcode %d\n", 2269 (uint)srp->opcode); 2270 ibmvscsis_post_disconnect(vscsi, 2271 ERR_DISCONNECT_RECONNECT, 0); 2272 break; 2273 } 2274 } else if (srp->opcode == SRP_LOGIN_REQ && vscsi->state == CONNECTED) { 2275 rc = ibmvscsis_srp_login(vscsi, cmd, crq); 2276 } else { 2277 ibmvscsis_free_cmd_resources(vscsi, cmd); 2278 dev_err(&vscsi->dev, "Invalid state %d to handle srp cmd\n", 2279 vscsi->state); 2280 ibmvscsis_post_disconnect(vscsi, ERR_DISCONNECT_RECONNECT, 0); 2281 } 2282 } 2283 2284 /** 2285 * ibmvscsis_ping_response() - Respond to a ping request 2286 * @vscsi: Pointer to our adapter structure 2287 * 2288 * Let the client know that the server is alive and waiting on 2289 * its native I/O stack. 2290 * If any type of error occurs from the call to queue a ping 2291 * response then the client is either not accepting or receiving 2292 * interrupts. Disconnect with an error. 2293 * 2294 * EXECUTION ENVIRONMENT: 2295 * Interrupt, interrupt lock held 2296 */ 2297 static long ibmvscsis_ping_response(struct scsi_info *vscsi) 2298 { 2299 struct viosrp_crq *crq; 2300 u64 buffer[2] = { 0, 0 }; 2301 long rc; 2302 2303 crq = (struct viosrp_crq *)&buffer; 2304 crq->valid = VALID_CMD_RESP_EL; 2305 crq->format = (u8)MESSAGE_IN_CRQ; 2306 crq->status = PING_RESPONSE; 2307 2308 rc = h_send_crq(vscsi->dds.unit_id, cpu_to_be64(buffer[MSG_HI]), 2309 cpu_to_be64(buffer[MSG_LOW])); 2310 2311 switch (rc) { 2312 case H_SUCCESS: 2313 break; 2314 case H_CLOSED: 2315 vscsi->flags |= CLIENT_FAILED; 2316 case H_DROPPED: 2317 vscsi->flags |= RESPONSE_Q_DOWN; 2318 case H_REMOTE_PARM: 2319 dev_err(&vscsi->dev, "ping_response: h_send_crq failed, rc %ld\n", 2320 rc); 2321 ibmvscsis_post_disconnect(vscsi, ERR_DISCONNECT_RECONNECT, 0); 2322 break; 2323 default: 2324 dev_err(&vscsi->dev, "ping_response: h_send_crq returned unknown rc %ld\n", 2325 rc); 2326 ibmvscsis_post_disconnect(vscsi, ERR_DISCONNECT, 0); 2327 break; 2328 } 2329 2330 return rc; 2331 } 2332 2333 /** 2334 * ibmvscsis_parse_command() - Parse an element taken from the cmd rsp queue. 2335 * @vscsi: Pointer to our adapter structure 2336 * @crq: Pointer to CRQ element containing the SRP request 2337 * 2338 * This function will return success if the command queue element is valid 2339 * and the srp iu or MAD request it pointed to was also valid. That does 2340 * not mean that an error was not returned to the client. 2341 * 2342 * EXECUTION ENVIRONMENT: 2343 * Interrupt, intr lock held 2344 */ 2345 static long ibmvscsis_parse_command(struct scsi_info *vscsi, 2346 struct viosrp_crq *crq) 2347 { 2348 long rc = ADAPT_SUCCESS; 2349 2350 switch (crq->valid) { 2351 case VALID_CMD_RESP_EL: 2352 switch (crq->format) { 2353 case OS400_FORMAT: 2354 case AIX_FORMAT: 2355 case LINUX_FORMAT: 2356 case MAD_FORMAT: 2357 if (vscsi->flags & PROCESSING_MAD) { 2358 rc = ERROR; 2359 dev_err(&vscsi->dev, "parse_command: already processing mad\n"); 2360 ibmvscsis_post_disconnect(vscsi, 2361 ERR_DISCONNECT_RECONNECT, 2362 0); 2363 } else { 2364 vscsi->flags |= PROCESSING_MAD; 2365 rc = ibmvscsis_mad(vscsi, crq); 2366 } 2367 break; 2368 2369 case SRP_FORMAT: 2370 ibmvscsis_srp_cmd(vscsi, crq); 2371 break; 2372 2373 case MESSAGE_IN_CRQ: 2374 if (crq->status == PING) 2375 ibmvscsis_ping_response(vscsi); 2376 break; 2377 2378 default: 2379 dev_err(&vscsi->dev, "parse_command: invalid format %d\n", 2380 (uint)crq->format); 2381 ibmvscsis_post_disconnect(vscsi, 2382 ERR_DISCONNECT_RECONNECT, 0); 2383 break; 2384 } 2385 break; 2386 2387 case VALID_TRANS_EVENT: 2388 rc = ibmvscsis_trans_event(vscsi, crq); 2389 break; 2390 2391 case VALID_INIT_MSG: 2392 rc = ibmvscsis_init_msg(vscsi, crq); 2393 break; 2394 2395 default: 2396 dev_err(&vscsi->dev, "parse_command: invalid valid field %d\n", 2397 (uint)crq->valid); 2398 ibmvscsis_post_disconnect(vscsi, ERR_DISCONNECT_RECONNECT, 0); 2399 break; 2400 } 2401 2402 /* 2403 * Return only what the interrupt handler cares 2404 * about. Most errors we keep right on trucking. 2405 */ 2406 rc = vscsi->flags & SCHEDULE_DISCONNECT; 2407 2408 return rc; 2409 } 2410 2411 static int read_dma_window(struct scsi_info *vscsi) 2412 { 2413 struct vio_dev *vdev = vscsi->dma_dev; 2414 const __be32 *dma_window; 2415 const __be32 *prop; 2416 2417 /* TODO Using of_parse_dma_window would be better, but it doesn't give 2418 * a way to read multiple windows without already knowing the size of 2419 * a window or the number of windows. 2420 */ 2421 dma_window = (const __be32 *)vio_get_attribute(vdev, 2422 "ibm,my-dma-window", 2423 NULL); 2424 if (!dma_window) { 2425 pr_err("Couldn't find ibm,my-dma-window property\n"); 2426 return -1; 2427 } 2428 2429 vscsi->dds.window[LOCAL].liobn = be32_to_cpu(*dma_window); 2430 dma_window++; 2431 2432 prop = (const __be32 *)vio_get_attribute(vdev, "ibm,#dma-address-cells", 2433 NULL); 2434 if (!prop) { 2435 pr_warn("Couldn't find ibm,#dma-address-cells property\n"); 2436 dma_window++; 2437 } else { 2438 dma_window += be32_to_cpu(*prop); 2439 } 2440 2441 prop = (const __be32 *)vio_get_attribute(vdev, "ibm,#dma-size-cells", 2442 NULL); 2443 if (!prop) { 2444 pr_warn("Couldn't find ibm,#dma-size-cells property\n"); 2445 dma_window++; 2446 } else { 2447 dma_window += be32_to_cpu(*prop); 2448 } 2449 2450 /* dma_window should point to the second window now */ 2451 vscsi->dds.window[REMOTE].liobn = be32_to_cpu(*dma_window); 2452 2453 return 0; 2454 } 2455 2456 static struct ibmvscsis_tport *ibmvscsis_lookup_port(const char *name) 2457 { 2458 struct ibmvscsis_tport *tport = NULL; 2459 struct vio_dev *vdev; 2460 struct scsi_info *vscsi; 2461 2462 spin_lock_bh(&ibmvscsis_dev_lock); 2463 list_for_each_entry(vscsi, &ibmvscsis_dev_list, list) { 2464 vdev = vscsi->dma_dev; 2465 if (!strcmp(dev_name(&vdev->dev), name)) { 2466 tport = &vscsi->tport; 2467 break; 2468 } 2469 } 2470 spin_unlock_bh(&ibmvscsis_dev_lock); 2471 2472 return tport; 2473 } 2474 2475 /** 2476 * ibmvscsis_parse_cmd() - Parse SRP Command 2477 * @vscsi: Pointer to our adapter structure 2478 * @cmd: Pointer to command element with SRP command 2479 * 2480 * Parse the srp command; if it is valid then submit it to tcm. 2481 * Note: The return code does not reflect the status of the SCSI CDB. 2482 * 2483 * EXECUTION ENVIRONMENT: 2484 * Process level 2485 */ 2486 static void ibmvscsis_parse_cmd(struct scsi_info *vscsi, 2487 struct ibmvscsis_cmd *cmd) 2488 { 2489 struct iu_entry *iue = cmd->iue; 2490 struct srp_cmd *srp = (struct srp_cmd *)iue->sbuf->buf; 2491 struct ibmvscsis_nexus *nexus; 2492 u64 data_len = 0; 2493 enum dma_data_direction dir; 2494 int attr = 0; 2495 int rc = 0; 2496 2497 nexus = vscsi->tport.ibmv_nexus; 2498 /* 2499 * additional length in bytes. Note that the SRP spec says that 2500 * additional length is in 4-byte words, but technically the 2501 * additional length field is only the upper 6 bits of the byte. 2502 * The lower 2 bits are reserved. If the lower 2 bits are 0 (as 2503 * all reserved fields should be), then interpreting the byte as 2504 * an int will yield the length in bytes. 2505 */ 2506 if (srp->add_cdb_len & 0x03) { 2507 dev_err(&vscsi->dev, "parse_cmd: reserved bits set in IU\n"); 2508 spin_lock_bh(&vscsi->intr_lock); 2509 ibmvscsis_post_disconnect(vscsi, ERR_DISCONNECT_RECONNECT, 0); 2510 ibmvscsis_free_cmd_resources(vscsi, cmd); 2511 spin_unlock_bh(&vscsi->intr_lock); 2512 return; 2513 } 2514 2515 if (srp_get_desc_table(srp, &dir, &data_len)) { 2516 dev_err(&vscsi->dev, "0x%llx: parsing SRP descriptor table failed.\n", 2517 srp->tag); 2518 goto fail; 2519 } 2520 2521 cmd->rsp.sol_not = srp->sol_not; 2522 2523 switch (srp->task_attr) { 2524 case SRP_SIMPLE_TASK: 2525 attr = TCM_SIMPLE_TAG; 2526 break; 2527 case SRP_ORDERED_TASK: 2528 attr = TCM_ORDERED_TAG; 2529 break; 2530 case SRP_HEAD_TASK: 2531 attr = TCM_HEAD_TAG; 2532 break; 2533 case SRP_ACA_TASK: 2534 attr = TCM_ACA_TAG; 2535 break; 2536 default: 2537 dev_err(&vscsi->dev, "Invalid task attribute %d\n", 2538 srp->task_attr); 2539 goto fail; 2540 } 2541 2542 cmd->se_cmd.tag = be64_to_cpu(srp->tag); 2543 2544 spin_lock_bh(&vscsi->intr_lock); 2545 list_add_tail(&cmd->list, &vscsi->active_q); 2546 spin_unlock_bh(&vscsi->intr_lock); 2547 2548 srp->lun.scsi_lun[0] &= 0x3f; 2549 2550 rc = target_submit_cmd(&cmd->se_cmd, nexus->se_sess, srp->cdb, 2551 cmd->sense_buf, scsilun_to_int(&srp->lun), 2552 data_len, attr, dir, 0); 2553 if (rc) { 2554 dev_err(&vscsi->dev, "target_submit_cmd failed, rc %d\n", rc); 2555 spin_lock_bh(&vscsi->intr_lock); 2556 list_del(&cmd->list); 2557 ibmvscsis_free_cmd_resources(vscsi, cmd); 2558 spin_unlock_bh(&vscsi->intr_lock); 2559 goto fail; 2560 } 2561 return; 2562 2563 fail: 2564 spin_lock_bh(&vscsi->intr_lock); 2565 ibmvscsis_post_disconnect(vscsi, ERR_DISCONNECT_RECONNECT, 0); 2566 spin_unlock_bh(&vscsi->intr_lock); 2567 } 2568 2569 /** 2570 * ibmvscsis_parse_task() - Parse SRP Task Management Request 2571 * @vscsi: Pointer to our adapter structure 2572 * @cmd: Pointer to command element with SRP task management request 2573 * 2574 * Parse the srp task management request; if it is valid then submit it to tcm. 2575 * Note: The return code does not reflect the status of the task management 2576 * request. 2577 * 2578 * EXECUTION ENVIRONMENT: 2579 * Processor level 2580 */ 2581 static void ibmvscsis_parse_task(struct scsi_info *vscsi, 2582 struct ibmvscsis_cmd *cmd) 2583 { 2584 struct iu_entry *iue = cmd->iue; 2585 struct srp_tsk_mgmt *srp_tsk = &vio_iu(iue)->srp.tsk_mgmt; 2586 int tcm_type; 2587 u64 tag_to_abort = 0; 2588 int rc = 0; 2589 struct ibmvscsis_nexus *nexus; 2590 2591 nexus = vscsi->tport.ibmv_nexus; 2592 2593 cmd->rsp.sol_not = srp_tsk->sol_not; 2594 2595 switch (srp_tsk->tsk_mgmt_func) { 2596 case SRP_TSK_ABORT_TASK: 2597 tcm_type = TMR_ABORT_TASK; 2598 tag_to_abort = be64_to_cpu(srp_tsk->task_tag); 2599 break; 2600 case SRP_TSK_ABORT_TASK_SET: 2601 tcm_type = TMR_ABORT_TASK_SET; 2602 break; 2603 case SRP_TSK_CLEAR_TASK_SET: 2604 tcm_type = TMR_CLEAR_TASK_SET; 2605 break; 2606 case SRP_TSK_LUN_RESET: 2607 tcm_type = TMR_LUN_RESET; 2608 break; 2609 case SRP_TSK_CLEAR_ACA: 2610 tcm_type = TMR_CLEAR_ACA; 2611 break; 2612 default: 2613 dev_err(&vscsi->dev, "unknown task mgmt func %d\n", 2614 srp_tsk->tsk_mgmt_func); 2615 cmd->se_cmd.se_tmr_req->response = 2616 TMR_TASK_MGMT_FUNCTION_NOT_SUPPORTED; 2617 rc = -1; 2618 break; 2619 } 2620 2621 if (!rc) { 2622 cmd->se_cmd.tag = be64_to_cpu(srp_tsk->tag); 2623 2624 spin_lock_bh(&vscsi->intr_lock); 2625 list_add_tail(&cmd->list, &vscsi->active_q); 2626 spin_unlock_bh(&vscsi->intr_lock); 2627 2628 srp_tsk->lun.scsi_lun[0] &= 0x3f; 2629 2630 pr_debug("calling submit_tmr, func %d\n", 2631 srp_tsk->tsk_mgmt_func); 2632 rc = target_submit_tmr(&cmd->se_cmd, nexus->se_sess, NULL, 2633 scsilun_to_int(&srp_tsk->lun), srp_tsk, 2634 tcm_type, GFP_KERNEL, tag_to_abort, 0); 2635 if (rc) { 2636 dev_err(&vscsi->dev, "target_submit_tmr failed, rc %d\n", 2637 rc); 2638 spin_lock_bh(&vscsi->intr_lock); 2639 list_del(&cmd->list); 2640 spin_unlock_bh(&vscsi->intr_lock); 2641 cmd->se_cmd.se_tmr_req->response = 2642 TMR_FUNCTION_REJECTED; 2643 } 2644 } 2645 2646 if (rc) 2647 transport_send_check_condition_and_sense(&cmd->se_cmd, 0, 0); 2648 } 2649 2650 static void ibmvscsis_scheduler(struct work_struct *work) 2651 { 2652 struct ibmvscsis_cmd *cmd = container_of(work, struct ibmvscsis_cmd, 2653 work); 2654 struct scsi_info *vscsi = cmd->adapter; 2655 2656 spin_lock_bh(&vscsi->intr_lock); 2657 2658 /* Remove from schedule_q */ 2659 list_del(&cmd->list); 2660 2661 /* Don't submit cmd if we're disconnecting */ 2662 if (vscsi->flags & (SCHEDULE_DISCONNECT | DISCONNECT_SCHEDULED)) { 2663 ibmvscsis_free_cmd_resources(vscsi, cmd); 2664 2665 /* ibmvscsis_disconnect might be waiting for us */ 2666 if (list_empty(&vscsi->active_q) && 2667 list_empty(&vscsi->schedule_q) && 2668 (vscsi->flags & WAIT_FOR_IDLE)) { 2669 vscsi->flags &= ~WAIT_FOR_IDLE; 2670 complete(&vscsi->wait_idle); 2671 } 2672 2673 spin_unlock_bh(&vscsi->intr_lock); 2674 return; 2675 } 2676 2677 spin_unlock_bh(&vscsi->intr_lock); 2678 2679 switch (cmd->type) { 2680 case SCSI_CDB: 2681 ibmvscsis_parse_cmd(vscsi, cmd); 2682 break; 2683 case TASK_MANAGEMENT: 2684 ibmvscsis_parse_task(vscsi, cmd); 2685 break; 2686 default: 2687 dev_err(&vscsi->dev, "scheduler, invalid cmd type %d\n", 2688 cmd->type); 2689 spin_lock_bh(&vscsi->intr_lock); 2690 ibmvscsis_free_cmd_resources(vscsi, cmd); 2691 spin_unlock_bh(&vscsi->intr_lock); 2692 break; 2693 } 2694 } 2695 2696 static int ibmvscsis_alloc_cmds(struct scsi_info *vscsi, int num) 2697 { 2698 struct ibmvscsis_cmd *cmd; 2699 int i; 2700 2701 INIT_LIST_HEAD(&vscsi->free_cmd); 2702 vscsi->cmd_pool = kcalloc(num, sizeof(struct ibmvscsis_cmd), 2703 GFP_KERNEL); 2704 if (!vscsi->cmd_pool) 2705 return -ENOMEM; 2706 2707 for (i = 0, cmd = (struct ibmvscsis_cmd *)vscsi->cmd_pool; i < num; 2708 i++, cmd++) { 2709 cmd->adapter = vscsi; 2710 INIT_WORK(&cmd->work, ibmvscsis_scheduler); 2711 list_add_tail(&cmd->list, &vscsi->free_cmd); 2712 } 2713 2714 return 0; 2715 } 2716 2717 static void ibmvscsis_free_cmds(struct scsi_info *vscsi) 2718 { 2719 kfree(vscsi->cmd_pool); 2720 vscsi->cmd_pool = NULL; 2721 INIT_LIST_HEAD(&vscsi->free_cmd); 2722 } 2723 2724 /** 2725 * ibmvscsis_service_wait_q() - Service Waiting Queue 2726 * @timer: Pointer to timer which has expired 2727 * 2728 * This routine is called when the timer pops to service the waiting 2729 * queue. Elements on the queue have completed, their responses have been 2730 * copied to the client, but the client's response queue was full so 2731 * the queue message could not be sent. The routine grabs the proper locks 2732 * and calls send messages. 2733 * 2734 * EXECUTION ENVIRONMENT: 2735 * called at interrupt level 2736 */ 2737 static enum hrtimer_restart ibmvscsis_service_wait_q(struct hrtimer *timer) 2738 { 2739 struct timer_cb *p_timer = container_of(timer, struct timer_cb, timer); 2740 struct scsi_info *vscsi = container_of(p_timer, struct scsi_info, 2741 rsp_q_timer); 2742 2743 spin_lock_bh(&vscsi->intr_lock); 2744 p_timer->timer_pops += 1; 2745 p_timer->started = false; 2746 ibmvscsis_send_messages(vscsi); 2747 spin_unlock_bh(&vscsi->intr_lock); 2748 2749 return HRTIMER_NORESTART; 2750 } 2751 2752 static long ibmvscsis_alloctimer(struct scsi_info *vscsi) 2753 { 2754 struct timer_cb *p_timer; 2755 2756 p_timer = &vscsi->rsp_q_timer; 2757 hrtimer_init(&p_timer->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); 2758 2759 p_timer->timer.function = ibmvscsis_service_wait_q; 2760 p_timer->started = false; 2761 p_timer->timer_pops = 0; 2762 2763 return ADAPT_SUCCESS; 2764 } 2765 2766 static void ibmvscsis_freetimer(struct scsi_info *vscsi) 2767 { 2768 struct timer_cb *p_timer; 2769 2770 p_timer = &vscsi->rsp_q_timer; 2771 2772 (void)hrtimer_cancel(&p_timer->timer); 2773 2774 p_timer->started = false; 2775 p_timer->timer_pops = 0; 2776 } 2777 2778 static irqreturn_t ibmvscsis_interrupt(int dummy, void *data) 2779 { 2780 struct scsi_info *vscsi = data; 2781 2782 vio_disable_interrupts(vscsi->dma_dev); 2783 tasklet_schedule(&vscsi->work_task); 2784 2785 return IRQ_HANDLED; 2786 } 2787 2788 /** 2789 * ibmvscsis_enable_change_state() - Set new state based on enabled status 2790 * @vscsi: Pointer to our adapter structure 2791 * 2792 * This function determines our new state now that we are enabled. This 2793 * may involve sending an Init Complete message to the client. 2794 * 2795 * Must be called with interrupt lock held. 2796 */ 2797 static long ibmvscsis_enable_change_state(struct scsi_info *vscsi) 2798 { 2799 int bytes; 2800 long rc = ADAPT_SUCCESS; 2801 2802 bytes = vscsi->cmd_q.size * PAGE_SIZE; 2803 rc = h_reg_crq(vscsi->dds.unit_id, vscsi->cmd_q.crq_token, bytes); 2804 if (rc == H_CLOSED || rc == H_SUCCESS) { 2805 vscsi->state = WAIT_CONNECTION; 2806 rc = ibmvscsis_establish_new_q(vscsi); 2807 } 2808 2809 if (rc != ADAPT_SUCCESS) { 2810 vscsi->state = ERR_DISCONNECTED; 2811 vscsi->flags |= RESPONSE_Q_DOWN; 2812 } 2813 2814 return rc; 2815 } 2816 2817 /** 2818 * ibmvscsis_create_command_q() - Create Command Queue 2819 * @vscsi: Pointer to our adapter structure 2820 * @num_cmds: Currently unused. In the future, may be used to determine 2821 * the size of the CRQ. 2822 * 2823 * Allocates memory for command queue maps remote memory into an ioba 2824 * initializes the command response queue 2825 * 2826 * EXECUTION ENVIRONMENT: 2827 * Process level only 2828 */ 2829 static long ibmvscsis_create_command_q(struct scsi_info *vscsi, int num_cmds) 2830 { 2831 int pages; 2832 struct vio_dev *vdev = vscsi->dma_dev; 2833 2834 /* We might support multiple pages in the future, but just 1 for now */ 2835 pages = 1; 2836 2837 vscsi->cmd_q.size = pages; 2838 2839 vscsi->cmd_q.base_addr = 2840 (struct viosrp_crq *)get_zeroed_page(GFP_KERNEL); 2841 if (!vscsi->cmd_q.base_addr) 2842 return -ENOMEM; 2843 2844 vscsi->cmd_q.mask = ((uint)pages * CRQ_PER_PAGE) - 1; 2845 2846 vscsi->cmd_q.crq_token = dma_map_single(&vdev->dev, 2847 vscsi->cmd_q.base_addr, 2848 PAGE_SIZE, DMA_BIDIRECTIONAL); 2849 if (dma_mapping_error(&vdev->dev, vscsi->cmd_q.crq_token)) { 2850 free_page((unsigned long)vscsi->cmd_q.base_addr); 2851 return -ENOMEM; 2852 } 2853 2854 return 0; 2855 } 2856 2857 /** 2858 * ibmvscsis_destroy_command_q - Destroy Command Queue 2859 * @vscsi: Pointer to our adapter structure 2860 * 2861 * Releases memory for command queue and unmaps mapped remote memory. 2862 * 2863 * EXECUTION ENVIRONMENT: 2864 * Process level only 2865 */ 2866 static void ibmvscsis_destroy_command_q(struct scsi_info *vscsi) 2867 { 2868 dma_unmap_single(&vscsi->dma_dev->dev, vscsi->cmd_q.crq_token, 2869 PAGE_SIZE, DMA_BIDIRECTIONAL); 2870 free_page((unsigned long)vscsi->cmd_q.base_addr); 2871 vscsi->cmd_q.base_addr = NULL; 2872 vscsi->state = NO_QUEUE; 2873 } 2874 2875 static u8 ibmvscsis_fast_fail(struct scsi_info *vscsi, 2876 struct ibmvscsis_cmd *cmd) 2877 { 2878 struct iu_entry *iue = cmd->iue; 2879 struct se_cmd *se_cmd = &cmd->se_cmd; 2880 struct srp_cmd *srp = (struct srp_cmd *)iue->sbuf->buf; 2881 struct scsi_sense_hdr sshdr; 2882 u8 rc = se_cmd->scsi_status; 2883 2884 if (vscsi->fast_fail && (READ_CMD(srp->cdb) || WRITE_CMD(srp->cdb))) 2885 if (scsi_normalize_sense(se_cmd->sense_buffer, 2886 se_cmd->scsi_sense_length, &sshdr)) 2887 if (sshdr.sense_key == HARDWARE_ERROR && 2888 (se_cmd->residual_count == 0 || 2889 se_cmd->residual_count == se_cmd->data_length)) { 2890 rc = NO_SENSE; 2891 cmd->flags |= CMD_FAST_FAIL; 2892 } 2893 2894 return rc; 2895 } 2896 2897 /** 2898 * srp_build_response() - Build an SRP response buffer 2899 * @vscsi: Pointer to our adapter structure 2900 * @cmd: Pointer to command for which to send the response 2901 * @len_p: Where to return the length of the IU response sent. This 2902 * is needed to construct the CRQ response. 2903 * 2904 * Build the SRP response buffer and copy it to the client's memory space. 2905 */ 2906 static long srp_build_response(struct scsi_info *vscsi, 2907 struct ibmvscsis_cmd *cmd, uint *len_p) 2908 { 2909 struct iu_entry *iue = cmd->iue; 2910 struct se_cmd *se_cmd = &cmd->se_cmd; 2911 struct srp_rsp *rsp; 2912 uint len; 2913 u32 rsp_code; 2914 char *data; 2915 u32 *tsk_status; 2916 long rc = ADAPT_SUCCESS; 2917 2918 spin_lock_bh(&vscsi->intr_lock); 2919 2920 rsp = &vio_iu(iue)->srp.rsp; 2921 len = sizeof(*rsp); 2922 memset(rsp, 0, len); 2923 data = rsp->data; 2924 2925 rsp->opcode = SRP_RSP; 2926 2927 if (vscsi->credit > 0 && vscsi->state == SRP_PROCESSING) 2928 rsp->req_lim_delta = cpu_to_be32(vscsi->credit); 2929 else 2930 rsp->req_lim_delta = cpu_to_be32(1 + vscsi->credit); 2931 rsp->tag = cmd->rsp.tag; 2932 rsp->flags = 0; 2933 2934 if (cmd->type == SCSI_CDB) { 2935 rsp->status = ibmvscsis_fast_fail(vscsi, cmd); 2936 if (rsp->status) { 2937 pr_debug("build_resp: cmd %p, scsi status %d\n", cmd, 2938 (int)rsp->status); 2939 ibmvscsis_determine_resid(se_cmd, rsp); 2940 if (se_cmd->scsi_sense_length && se_cmd->sense_buffer) { 2941 rsp->sense_data_len = 2942 cpu_to_be32(se_cmd->scsi_sense_length); 2943 rsp->flags |= SRP_RSP_FLAG_SNSVALID; 2944 len += se_cmd->scsi_sense_length; 2945 memcpy(data, se_cmd->sense_buffer, 2946 se_cmd->scsi_sense_length); 2947 } 2948 rsp->sol_not = (cmd->rsp.sol_not & UCSOLNT) >> 2949 UCSOLNT_RESP_SHIFT; 2950 } else if (cmd->flags & CMD_FAST_FAIL) { 2951 pr_debug("build_resp: cmd %p, fast fail\n", cmd); 2952 rsp->sol_not = (cmd->rsp.sol_not & UCSOLNT) >> 2953 UCSOLNT_RESP_SHIFT; 2954 } else { 2955 rsp->sol_not = (cmd->rsp.sol_not & SCSOLNT) >> 2956 SCSOLNT_RESP_SHIFT; 2957 } 2958 } else { 2959 /* this is task management */ 2960 rsp->status = 0; 2961 rsp->resp_data_len = cpu_to_be32(4); 2962 rsp->flags |= SRP_RSP_FLAG_RSPVALID; 2963 2964 switch (se_cmd->se_tmr_req->response) { 2965 case TMR_FUNCTION_COMPLETE: 2966 case TMR_TASK_DOES_NOT_EXIST: 2967 rsp_code = SRP_TASK_MANAGEMENT_FUNCTION_COMPLETE; 2968 rsp->sol_not = (cmd->rsp.sol_not & SCSOLNT) >> 2969 SCSOLNT_RESP_SHIFT; 2970 break; 2971 case TMR_TASK_MGMT_FUNCTION_NOT_SUPPORTED: 2972 case TMR_LUN_DOES_NOT_EXIST: 2973 rsp_code = SRP_TASK_MANAGEMENT_FUNCTION_NOT_SUPPORTED; 2974 rsp->sol_not = (cmd->rsp.sol_not & UCSOLNT) >> 2975 UCSOLNT_RESP_SHIFT; 2976 break; 2977 case TMR_FUNCTION_FAILED: 2978 case TMR_FUNCTION_REJECTED: 2979 default: 2980 rsp_code = SRP_TASK_MANAGEMENT_FUNCTION_FAILED; 2981 rsp->sol_not = (cmd->rsp.sol_not & UCSOLNT) >> 2982 UCSOLNT_RESP_SHIFT; 2983 break; 2984 } 2985 2986 tsk_status = (u32 *)data; 2987 *tsk_status = cpu_to_be32(rsp_code); 2988 data = (char *)(tsk_status + 1); 2989 len += 4; 2990 } 2991 2992 dma_wmb(); 2993 rc = h_copy_rdma(len, vscsi->dds.window[LOCAL].liobn, iue->sbuf->dma, 2994 vscsi->dds.window[REMOTE].liobn, 2995 be64_to_cpu(iue->remote_token)); 2996 2997 switch (rc) { 2998 case H_SUCCESS: 2999 vscsi->credit = 0; 3000 *len_p = len; 3001 break; 3002 case H_PERMISSION: 3003 if (connection_broken(vscsi)) 3004 vscsi->flags |= RESPONSE_Q_DOWN | CLIENT_FAILED; 3005 3006 dev_err(&vscsi->dev, "build_response: error copying to client, rc %ld, flags 0x%x, state 0x%hx\n", 3007 rc, vscsi->flags, vscsi->state); 3008 break; 3009 case H_SOURCE_PARM: 3010 case H_DEST_PARM: 3011 default: 3012 dev_err(&vscsi->dev, "build_response: error copying to client, rc %ld\n", 3013 rc); 3014 break; 3015 } 3016 3017 spin_unlock_bh(&vscsi->intr_lock); 3018 3019 return rc; 3020 } 3021 3022 static int ibmvscsis_rdma(struct ibmvscsis_cmd *cmd, struct scatterlist *sg, 3023 int nsg, struct srp_direct_buf *md, int nmd, 3024 enum dma_data_direction dir, unsigned int bytes) 3025 { 3026 struct iu_entry *iue = cmd->iue; 3027 struct srp_target *target = iue->target; 3028 struct scsi_info *vscsi = target->ldata; 3029 struct scatterlist *sgp; 3030 dma_addr_t client_ioba, server_ioba; 3031 ulong buf_len; 3032 ulong client_len, server_len; 3033 int md_idx; 3034 long tx_len; 3035 long rc = 0; 3036 3037 if (bytes == 0) 3038 return 0; 3039 3040 sgp = sg; 3041 client_len = 0; 3042 server_len = 0; 3043 md_idx = 0; 3044 tx_len = bytes; 3045 3046 do { 3047 if (client_len == 0) { 3048 if (md_idx >= nmd) { 3049 dev_err(&vscsi->dev, "rdma: ran out of client memory descriptors\n"); 3050 rc = -EIO; 3051 break; 3052 } 3053 client_ioba = be64_to_cpu(md[md_idx].va); 3054 client_len = be32_to_cpu(md[md_idx].len); 3055 } 3056 if (server_len == 0) { 3057 if (!sgp) { 3058 dev_err(&vscsi->dev, "rdma: ran out of scatter/gather list\n"); 3059 rc = -EIO; 3060 break; 3061 } 3062 server_ioba = sg_dma_address(sgp); 3063 server_len = sg_dma_len(sgp); 3064 } 3065 3066 buf_len = tx_len; 3067 3068 if (buf_len > client_len) 3069 buf_len = client_len; 3070 3071 if (buf_len > server_len) 3072 buf_len = server_len; 3073 3074 if (buf_len > max_vdma_size) 3075 buf_len = max_vdma_size; 3076 3077 if (dir == DMA_TO_DEVICE) { 3078 /* read from client */ 3079 rc = h_copy_rdma(buf_len, 3080 vscsi->dds.window[REMOTE].liobn, 3081 client_ioba, 3082 vscsi->dds.window[LOCAL].liobn, 3083 server_ioba); 3084 } else { 3085 /* The h_copy_rdma will cause phyp, running in another 3086 * partition, to read memory, so we need to make sure 3087 * the data has been written out, hence these syncs. 3088 */ 3089 /* ensure that everything is in memory */ 3090 isync(); 3091 /* ensure that memory has been made visible */ 3092 dma_wmb(); 3093 rc = h_copy_rdma(buf_len, 3094 vscsi->dds.window[LOCAL].liobn, 3095 server_ioba, 3096 vscsi->dds.window[REMOTE].liobn, 3097 client_ioba); 3098 } 3099 switch (rc) { 3100 case H_SUCCESS: 3101 break; 3102 case H_PERMISSION: 3103 case H_SOURCE_PARM: 3104 case H_DEST_PARM: 3105 if (connection_broken(vscsi)) { 3106 spin_lock_bh(&vscsi->intr_lock); 3107 vscsi->flags |= 3108 (RESPONSE_Q_DOWN | CLIENT_FAILED); 3109 spin_unlock_bh(&vscsi->intr_lock); 3110 } 3111 dev_err(&vscsi->dev, "rdma: h_copy_rdma failed, rc %ld\n", 3112 rc); 3113 break; 3114 3115 default: 3116 dev_err(&vscsi->dev, "rdma: unknown error %ld from h_copy_rdma\n", 3117 rc); 3118 break; 3119 } 3120 3121 if (!rc) { 3122 tx_len -= buf_len; 3123 if (tx_len) { 3124 client_len -= buf_len; 3125 if (client_len == 0) 3126 md_idx++; 3127 else 3128 client_ioba += buf_len; 3129 3130 server_len -= buf_len; 3131 if (server_len == 0) 3132 sgp = sg_next(sgp); 3133 else 3134 server_ioba += buf_len; 3135 } else { 3136 break; 3137 } 3138 } 3139 } while (!rc); 3140 3141 return rc; 3142 } 3143 3144 /** 3145 * ibmvscsis_handle_crq() - Handle CRQ 3146 * @data: Pointer to our adapter structure 3147 * 3148 * Read the command elements from the command queue and copy the payloads 3149 * associated with the command elements to local memory and execute the 3150 * SRP requests. 3151 * 3152 * Note: this is an edge triggered interrupt. It can not be shared. 3153 */ 3154 static void ibmvscsis_handle_crq(unsigned long data) 3155 { 3156 struct scsi_info *vscsi = (struct scsi_info *)data; 3157 struct viosrp_crq *crq; 3158 long rc; 3159 bool ack = true; 3160 volatile u8 valid; 3161 3162 spin_lock_bh(&vscsi->intr_lock); 3163 3164 pr_debug("got interrupt\n"); 3165 3166 /* 3167 * if we are in a path where we are waiting for all pending commands 3168 * to complete because we received a transport event and anything in 3169 * the command queue is for a new connection, do nothing 3170 */ 3171 if (TARGET_STOP(vscsi)) { 3172 vio_enable_interrupts(vscsi->dma_dev); 3173 3174 pr_debug("handle_crq, don't process: flags 0x%x, state 0x%hx\n", 3175 vscsi->flags, vscsi->state); 3176 spin_unlock_bh(&vscsi->intr_lock); 3177 return; 3178 } 3179 3180 rc = vscsi->flags & SCHEDULE_DISCONNECT; 3181 crq = vscsi->cmd_q.base_addr + vscsi->cmd_q.index; 3182 valid = crq->valid; 3183 dma_rmb(); 3184 3185 while (valid) { 3186 /* 3187 * These are edege triggered interrupts. After dropping out of 3188 * the while loop, the code must check for work since an 3189 * interrupt could be lost, and an elment be left on the queue, 3190 * hence the label. 3191 */ 3192 cmd_work: 3193 vscsi->cmd_q.index = 3194 (vscsi->cmd_q.index + 1) & vscsi->cmd_q.mask; 3195 3196 if (!rc) { 3197 rc = ibmvscsis_parse_command(vscsi, crq); 3198 } else { 3199 if ((uint)crq->valid == VALID_TRANS_EVENT) { 3200 /* 3201 * must service the transport layer events even 3202 * in an error state, dont break out until all 3203 * the consecutive transport events have been 3204 * processed 3205 */ 3206 rc = ibmvscsis_trans_event(vscsi, crq); 3207 } else if (vscsi->flags & TRANS_EVENT) { 3208 /* 3209 * if a transport event has occurred leave 3210 * everything but transport events on the queue 3211 * 3212 * need to decrement the queue index so we can 3213 * look at the element again 3214 */ 3215 if (vscsi->cmd_q.index) 3216 vscsi->cmd_q.index -= 1; 3217 else 3218 /* 3219 * index is at 0 it just wrapped. 3220 * have it index last element in q 3221 */ 3222 vscsi->cmd_q.index = vscsi->cmd_q.mask; 3223 break; 3224 } 3225 } 3226 3227 crq->valid = INVALIDATE_CMD_RESP_EL; 3228 3229 crq = vscsi->cmd_q.base_addr + vscsi->cmd_q.index; 3230 valid = crq->valid; 3231 dma_rmb(); 3232 } 3233 3234 if (!rc) { 3235 if (ack) { 3236 vio_enable_interrupts(vscsi->dma_dev); 3237 ack = false; 3238 pr_debug("handle_crq, reenabling interrupts\n"); 3239 } 3240 valid = crq->valid; 3241 dma_rmb(); 3242 if (valid) 3243 goto cmd_work; 3244 } else { 3245 pr_debug("handle_crq, error: flags 0x%x, state 0x%hx, crq index 0x%x\n", 3246 vscsi->flags, vscsi->state, vscsi->cmd_q.index); 3247 } 3248 3249 pr_debug("Leaving handle_crq: schedule_q empty %d, flags 0x%x, state 0x%hx\n", 3250 (int)list_empty(&vscsi->schedule_q), vscsi->flags, 3251 vscsi->state); 3252 3253 spin_unlock_bh(&vscsi->intr_lock); 3254 } 3255 3256 static int ibmvscsis_probe(struct vio_dev *vdev, 3257 const struct vio_device_id *id) 3258 { 3259 struct scsi_info *vscsi; 3260 int rc = 0; 3261 long hrc = 0; 3262 char wq_name[24]; 3263 3264 vscsi = kzalloc(sizeof(*vscsi), GFP_KERNEL); 3265 if (!vscsi) { 3266 rc = -ENOMEM; 3267 pr_err("probe: allocation of adapter failed\n"); 3268 return rc; 3269 } 3270 3271 vscsi->dma_dev = vdev; 3272 vscsi->dev = vdev->dev; 3273 INIT_LIST_HEAD(&vscsi->schedule_q); 3274 INIT_LIST_HEAD(&vscsi->waiting_rsp); 3275 INIT_LIST_HEAD(&vscsi->active_q); 3276 3277 snprintf(vscsi->tport.tport_name, IBMVSCSIS_NAMELEN, "%s", 3278 dev_name(&vdev->dev)); 3279 3280 pr_debug("probe tport_name: %s\n", vscsi->tport.tport_name); 3281 3282 rc = read_dma_window(vscsi); 3283 if (rc) 3284 goto free_adapter; 3285 pr_debug("Probe: liobn 0x%x, riobn 0x%x\n", 3286 vscsi->dds.window[LOCAL].liobn, 3287 vscsi->dds.window[REMOTE].liobn); 3288 3289 strcpy(vscsi->eye, "VSCSI "); 3290 strncat(vscsi->eye, vdev->name, MAX_EYE); 3291 3292 vscsi->dds.unit_id = vdev->unit_address; 3293 strncpy(vscsi->dds.partition_name, partition_name, 3294 sizeof(vscsi->dds.partition_name)); 3295 vscsi->dds.partition_num = partition_number; 3296 3297 spin_lock_bh(&ibmvscsis_dev_lock); 3298 list_add_tail(&vscsi->list, &ibmvscsis_dev_list); 3299 spin_unlock_bh(&ibmvscsis_dev_lock); 3300 3301 /* 3302 * TBD: How do we determine # of cmds to request? Do we know how 3303 * many "children" we have? 3304 */ 3305 vscsi->request_limit = INITIAL_SRP_LIMIT; 3306 rc = srp_target_alloc(&vscsi->target, &vdev->dev, vscsi->request_limit, 3307 SRP_MAX_IU_LEN); 3308 if (rc) 3309 goto rem_list; 3310 3311 vscsi->target.ldata = vscsi; 3312 3313 rc = ibmvscsis_alloc_cmds(vscsi, vscsi->request_limit); 3314 if (rc) { 3315 dev_err(&vscsi->dev, "alloc_cmds failed, rc %d, num %d\n", 3316 rc, vscsi->request_limit); 3317 goto free_target; 3318 } 3319 3320 /* 3321 * Note: the lock is used in freeing timers, so must initialize 3322 * first so that ordering in case of error is correct. 3323 */ 3324 spin_lock_init(&vscsi->intr_lock); 3325 3326 rc = ibmvscsis_alloctimer(vscsi); 3327 if (rc) { 3328 dev_err(&vscsi->dev, "probe: alloctimer failed, rc %d\n", rc); 3329 goto free_cmds; 3330 } 3331 3332 rc = ibmvscsis_create_command_q(vscsi, 256); 3333 if (rc) { 3334 dev_err(&vscsi->dev, "probe: create_command_q failed, rc %d\n", 3335 rc); 3336 goto free_timer; 3337 } 3338 3339 vscsi->map_buf = kzalloc(PAGE_SIZE, GFP_KERNEL); 3340 if (!vscsi->map_buf) { 3341 rc = -ENOMEM; 3342 dev_err(&vscsi->dev, "probe: allocating cmd buffer failed\n"); 3343 goto destroy_queue; 3344 } 3345 3346 vscsi->map_ioba = dma_map_single(&vdev->dev, vscsi->map_buf, PAGE_SIZE, 3347 DMA_BIDIRECTIONAL); 3348 if (dma_mapping_error(&vdev->dev, vscsi->map_ioba)) { 3349 rc = -ENOMEM; 3350 dev_err(&vscsi->dev, "probe: error mapping command buffer\n"); 3351 goto free_buf; 3352 } 3353 3354 hrc = h_vioctl(vscsi->dds.unit_id, H_GET_PARTNER_INFO, 3355 (u64)vscsi->map_ioba | ((u64)PAGE_SIZE << 32), 0, 0, 0, 3356 0); 3357 if (hrc == H_SUCCESS) 3358 vscsi->client_data.partition_number = 3359 be64_to_cpu(*(u64 *)vscsi->map_buf); 3360 /* 3361 * We expect the VIOCTL to fail if we're configured as "any 3362 * client can connect" and the client isn't activated yet. 3363 * We'll make the call again when he sends an init msg. 3364 */ 3365 pr_debug("probe hrc %ld, client partition num %d\n", 3366 hrc, vscsi->client_data.partition_number); 3367 3368 tasklet_init(&vscsi->work_task, ibmvscsis_handle_crq, 3369 (unsigned long)vscsi); 3370 3371 init_completion(&vscsi->wait_idle); 3372 init_completion(&vscsi->unconfig); 3373 3374 snprintf(wq_name, 24, "ibmvscsis%s", dev_name(&vdev->dev)); 3375 vscsi->work_q = create_workqueue(wq_name); 3376 if (!vscsi->work_q) { 3377 rc = -ENOMEM; 3378 dev_err(&vscsi->dev, "create_workqueue failed\n"); 3379 goto unmap_buf; 3380 } 3381 3382 rc = request_irq(vdev->irq, ibmvscsis_interrupt, 0, "ibmvscsis", vscsi); 3383 if (rc) { 3384 rc = -EPERM; 3385 dev_err(&vscsi->dev, "probe: request_irq failed, rc %d\n", rc); 3386 goto destroy_WQ; 3387 } 3388 3389 vscsi->state = WAIT_ENABLED; 3390 3391 dev_set_drvdata(&vdev->dev, vscsi); 3392 3393 return 0; 3394 3395 destroy_WQ: 3396 destroy_workqueue(vscsi->work_q); 3397 unmap_buf: 3398 dma_unmap_single(&vdev->dev, vscsi->map_ioba, PAGE_SIZE, 3399 DMA_BIDIRECTIONAL); 3400 free_buf: 3401 kfree(vscsi->map_buf); 3402 destroy_queue: 3403 tasklet_kill(&vscsi->work_task); 3404 ibmvscsis_unregister_command_q(vscsi); 3405 ibmvscsis_destroy_command_q(vscsi); 3406 free_timer: 3407 ibmvscsis_freetimer(vscsi); 3408 free_cmds: 3409 ibmvscsis_free_cmds(vscsi); 3410 free_target: 3411 srp_target_free(&vscsi->target); 3412 rem_list: 3413 spin_lock_bh(&ibmvscsis_dev_lock); 3414 list_del(&vscsi->list); 3415 spin_unlock_bh(&ibmvscsis_dev_lock); 3416 free_adapter: 3417 kfree(vscsi); 3418 3419 return rc; 3420 } 3421 3422 static int ibmvscsis_remove(struct vio_dev *vdev) 3423 { 3424 struct scsi_info *vscsi = dev_get_drvdata(&vdev->dev); 3425 3426 pr_debug("remove (%s)\n", dev_name(&vscsi->dma_dev->dev)); 3427 3428 spin_lock_bh(&vscsi->intr_lock); 3429 ibmvscsis_post_disconnect(vscsi, UNCONFIGURING, 0); 3430 vscsi->flags |= CFG_SLEEPING; 3431 spin_unlock_bh(&vscsi->intr_lock); 3432 wait_for_completion(&vscsi->unconfig); 3433 3434 vio_disable_interrupts(vdev); 3435 free_irq(vdev->irq, vscsi); 3436 destroy_workqueue(vscsi->work_q); 3437 dma_unmap_single(&vdev->dev, vscsi->map_ioba, PAGE_SIZE, 3438 DMA_BIDIRECTIONAL); 3439 kfree(vscsi->map_buf); 3440 tasklet_kill(&vscsi->work_task); 3441 ibmvscsis_destroy_command_q(vscsi); 3442 ibmvscsis_freetimer(vscsi); 3443 ibmvscsis_free_cmds(vscsi); 3444 srp_target_free(&vscsi->target); 3445 spin_lock_bh(&ibmvscsis_dev_lock); 3446 list_del(&vscsi->list); 3447 spin_unlock_bh(&ibmvscsis_dev_lock); 3448 kfree(vscsi); 3449 3450 return 0; 3451 } 3452 3453 static ssize_t system_id_show(struct device *dev, 3454 struct device_attribute *attr, char *buf) 3455 { 3456 return snprintf(buf, PAGE_SIZE, "%s\n", system_id); 3457 } 3458 3459 static ssize_t partition_number_show(struct device *dev, 3460 struct device_attribute *attr, char *buf) 3461 { 3462 return snprintf(buf, PAGE_SIZE, "%x\n", partition_number); 3463 } 3464 3465 static ssize_t unit_address_show(struct device *dev, 3466 struct device_attribute *attr, char *buf) 3467 { 3468 struct scsi_info *vscsi = container_of(dev, struct scsi_info, dev); 3469 3470 return snprintf(buf, PAGE_SIZE, "%x\n", vscsi->dma_dev->unit_address); 3471 } 3472 3473 static int ibmvscsis_get_system_info(void) 3474 { 3475 struct device_node *rootdn, *vdevdn; 3476 const char *id, *model, *name; 3477 const uint *num; 3478 3479 rootdn = of_find_node_by_path("/"); 3480 if (!rootdn) 3481 return -ENOENT; 3482 3483 model = of_get_property(rootdn, "model", NULL); 3484 id = of_get_property(rootdn, "system-id", NULL); 3485 if (model && id) 3486 snprintf(system_id, sizeof(system_id), "%s-%s", model, id); 3487 3488 name = of_get_property(rootdn, "ibm,partition-name", NULL); 3489 if (name) 3490 strncpy(partition_name, name, sizeof(partition_name)); 3491 3492 num = of_get_property(rootdn, "ibm,partition-no", NULL); 3493 if (num) 3494 partition_number = of_read_number(num, 1); 3495 3496 of_node_put(rootdn); 3497 3498 vdevdn = of_find_node_by_path("/vdevice"); 3499 if (vdevdn) { 3500 const uint *mvds; 3501 3502 mvds = of_get_property(vdevdn, "ibm,max-virtual-dma-size", 3503 NULL); 3504 if (mvds) 3505 max_vdma_size = *mvds; 3506 of_node_put(vdevdn); 3507 } 3508 3509 return 0; 3510 } 3511 3512 static char *ibmvscsis_get_fabric_name(void) 3513 { 3514 return "ibmvscsis"; 3515 } 3516 3517 static char *ibmvscsis_get_fabric_wwn(struct se_portal_group *se_tpg) 3518 { 3519 struct ibmvscsis_tport *tport = 3520 container_of(se_tpg, struct ibmvscsis_tport, se_tpg); 3521 3522 return tport->tport_name; 3523 } 3524 3525 static u16 ibmvscsis_get_tag(struct se_portal_group *se_tpg) 3526 { 3527 struct ibmvscsis_tport *tport = 3528 container_of(se_tpg, struct ibmvscsis_tport, se_tpg); 3529 3530 return tport->tport_tpgt; 3531 } 3532 3533 static u32 ibmvscsis_get_default_depth(struct se_portal_group *se_tpg) 3534 { 3535 return 1; 3536 } 3537 3538 static int ibmvscsis_check_true(struct se_portal_group *se_tpg) 3539 { 3540 return 1; 3541 } 3542 3543 static int ibmvscsis_check_false(struct se_portal_group *se_tpg) 3544 { 3545 return 0; 3546 } 3547 3548 static u32 ibmvscsis_tpg_get_inst_index(struct se_portal_group *se_tpg) 3549 { 3550 return 1; 3551 } 3552 3553 static int ibmvscsis_check_stop_free(struct se_cmd *se_cmd) 3554 { 3555 return target_put_sess_cmd(se_cmd); 3556 } 3557 3558 static void ibmvscsis_release_cmd(struct se_cmd *se_cmd) 3559 { 3560 struct ibmvscsis_cmd *cmd = container_of(se_cmd, struct ibmvscsis_cmd, 3561 se_cmd); 3562 struct scsi_info *vscsi = cmd->adapter; 3563 3564 spin_lock_bh(&vscsi->intr_lock); 3565 /* Remove from active_q */ 3566 list_move_tail(&cmd->list, &vscsi->waiting_rsp); 3567 ibmvscsis_send_messages(vscsi); 3568 spin_unlock_bh(&vscsi->intr_lock); 3569 } 3570 3571 static u32 ibmvscsis_sess_get_index(struct se_session *se_sess) 3572 { 3573 return 0; 3574 } 3575 3576 static int ibmvscsis_write_pending(struct se_cmd *se_cmd) 3577 { 3578 struct ibmvscsis_cmd *cmd = container_of(se_cmd, struct ibmvscsis_cmd, 3579 se_cmd); 3580 struct iu_entry *iue = cmd->iue; 3581 int rc; 3582 3583 rc = srp_transfer_data(cmd, &vio_iu(iue)->srp.cmd, ibmvscsis_rdma, 3584 1, 1); 3585 if (rc) { 3586 pr_err("srp_transfer_data() failed: %d\n", rc); 3587 return -EAGAIN; 3588 } 3589 /* 3590 * We now tell TCM to add this WRITE CDB directly into the TCM storage 3591 * object execution queue. 3592 */ 3593 target_execute_cmd(se_cmd); 3594 return 0; 3595 } 3596 3597 static int ibmvscsis_write_pending_status(struct se_cmd *se_cmd) 3598 { 3599 return 0; 3600 } 3601 3602 static void ibmvscsis_set_default_node_attrs(struct se_node_acl *nacl) 3603 { 3604 } 3605 3606 static int ibmvscsis_get_cmd_state(struct se_cmd *se_cmd) 3607 { 3608 return 0; 3609 } 3610 3611 static int ibmvscsis_queue_data_in(struct se_cmd *se_cmd) 3612 { 3613 struct ibmvscsis_cmd *cmd = container_of(se_cmd, struct ibmvscsis_cmd, 3614 se_cmd); 3615 struct iu_entry *iue = cmd->iue; 3616 struct scsi_info *vscsi = cmd->adapter; 3617 char *sd; 3618 uint len = 0; 3619 int rc; 3620 3621 rc = srp_transfer_data(cmd, &vio_iu(iue)->srp.cmd, ibmvscsis_rdma, 1, 3622 1); 3623 if (rc) { 3624 pr_err("srp_transfer_data failed: %d\n", rc); 3625 sd = se_cmd->sense_buffer; 3626 se_cmd->scsi_sense_length = 18; 3627 memset(se_cmd->sense_buffer, 0, se_cmd->scsi_sense_length); 3628 /* Logical Unit Communication Time-out asc/ascq = 0x0801 */ 3629 scsi_build_sense_buffer(0, se_cmd->sense_buffer, MEDIUM_ERROR, 3630 0x08, 0x01); 3631 } 3632 3633 srp_build_response(vscsi, cmd, &len); 3634 cmd->rsp.format = SRP_FORMAT; 3635 cmd->rsp.len = len; 3636 3637 return 0; 3638 } 3639 3640 static int ibmvscsis_queue_status(struct se_cmd *se_cmd) 3641 { 3642 struct ibmvscsis_cmd *cmd = container_of(se_cmd, struct ibmvscsis_cmd, 3643 se_cmd); 3644 struct scsi_info *vscsi = cmd->adapter; 3645 uint len; 3646 3647 pr_debug("queue_status %p\n", se_cmd); 3648 3649 srp_build_response(vscsi, cmd, &len); 3650 cmd->rsp.format = SRP_FORMAT; 3651 cmd->rsp.len = len; 3652 3653 return 0; 3654 } 3655 3656 static void ibmvscsis_queue_tm_rsp(struct se_cmd *se_cmd) 3657 { 3658 struct ibmvscsis_cmd *cmd = container_of(se_cmd, struct ibmvscsis_cmd, 3659 se_cmd); 3660 struct scsi_info *vscsi = cmd->adapter; 3661 uint len; 3662 3663 pr_debug("queue_tm_rsp %p, status %d\n", 3664 se_cmd, (int)se_cmd->se_tmr_req->response); 3665 3666 srp_build_response(vscsi, cmd, &len); 3667 cmd->rsp.format = SRP_FORMAT; 3668 cmd->rsp.len = len; 3669 } 3670 3671 static void ibmvscsis_aborted_task(struct se_cmd *se_cmd) 3672 { 3673 /* TBD: What (if anything) should we do here? */ 3674 pr_debug("ibmvscsis_aborted_task %p\n", se_cmd); 3675 } 3676 3677 static struct se_wwn *ibmvscsis_make_tport(struct target_fabric_configfs *tf, 3678 struct config_group *group, 3679 const char *name) 3680 { 3681 struct ibmvscsis_tport *tport; 3682 3683 tport = ibmvscsis_lookup_port(name); 3684 if (tport) { 3685 tport->tport_proto_id = SCSI_PROTOCOL_SRP; 3686 pr_debug("make_tport(%s), pointer:%p, tport_id:%x\n", 3687 name, tport, tport->tport_proto_id); 3688 return &tport->tport_wwn; 3689 } 3690 3691 return ERR_PTR(-EINVAL); 3692 } 3693 3694 static void ibmvscsis_drop_tport(struct se_wwn *wwn) 3695 { 3696 struct ibmvscsis_tport *tport = container_of(wwn, 3697 struct ibmvscsis_tport, 3698 tport_wwn); 3699 3700 pr_debug("drop_tport(%s)\n", 3701 config_item_name(&tport->tport_wwn.wwn_group.cg_item)); 3702 } 3703 3704 static struct se_portal_group *ibmvscsis_make_tpg(struct se_wwn *wwn, 3705 struct config_group *group, 3706 const char *name) 3707 { 3708 struct ibmvscsis_tport *tport = 3709 container_of(wwn, struct ibmvscsis_tport, tport_wwn); 3710 int rc; 3711 3712 tport->releasing = false; 3713 3714 rc = core_tpg_register(&tport->tport_wwn, &tport->se_tpg, 3715 tport->tport_proto_id); 3716 if (rc) 3717 return ERR_PTR(rc); 3718 3719 return &tport->se_tpg; 3720 } 3721 3722 static void ibmvscsis_drop_tpg(struct se_portal_group *se_tpg) 3723 { 3724 struct ibmvscsis_tport *tport = container_of(se_tpg, 3725 struct ibmvscsis_tport, 3726 se_tpg); 3727 3728 tport->releasing = true; 3729 tport->enabled = false; 3730 3731 /* 3732 * Release the virtual I_T Nexus for this ibmvscsis TPG 3733 */ 3734 ibmvscsis_drop_nexus(tport); 3735 /* 3736 * Deregister the se_tpg from TCM.. 3737 */ 3738 core_tpg_deregister(se_tpg); 3739 } 3740 3741 static ssize_t ibmvscsis_wwn_version_show(struct config_item *item, 3742 char *page) 3743 { 3744 return scnprintf(page, PAGE_SIZE, "%s\n", IBMVSCSIS_VERSION); 3745 } 3746 CONFIGFS_ATTR_RO(ibmvscsis_wwn_, version); 3747 3748 static struct configfs_attribute *ibmvscsis_wwn_attrs[] = { 3749 &ibmvscsis_wwn_attr_version, 3750 NULL, 3751 }; 3752 3753 static ssize_t ibmvscsis_tpg_enable_show(struct config_item *item, 3754 char *page) 3755 { 3756 struct se_portal_group *se_tpg = to_tpg(item); 3757 struct ibmvscsis_tport *tport = container_of(se_tpg, 3758 struct ibmvscsis_tport, 3759 se_tpg); 3760 3761 return snprintf(page, PAGE_SIZE, "%d\n", (tport->enabled) ? 1 : 0); 3762 } 3763 3764 static ssize_t ibmvscsis_tpg_enable_store(struct config_item *item, 3765 const char *page, size_t count) 3766 { 3767 struct se_portal_group *se_tpg = to_tpg(item); 3768 struct ibmvscsis_tport *tport = container_of(se_tpg, 3769 struct ibmvscsis_tport, 3770 se_tpg); 3771 struct scsi_info *vscsi = container_of(tport, struct scsi_info, tport); 3772 unsigned long tmp; 3773 int rc; 3774 long lrc; 3775 3776 rc = kstrtoul(page, 0, &tmp); 3777 if (rc < 0) { 3778 pr_err("Unable to extract srpt_tpg_store_enable\n"); 3779 return -EINVAL; 3780 } 3781 3782 if ((tmp != 0) && (tmp != 1)) { 3783 pr_err("Illegal value for srpt_tpg_store_enable\n"); 3784 return -EINVAL; 3785 } 3786 3787 if (tmp) { 3788 spin_lock_bh(&vscsi->intr_lock); 3789 tport->enabled = true; 3790 lrc = ibmvscsis_enable_change_state(vscsi); 3791 if (lrc) 3792 pr_err("enable_change_state failed, rc %ld state %d\n", 3793 lrc, vscsi->state); 3794 spin_unlock_bh(&vscsi->intr_lock); 3795 } else { 3796 spin_lock_bh(&vscsi->intr_lock); 3797 tport->enabled = false; 3798 /* This simulates the server going down */ 3799 ibmvscsis_post_disconnect(vscsi, ERR_DISCONNECT, 0); 3800 spin_unlock_bh(&vscsi->intr_lock); 3801 } 3802 3803 pr_debug("tpg_enable_store, tmp %ld, state %d\n", tmp, vscsi->state); 3804 3805 return count; 3806 } 3807 CONFIGFS_ATTR(ibmvscsis_tpg_, enable); 3808 3809 static struct configfs_attribute *ibmvscsis_tpg_attrs[] = { 3810 &ibmvscsis_tpg_attr_enable, 3811 NULL, 3812 }; 3813 3814 static const struct target_core_fabric_ops ibmvscsis_ops = { 3815 .module = THIS_MODULE, 3816 .name = "ibmvscsis", 3817 .get_fabric_name = ibmvscsis_get_fabric_name, 3818 .tpg_get_wwn = ibmvscsis_get_fabric_wwn, 3819 .tpg_get_tag = ibmvscsis_get_tag, 3820 .tpg_get_default_depth = ibmvscsis_get_default_depth, 3821 .tpg_check_demo_mode = ibmvscsis_check_true, 3822 .tpg_check_demo_mode_cache = ibmvscsis_check_true, 3823 .tpg_check_demo_mode_write_protect = ibmvscsis_check_false, 3824 .tpg_check_prod_mode_write_protect = ibmvscsis_check_false, 3825 .tpg_get_inst_index = ibmvscsis_tpg_get_inst_index, 3826 .check_stop_free = ibmvscsis_check_stop_free, 3827 .release_cmd = ibmvscsis_release_cmd, 3828 .sess_get_index = ibmvscsis_sess_get_index, 3829 .write_pending = ibmvscsis_write_pending, 3830 .write_pending_status = ibmvscsis_write_pending_status, 3831 .set_default_node_attributes = ibmvscsis_set_default_node_attrs, 3832 .get_cmd_state = ibmvscsis_get_cmd_state, 3833 .queue_data_in = ibmvscsis_queue_data_in, 3834 .queue_status = ibmvscsis_queue_status, 3835 .queue_tm_rsp = ibmvscsis_queue_tm_rsp, 3836 .aborted_task = ibmvscsis_aborted_task, 3837 /* 3838 * Setup function pointers for logic in target_core_fabric_configfs.c 3839 */ 3840 .fabric_make_wwn = ibmvscsis_make_tport, 3841 .fabric_drop_wwn = ibmvscsis_drop_tport, 3842 .fabric_make_tpg = ibmvscsis_make_tpg, 3843 .fabric_drop_tpg = ibmvscsis_drop_tpg, 3844 3845 .tfc_wwn_attrs = ibmvscsis_wwn_attrs, 3846 .tfc_tpg_base_attrs = ibmvscsis_tpg_attrs, 3847 }; 3848 3849 static void ibmvscsis_dev_release(struct device *dev) {}; 3850 3851 static struct class_attribute ibmvscsis_class_attrs[] = { 3852 __ATTR_NULL, 3853 }; 3854 3855 static struct device_attribute dev_attr_system_id = 3856 __ATTR(system_id, S_IRUGO, system_id_show, NULL); 3857 3858 static struct device_attribute dev_attr_partition_number = 3859 __ATTR(partition_number, S_IRUGO, partition_number_show, NULL); 3860 3861 static struct device_attribute dev_attr_unit_address = 3862 __ATTR(unit_address, S_IRUGO, unit_address_show, NULL); 3863 3864 static struct attribute *ibmvscsis_dev_attrs[] = { 3865 &dev_attr_system_id.attr, 3866 &dev_attr_partition_number.attr, 3867 &dev_attr_unit_address.attr, 3868 }; 3869 ATTRIBUTE_GROUPS(ibmvscsis_dev); 3870 3871 static struct class ibmvscsis_class = { 3872 .name = "ibmvscsis", 3873 .dev_release = ibmvscsis_dev_release, 3874 .class_attrs = ibmvscsis_class_attrs, 3875 .dev_groups = ibmvscsis_dev_groups, 3876 }; 3877 3878 static struct vio_device_id ibmvscsis_device_table[] = { 3879 { "v-scsi-host", "IBM,v-scsi-host" }, 3880 { "", "" } 3881 }; 3882 MODULE_DEVICE_TABLE(vio, ibmvscsis_device_table); 3883 3884 static struct vio_driver ibmvscsis_driver = { 3885 .name = "ibmvscsis", 3886 .id_table = ibmvscsis_device_table, 3887 .probe = ibmvscsis_probe, 3888 .remove = ibmvscsis_remove, 3889 }; 3890 3891 /* 3892 * ibmvscsis_init() - Kernel Module initialization 3893 * 3894 * Note: vio_register_driver() registers callback functions, and at least one 3895 * of those callback functions calls TCM - Linux IO Target Subsystem, thus 3896 * the SCSI Target template must be registered before vio_register_driver() 3897 * is called. 3898 */ 3899 static int __init ibmvscsis_init(void) 3900 { 3901 int rc = 0; 3902 3903 rc = ibmvscsis_get_system_info(); 3904 if (rc) { 3905 pr_err("rc %d from get_system_info\n", rc); 3906 goto out; 3907 } 3908 3909 rc = class_register(&ibmvscsis_class); 3910 if (rc) { 3911 pr_err("failed class register\n"); 3912 goto out; 3913 } 3914 3915 rc = target_register_template(&ibmvscsis_ops); 3916 if (rc) { 3917 pr_err("rc %d from target_register_template\n", rc); 3918 goto unregister_class; 3919 } 3920 3921 rc = vio_register_driver(&ibmvscsis_driver); 3922 if (rc) { 3923 pr_err("rc %d from vio_register_driver\n", rc); 3924 goto unregister_target; 3925 } 3926 3927 return 0; 3928 3929 unregister_target: 3930 target_unregister_template(&ibmvscsis_ops); 3931 unregister_class: 3932 class_unregister(&ibmvscsis_class); 3933 out: 3934 return rc; 3935 } 3936 3937 static void __exit ibmvscsis_exit(void) 3938 { 3939 pr_info("Unregister IBM virtual SCSI host driver\n"); 3940 vio_unregister_driver(&ibmvscsis_driver); 3941 target_unregister_template(&ibmvscsis_ops); 3942 class_unregister(&ibmvscsis_class); 3943 } 3944 3945 MODULE_DESCRIPTION("IBMVSCSIS fabric driver"); 3946 MODULE_AUTHOR("Bryant G. Ly and Michael Cyr"); 3947 MODULE_LICENSE("GPL"); 3948 MODULE_VERSION(IBMVSCSIS_VERSION); 3949 module_init(ibmvscsis_init); 3950 module_exit(ibmvscsis_exit); 3951