ibmvscsi_tgt.c

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