1 /*******************************************************************************
2 * IBM Virtual SCSI Target Driver
3 * Copyright (C) 2003-2005 Dave Boutcher (boutcher@us.ibm.com) IBM Corp.
4 * Santiago Leon (santil@us.ibm.com) IBM Corp.
5 * Linda Xie (lxie@us.ibm.com) IBM Corp.
7 * Copyright (C) 2005-2011 FUJITA Tomonori <tomof@acm.org>
8 * Copyright (C) 2010 Nicholas A. Bellinger <nab@kernel.org>
10 * Authors: Bryant G. Ly <bryantly@linux.vnet.ibm.com>
11 * Authors: Michael Cyr <mikecyr@linux.vnet.ibm.com>
13 * This program is free software; you can redistribute it and/or modify
14 * it under the terms of the GNU General Public License as published by
15 * the Free Software Foundation; either version 2 of the License, or
16 * (at your option) any later version.
18 * This program is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU General Public License for more details.
23 ****************************************************************************/
25 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
27 #include <linux/module.h>
28 #include <linux/kernel.h>
29 #include <linux/slab.h>
30 #include <linux/types.h>
31 #include <linux/list.h>
32 #include <linux/string.h>
33 #include <linux/delay.h>
35 #include <target/target_core_base.h>
36 #include <target/target_core_fabric.h>
38 #include <asm/hvcall.h>
41 #include <scsi/viosrp.h>
43 #include "ibmvscsi_tgt.h"
45 #define IBMVSCSIS_VERSION "v0.2"
47 #define INITIAL_SRP_LIMIT 800
48 #define DEFAULT_MAX_SECTORS 256
49 #define MAX_TXU 1024 * 1024
51 static uint max_vdma_size
= MAX_H_COPY_RDMA
;
53 static char system_id
[SYS_ID_NAME_LEN
] = "";
54 static char partition_name
[PARTITION_NAMELEN
] = "UNKNOWN";
55 static uint partition_number
= -1;
57 /* Adapter list and lock to control it */
58 static DEFINE_SPINLOCK(ibmvscsis_dev_lock
);
59 static LIST_HEAD(ibmvscsis_dev_list
);
61 static long ibmvscsis_parse_command(struct scsi_info
*vscsi
,
62 struct viosrp_crq
*crq
);
64 static void ibmvscsis_adapter_idle(struct scsi_info
*vscsi
);
66 static void ibmvscsis_determine_resid(struct se_cmd
*se_cmd
,
69 u32 residual_count
= se_cmd
->residual_count
;
74 if (se_cmd
->se_cmd_flags
& SCF_UNDERFLOW_BIT
) {
75 if (se_cmd
->data_direction
== DMA_TO_DEVICE
) {
76 /* residual data from an underflow write */
77 rsp
->flags
= SRP_RSP_FLAG_DOUNDER
;
78 rsp
->data_out_res_cnt
= cpu_to_be32(residual_count
);
79 } else if (se_cmd
->data_direction
== DMA_FROM_DEVICE
) {
80 /* residual data from an underflow read */
81 rsp
->flags
= SRP_RSP_FLAG_DIUNDER
;
82 rsp
->data_in_res_cnt
= cpu_to_be32(residual_count
);
84 } else if (se_cmd
->se_cmd_flags
& SCF_OVERFLOW_BIT
) {
85 if (se_cmd
->data_direction
== DMA_TO_DEVICE
) {
86 /* residual data from an overflow write */
87 rsp
->flags
= SRP_RSP_FLAG_DOOVER
;
88 rsp
->data_out_res_cnt
= cpu_to_be32(residual_count
);
89 } else if (se_cmd
->data_direction
== DMA_FROM_DEVICE
) {
90 /* residual data from an overflow read */
91 rsp
->flags
= SRP_RSP_FLAG_DIOVER
;
92 rsp
->data_in_res_cnt
= cpu_to_be32(residual_count
);
98 * connection_broken() - Determine if the connection to the client is good
99 * @vscsi: Pointer to our adapter structure
101 * This function attempts to send a ping MAD to the client. If the call to
102 * queue the request returns H_CLOSED then the connection has been broken
103 * and the function returns TRUE.
105 * EXECUTION ENVIRONMENT:
106 * Interrupt or Process environment
108 static bool connection_broken(struct scsi_info
*vscsi
)
110 struct viosrp_crq
*crq
;
111 u64 buffer
[2] = { 0, 0 };
115 /* create a PING crq */
116 crq
= (struct viosrp_crq
*)&buffer
;
117 crq
->valid
= VALID_CMD_RESP_EL
;
118 crq
->format
= MESSAGE_IN_CRQ
;
121 h_return_code
= h_send_crq(vscsi
->dds
.unit_id
,
122 cpu_to_be64(buffer
[MSG_HI
]),
123 cpu_to_be64(buffer
[MSG_LOW
]));
125 pr_debug("connection_broken: rc %ld\n", h_return_code
);
127 if (h_return_code
== H_CLOSED
)
134 * ibmvscsis_unregister_command_q() - Helper Function-Unregister Command Queue
135 * @vscsi: Pointer to our adapter structure
137 * This function calls h_free_q then frees the interrupt bit etc.
138 * It must release the lock before doing so because of the time it can take
139 * for h_free_crq in PHYP
140 * NOTE: the caller must make sure that state and or flags will prevent
141 * interrupt handler from scheduling work.
142 * NOTE: anyone calling this function may need to set the CRQ_CLOSED flag
143 * we can't do it here, because we don't have the lock
145 * EXECUTION ENVIRONMENT:
148 static long ibmvscsis_unregister_command_q(struct scsi_info
*vscsi
)
151 long rc
= ADAPT_SUCCESS
;
155 qrc
= h_free_crq(vscsi
->dds
.unit_id
);
158 spin_lock_bh(&vscsi
->intr_lock
);
159 vscsi
->flags
&= ~PREP_FOR_SUSPEND_FLAGS
;
160 spin_unlock_bh(&vscsi
->intr_lock
);
165 dev_err(&vscsi
->dev
, "unregister_command_q: error from h_free_crq %ld\n",
171 case H_LONG_BUSY_ORDER_1_MSEC
:
172 /* msleep not good for small values */
173 usleep_range(1000, 2000);
176 case H_LONG_BUSY_ORDER_10_MSEC
:
177 usleep_range(10000, 20000);
180 case H_LONG_BUSY_ORDER_100_MSEC
:
184 case H_LONG_BUSY_ORDER_1_SEC
:
188 case H_LONG_BUSY_ORDER_10_SEC
:
192 case H_LONG_BUSY_ORDER_100_SEC
:
197 dev_err(&vscsi
->dev
, "unregister_command_q: unknown error %ld from h_free_crq\n",
204 * dont wait more then 300 seconds
205 * ticks are in milliseconds more or less
207 if (ticks
> 300000 && qrc
!= H_SUCCESS
) {
209 dev_err(&vscsi
->dev
, "Excessive wait for h_free_crq\n");
211 } while (qrc
!= H_SUCCESS
&& rc
== ADAPT_SUCCESS
);
213 pr_debug("Freeing CRQ: phyp rc %ld, rc %ld\n", qrc
, rc
);
219 * ibmvscsis_delete_client_info() - Helper function to Delete Client Info
220 * @vscsi: Pointer to our adapter structure
221 * @client_closed: True if client closed its queue
223 * Deletes information specific to the client when the client goes away
225 * EXECUTION ENVIRONMENT:
226 * Interrupt or Process
228 static void ibmvscsis_delete_client_info(struct scsi_info
*vscsi
,
231 vscsi
->client_cap
= 0;
234 * Some things we don't want to clear if we're closing the queue,
235 * because some clients don't resend the host handshake when they
236 * get a transport event.
239 vscsi
->client_data
.os_type
= 0;
243 * ibmvscsis_free_command_q() - Free Command Queue
244 * @vscsi: Pointer to our adapter structure
246 * This function calls unregister_command_q, then clears interrupts and
247 * any pending interrupt acknowledgments associated with the command q.
248 * It also clears memory if there is no error.
250 * PHYP did not meet the PAPR architecture so that we must give up the
251 * lock. This causes a timing hole regarding state change. To close the
252 * hole this routine does accounting on any change that occurred during
253 * the time the lock is not held.
254 * NOTE: must give up and then acquire the interrupt lock, the caller must
255 * make sure that state and or flags will prevent interrupt handler from
258 * EXECUTION ENVIRONMENT:
259 * Process level, interrupt lock is held
261 static long ibmvscsis_free_command_q(struct scsi_info
*vscsi
)
264 u32 flags_under_lock
;
265 u16 state_under_lock
;
266 long rc
= ADAPT_SUCCESS
;
268 if (!(vscsi
->flags
& CRQ_CLOSED
)) {
269 vio_disable_interrupts(vscsi
->dma_dev
);
271 state_under_lock
= vscsi
->new_state
;
272 flags_under_lock
= vscsi
->flags
;
273 vscsi
->phyp_acr_state
= 0;
274 vscsi
->phyp_acr_flags
= 0;
276 spin_unlock_bh(&vscsi
->intr_lock
);
277 rc
= ibmvscsis_unregister_command_q(vscsi
);
278 spin_lock_bh(&vscsi
->intr_lock
);
280 if (state_under_lock
!= vscsi
->new_state
)
281 vscsi
->phyp_acr_state
= vscsi
->new_state
;
283 vscsi
->phyp_acr_flags
= ((~flags_under_lock
) & vscsi
->flags
);
285 if (rc
== ADAPT_SUCCESS
) {
286 bytes
= vscsi
->cmd_q
.size
* PAGE_SIZE
;
287 memset(vscsi
->cmd_q
.base_addr
, 0, bytes
);
288 vscsi
->cmd_q
.index
= 0;
289 vscsi
->flags
|= CRQ_CLOSED
;
291 ibmvscsis_delete_client_info(vscsi
, false);
294 pr_debug("free_command_q: flags 0x%x, state 0x%hx, acr_flags 0x%x, acr_state 0x%hx\n",
295 vscsi
->flags
, vscsi
->state
, vscsi
->phyp_acr_flags
,
296 vscsi
->phyp_acr_state
);
302 * ibmvscsis_cmd_q_dequeue() - Get valid Command element
303 * @mask: Mask to use in case index wraps
304 * @current_index: Current index into command queue
305 * @base_addr: Pointer to start of command queue
307 * Returns a pointer to a valid command element or NULL, if the command
310 * EXECUTION ENVIRONMENT:
311 * Interrupt environment, interrupt lock held
313 static struct viosrp_crq
*ibmvscsis_cmd_q_dequeue(uint mask
,
315 struct viosrp_crq
*base_addr
)
317 struct viosrp_crq
*ptr
;
319 ptr
= base_addr
+ *current_index
;
322 *current_index
= (*current_index
+ 1) & mask
;
332 * ibmvscsis_send_init_message() - send initialize message to the client
333 * @vscsi: Pointer to our adapter structure
334 * @format: Which Init Message format to send
336 * EXECUTION ENVIRONMENT:
337 * Interrupt environment interrupt lock held
339 static long ibmvscsis_send_init_message(struct scsi_info
*vscsi
, u8 format
)
341 struct viosrp_crq
*crq
;
342 u64 buffer
[2] = { 0, 0 };
345 crq
= (struct viosrp_crq
*)&buffer
;
346 crq
->valid
= VALID_INIT_MSG
;
347 crq
->format
= format
;
348 rc
= h_send_crq(vscsi
->dds
.unit_id
, cpu_to_be64(buffer
[MSG_HI
]),
349 cpu_to_be64(buffer
[MSG_LOW
]));
355 * ibmvscsis_check_init_msg() - Check init message valid
356 * @vscsi: Pointer to our adapter structure
357 * @format: Pointer to return format of Init Message, if any.
358 * Set to UNUSED_FORMAT if no Init Message in queue.
360 * Checks if an initialize message was queued by the initiatior
361 * after the queue was created and before the interrupt was enabled.
363 * EXECUTION ENVIRONMENT:
364 * Process level only, interrupt lock held
366 static long ibmvscsis_check_init_msg(struct scsi_info
*vscsi
, uint
*format
)
368 struct viosrp_crq
*crq
;
369 long rc
= ADAPT_SUCCESS
;
371 crq
= ibmvscsis_cmd_q_dequeue(vscsi
->cmd_q
.mask
, &vscsi
->cmd_q
.index
,
372 vscsi
->cmd_q
.base_addr
);
374 *format
= (uint
)UNUSED_FORMAT
;
375 } else if (crq
->valid
== VALID_INIT_MSG
&& crq
->format
== INIT_MSG
) {
376 *format
= (uint
)INIT_MSG
;
377 crq
->valid
= INVALIDATE_CMD_RESP_EL
;
381 * the caller has ensured no initialize message was
382 * sent after the queue was
383 * created so there should be no other message on the queue.
385 crq
= ibmvscsis_cmd_q_dequeue(vscsi
->cmd_q
.mask
,
387 vscsi
->cmd_q
.base_addr
);
389 *format
= (uint
)(crq
->format
);
391 crq
->valid
= INVALIDATE_CMD_RESP_EL
;
395 *format
= (uint
)(crq
->format
);
397 crq
->valid
= INVALIDATE_CMD_RESP_EL
;
405 * ibmvscsis_disconnect() - Helper function to disconnect
406 * @work: Pointer to work_struct, gives access to our adapter structure
408 * An error has occurred or the driver received a Transport event,
409 * and the driver is requesting that the command queue be de-registered
410 * in a safe manner. If there is no outstanding I/O then we can stop the
411 * queue. If we are restarting the queue it will be reflected in the
412 * the state of the adapter.
414 * EXECUTION ENVIRONMENT:
415 * Process environment
417 static void ibmvscsis_disconnect(struct work_struct
*work
)
419 struct scsi_info
*vscsi
= container_of(work
, struct scsi_info
,
422 bool wait_idle
= false;
424 spin_lock_bh(&vscsi
->intr_lock
);
425 new_state
= vscsi
->new_state
;
426 vscsi
->new_state
= 0;
428 vscsi
->flags
|= DISCONNECT_SCHEDULED
;
429 vscsi
->flags
&= ~SCHEDULE_DISCONNECT
;
431 pr_debug("disconnect: flags 0x%x, state 0x%hx\n", vscsi
->flags
,
435 * check which state we are in and see if we
436 * should transitition to the new state
438 switch (vscsi
->state
) {
439 /* Should never be called while in this state. */
442 * Can never transition from this state;
443 * igonore errors and logout.
448 /* can transition from this state to UNCONFIGURING */
450 if (new_state
== UNCONFIGURING
)
451 vscsi
->state
= new_state
;
455 * Can transition from this state to to unconfiguring
458 case ERR_DISCONNECT_RECONNECT
:
462 vscsi
->state
= new_state
;
472 /* can transition from this state to UNCONFIGURING */
473 case ERR_DISCONNECTED
:
474 if (new_state
== UNCONFIGURING
)
475 vscsi
->state
= new_state
;
481 vscsi
->state
= new_state
;
482 vscsi
->flags
|= RESPONSE_Q_DOWN
;
483 vscsi
->flags
&= ~(SCHEDULE_DISCONNECT
|
484 DISCONNECT_SCHEDULED
);
486 if (vscsi
->flags
& CFG_SLEEPING
) {
487 vscsi
->flags
&= ~CFG_SLEEPING
;
488 complete(&vscsi
->unconfig
);
492 /* should never happen */
494 case ERR_DISCONNECT_RECONNECT
:
496 dev_err(&vscsi
->dev
, "disconnect: invalid state %d for WAIT_IDLE\n",
505 vscsi
->flags
|= RESPONSE_Q_DOWN
;
506 vscsi
->state
= new_state
;
507 vscsi
->flags
&= ~(SCHEDULE_DISCONNECT
|
508 DISCONNECT_SCHEDULED
);
509 ibmvscsis_free_command_q(vscsi
);
512 case ERR_DISCONNECT_RECONNECT
:
513 vscsi
->state
= new_state
;
519 * Initiator has not done a successful srp login
520 * or has done a successful srp logout ( adapter was not
521 * busy). In the first case there can be responses queued
522 * waiting for space on the initiators response queue (MAD)
523 * The second case the adapter is idle. Assume the worse case,
524 * i.e. the second case.
526 case WAIT_CONNECTION
:
530 vscsi
->state
= new_state
;
533 /* can transition from this state to UNCONFIGURING */
535 if (new_state
== UNCONFIGURING
)
536 vscsi
->state
= new_state
;
543 pr_debug("disconnect start wait, active %d, sched %d\n",
544 (int)list_empty(&vscsi
->active_q
),
545 (int)list_empty(&vscsi
->schedule_q
));
546 if (!list_empty(&vscsi
->active_q
) ||
547 !list_empty(&vscsi
->schedule_q
)) {
548 vscsi
->flags
|= WAIT_FOR_IDLE
;
549 pr_debug("disconnect flags 0x%x\n", vscsi
->flags
);
551 * This routine is can not be called with the interrupt
554 spin_unlock_bh(&vscsi
->intr_lock
);
555 wait_for_completion(&vscsi
->wait_idle
);
556 spin_lock_bh(&vscsi
->intr_lock
);
558 pr_debug("disconnect stop wait\n");
560 ibmvscsis_adapter_idle(vscsi
);
563 spin_unlock_bh(&vscsi
->intr_lock
);
567 * ibmvscsis_post_disconnect() - Schedule the disconnect
568 * @vscsi: Pointer to our adapter structure
569 * @new_state: State to move to after disconnecting
570 * @flag_bits: Flags to turn on in adapter structure
572 * If it's already been scheduled, then see if we need to "upgrade"
573 * the new state (if the one passed in is more "severe" than the
577 * interrupt lock is held
579 static void ibmvscsis_post_disconnect(struct scsi_info
*vscsi
, uint new_state
,
584 /* check the validity of the new state */
588 case ERR_DISCONNECT_RECONNECT
:
593 dev_err(&vscsi
->dev
, "post_disconnect: Invalid new state %d\n",
598 vscsi
->flags
|= flag_bits
;
600 pr_debug("post_disconnect: new_state 0x%x, flag_bits 0x%x, vscsi->flags 0x%x, state %hx\n",
601 new_state
, flag_bits
, vscsi
->flags
, vscsi
->state
);
603 if (!(vscsi
->flags
& (DISCONNECT_SCHEDULED
| SCHEDULE_DISCONNECT
))) {
604 vscsi
->flags
|= SCHEDULE_DISCONNECT
;
605 vscsi
->new_state
= new_state
;
607 INIT_WORK(&vscsi
->proc_work
, ibmvscsis_disconnect
);
608 (void)queue_work(vscsi
->work_q
, &vscsi
->proc_work
);
610 if (vscsi
->new_state
)
611 state
= vscsi
->new_state
;
613 state
= vscsi
->state
;
620 case ERR_DISCONNECTED
:
623 if (new_state
== UNCONFIGURING
)
624 vscsi
->new_state
= new_state
;
627 case ERR_DISCONNECT_RECONNECT
:
631 vscsi
->new_state
= new_state
;
640 case WAIT_CONNECTION
:
643 vscsi
->new_state
= new_state
;
651 pr_debug("Leaving post_disconnect: flags 0x%x, new_state 0x%x\n",
652 vscsi
->flags
, vscsi
->new_state
);
656 * ibmvscsis_handle_init_compl_msg() - Respond to an Init Complete Message
657 * @vscsi: Pointer to our adapter structure
659 * Must be called with interrupt lock held.
661 static long ibmvscsis_handle_init_compl_msg(struct scsi_info
*vscsi
)
663 long rc
= ADAPT_SUCCESS
;
665 switch (vscsi
->state
) {
668 case ERR_DISCONNECT_RECONNECT
:
669 case ERR_DISCONNECTED
:
675 case WAIT_CONNECTION
:
676 vscsi
->state
= CONNECTED
;
685 dev_err(&vscsi
->dev
, "init_msg: invalid state %d to get init compl msg\n",
687 ibmvscsis_post_disconnect(vscsi
, ERR_DISCONNECT_RECONNECT
, 0);
695 * ibmvscsis_handle_init_msg() - Respond to an Init Message
696 * @vscsi: Pointer to our adapter structure
698 * Must be called with interrupt lock held.
700 static long ibmvscsis_handle_init_msg(struct scsi_info
*vscsi
)
702 long rc
= ADAPT_SUCCESS
;
704 switch (vscsi
->state
) {
705 case WAIT_CONNECTION
:
706 rc
= ibmvscsis_send_init_message(vscsi
, INIT_COMPLETE_MSG
);
709 vscsi
->state
= CONNECTED
;
713 dev_err(&vscsi
->dev
, "init_msg: failed to send, rc %ld\n",
715 ibmvscsis_post_disconnect(vscsi
, ERR_DISCONNECT
, 0);
719 dev_err(&vscsi
->dev
, "init_msg: failed to send, rc %ld\n",
722 ibmvscsis_post_disconnect(vscsi
,
723 ERR_DISCONNECT_RECONNECT
, 0);
727 pr_warn("init_msg: failed to send, rc %ld\n", rc
);
746 case ERR_DISCONNECT_RECONNECT
:
747 case ERR_DISCONNECTED
:
750 dev_err(&vscsi
->dev
, "init_msg: invalid state %d to get init msg\n",
752 ibmvscsis_post_disconnect(vscsi
, ERR_DISCONNECT_RECONNECT
, 0);
760 * ibmvscsis_init_msg() - Respond to an init message
761 * @vscsi: Pointer to our adapter structure
762 * @crq: Pointer to CRQ element containing the Init Message
764 * EXECUTION ENVIRONMENT:
765 * Interrupt, interrupt lock held
767 static long ibmvscsis_init_msg(struct scsi_info
*vscsi
, struct viosrp_crq
*crq
)
769 long rc
= ADAPT_SUCCESS
;
771 pr_debug("init_msg: state 0x%hx\n", vscsi
->state
);
773 rc
= h_vioctl(vscsi
->dds
.unit_id
, H_GET_PARTNER_INFO
,
774 (u64
)vscsi
->map_ioba
| ((u64
)PAGE_SIZE
<< 32), 0, 0, 0,
776 if (rc
== H_SUCCESS
) {
777 vscsi
->client_data
.partition_number
=
778 be64_to_cpu(*(u64
*)vscsi
->map_buf
);
779 pr_debug("init_msg, part num %d\n",
780 vscsi
->client_data
.partition_number
);
782 pr_debug("init_msg h_vioctl rc %ld\n", rc
);
786 if (crq
->format
== INIT_MSG
) {
787 rc
= ibmvscsis_handle_init_msg(vscsi
);
788 } else if (crq
->format
== INIT_COMPLETE_MSG
) {
789 rc
= ibmvscsis_handle_init_compl_msg(vscsi
);
792 dev_err(&vscsi
->dev
, "init_msg: invalid format %d\n",
794 ibmvscsis_post_disconnect(vscsi
, ERR_DISCONNECT_RECONNECT
, 0);
801 * ibmvscsis_establish_new_q() - Establish new CRQ queue
802 * @vscsi: Pointer to our adapter structure
804 * Must be called with interrupt lock held.
806 static long ibmvscsis_establish_new_q(struct scsi_info
*vscsi
)
808 long rc
= ADAPT_SUCCESS
;
811 rc
= h_vioctl(vscsi
->dds
.unit_id
, H_ENABLE_PREPARE_FOR_SUSPEND
, 30000,
814 vscsi
->flags
|= PREP_FOR_SUSPEND_ENABLED
;
815 else if (rc
!= H_NOT_FOUND
)
816 pr_err("Error from Enable Prepare for Suspend: %ld\n", rc
);
818 vscsi
->flags
&= PRESERVE_FLAG_FIELDS
;
819 vscsi
->rsp_q_timer
.timer_pops
= 0;
823 rc
= vio_enable_interrupts(vscsi
->dma_dev
);
825 pr_warn("establish_new_q: failed to enable interrupts, rc %ld\n",
830 rc
= ibmvscsis_check_init_msg(vscsi
, &format
);
832 dev_err(&vscsi
->dev
, "establish_new_q: check_init_msg failed, rc %ld\n",
837 if (format
== UNUSED_FORMAT
) {
838 rc
= ibmvscsis_send_init_message(vscsi
, INIT_MSG
);
851 vscsi
->state
= UNDEFINED
;
855 } else if (format
== INIT_MSG
) {
856 rc
= ibmvscsis_handle_init_msg(vscsi
);
863 * ibmvscsis_reset_queue() - Reset CRQ Queue
864 * @vscsi: Pointer to our adapter structure
866 * This function calls h_free_q and then calls h_reg_q and does all
867 * of the bookkeeping to get us back to where we can communicate.
869 * Actually, we don't always call h_free_crq. A problem was discovered
870 * where one partition would close and reopen his queue, which would
871 * cause his partner to get a transport event, which would cause him to
872 * close and reopen his queue, which would cause the original partition
873 * to get a transport event, etc., etc. To prevent this, we don't
874 * actually close our queue if the client initiated the reset, (i.e.
875 * either we got a transport event or we have detected that the client's
878 * EXECUTION ENVIRONMENT:
879 * Process environment, called with interrupt lock held
881 static void ibmvscsis_reset_queue(struct scsi_info
*vscsi
)
884 long rc
= ADAPT_SUCCESS
;
886 pr_debug("reset_queue: flags 0x%x\n", vscsi
->flags
);
888 /* don't reset, the client did it for us */
889 if (vscsi
->flags
& (CLIENT_FAILED
| TRANS_EVENT
)) {
890 vscsi
->flags
&= PRESERVE_FLAG_FIELDS
;
891 vscsi
->rsp_q_timer
.timer_pops
= 0;
894 vscsi
->state
= WAIT_CONNECTION
;
895 vio_enable_interrupts(vscsi
->dma_dev
);
897 rc
= ibmvscsis_free_command_q(vscsi
);
898 if (rc
== ADAPT_SUCCESS
) {
899 vscsi
->state
= WAIT_CONNECTION
;
901 bytes
= vscsi
->cmd_q
.size
* PAGE_SIZE
;
902 rc
= h_reg_crq(vscsi
->dds
.unit_id
,
903 vscsi
->cmd_q
.crq_token
, bytes
);
904 if (rc
== H_CLOSED
|| rc
== H_SUCCESS
) {
905 rc
= ibmvscsis_establish_new_q(vscsi
);
908 if (rc
!= ADAPT_SUCCESS
) {
909 pr_debug("reset_queue: reg_crq rc %ld\n", rc
);
911 vscsi
->state
= ERR_DISCONNECTED
;
912 vscsi
->flags
|= RESPONSE_Q_DOWN
;
913 ibmvscsis_free_command_q(vscsi
);
916 vscsi
->state
= ERR_DISCONNECTED
;
917 vscsi
->flags
|= RESPONSE_Q_DOWN
;
923 * ibmvscsis_free_cmd_resources() - Free command resources
924 * @vscsi: Pointer to our adapter structure
925 * @cmd: Command which is not longer in use
927 * Must be called with interrupt lock held.
929 static void ibmvscsis_free_cmd_resources(struct scsi_info
*vscsi
,
930 struct ibmvscsis_cmd
*cmd
)
932 struct iu_entry
*iue
= cmd
->iue
;
935 case TASK_MANAGEMENT
:
938 * When the queue goes down this value is cleared, so it
939 * cannot be cleared in this general purpose function.
945 vscsi
->flags
&= ~PROCESSING_MAD
;
950 dev_err(&vscsi
->dev
, "free_cmd_resources unknown type %d\n",
956 list_add_tail(&cmd
->list
, &vscsi
->free_cmd
);
959 if (list_empty(&vscsi
->active_q
) && list_empty(&vscsi
->schedule_q
) &&
960 list_empty(&vscsi
->waiting_rsp
) && (vscsi
->flags
& WAIT_FOR_IDLE
)) {
961 vscsi
->flags
&= ~WAIT_FOR_IDLE
;
962 complete(&vscsi
->wait_idle
);
967 * ibmvscsis_ready_for_suspend() - Helper function to call VIOCTL
968 * @vscsi: Pointer to our adapter structure
969 * @idle: Indicates whether we were called from adapter_idle. This
970 * is important to know if we need to do a disconnect, since if
971 * we're called from adapter_idle, we're still processing the
972 * current disconnect, so we can't just call post_disconnect.
974 * This function is called when the adapter is idle when phyp has sent
975 * us a Prepare for Suspend Transport Event.
977 * EXECUTION ENVIRONMENT:
978 * Process or interrupt environment called with interrupt lock held
980 static long ibmvscsis_ready_for_suspend(struct scsi_info
*vscsi
, bool idle
)
983 struct viosrp_crq
*crq
;
985 /* See if there is a Resume event in the queue */
986 crq
= vscsi
->cmd_q
.base_addr
+ vscsi
->cmd_q
.index
;
988 pr_debug("ready_suspend: flags 0x%x, state 0x%hx crq_valid:%x\n",
989 vscsi
->flags
, vscsi
->state
, (int)crq
->valid
);
991 if (!(vscsi
->flags
& PREP_FOR_SUSPEND_ABORTED
) && !(crq
->valid
)) {
992 rc
= h_vioctl(vscsi
->dds
.unit_id
, H_READY_FOR_SUSPEND
, 0, 0, 0,
995 pr_err("Ready for Suspend Vioctl failed: %ld\n", rc
);
998 } else if (((vscsi
->flags
& PREP_FOR_SUSPEND_OVERWRITE
) &&
999 (vscsi
->flags
& PREP_FOR_SUSPEND_ABORTED
)) ||
1000 ((crq
->valid
) && ((crq
->valid
!= VALID_TRANS_EVENT
) ||
1001 (crq
->format
!= RESUME_FROM_SUSP
)))) {
1003 vscsi
->state
= ERR_DISCONNECT_RECONNECT
;
1004 ibmvscsis_reset_queue(vscsi
);
1006 } else if (vscsi
->state
== CONNECTED
) {
1007 ibmvscsis_post_disconnect(vscsi
,
1008 ERR_DISCONNECT_RECONNECT
, 0);
1011 vscsi
->flags
&= ~PREP_FOR_SUSPEND_OVERWRITE
;
1013 if ((crq
->valid
) && ((crq
->valid
!= VALID_TRANS_EVENT
) ||
1014 (crq
->format
!= RESUME_FROM_SUSP
)))
1015 pr_err("Invalid element in CRQ after Prepare for Suspend");
1018 vscsi
->flags
&= ~(PREP_FOR_SUSPEND_PENDING
| PREP_FOR_SUSPEND_ABORTED
);
1024 * ibmvscsis_trans_event() - Handle a Transport Event
1025 * @vscsi: Pointer to our adapter structure
1026 * @crq: Pointer to CRQ entry containing the Transport Event
1028 * Do the logic to close the I_T nexus. This function may not
1029 * behave to specification.
1031 * EXECUTION ENVIRONMENT:
1032 * Interrupt, interrupt lock held
1034 static long ibmvscsis_trans_event(struct scsi_info
*vscsi
,
1035 struct viosrp_crq
*crq
)
1037 long rc
= ADAPT_SUCCESS
;
1039 pr_debug("trans_event: format %d, flags 0x%x, state 0x%hx\n",
1040 (int)crq
->format
, vscsi
->flags
, vscsi
->state
);
1042 switch (crq
->format
) {
1044 case PARTNER_FAILED
:
1045 case PARTNER_DEREGISTER
:
1046 ibmvscsis_delete_client_info(vscsi
, true);
1047 if (crq
->format
== MIGRATED
)
1048 vscsi
->flags
&= ~PREP_FOR_SUSPEND_OVERWRITE
;
1049 switch (vscsi
->state
) {
1051 case ERR_DISCONNECTED
:
1056 vscsi
->flags
|= (RESPONSE_Q_DOWN
| TRANS_EVENT
);
1062 case WAIT_CONNECTION
:
1066 ibmvscsis_post_disconnect(vscsi
, WAIT_IDLE
,
1071 case SRP_PROCESSING
:
1072 if ((vscsi
->debit
> 0) ||
1073 !list_empty(&vscsi
->schedule_q
) ||
1074 !list_empty(&vscsi
->waiting_rsp
) ||
1075 !list_empty(&vscsi
->active_q
)) {
1076 pr_debug("debit %d, sched %d, wait %d, active %d\n",
1078 (int)list_empty(&vscsi
->schedule_q
),
1079 (int)list_empty(&vscsi
->waiting_rsp
),
1080 (int)list_empty(&vscsi
->active_q
));
1081 pr_warn("connection lost with outstanding work\n");
1083 pr_debug("trans_event: SRP Processing, but no outstanding work\n");
1086 ibmvscsis_post_disconnect(vscsi
, WAIT_IDLE
,
1091 case ERR_DISCONNECT
:
1092 case ERR_DISCONNECT_RECONNECT
:
1094 vscsi
->flags
|= (RESPONSE_Q_DOWN
| TRANS_EVENT
);
1099 case PREPARE_FOR_SUSPEND
:
1100 pr_debug("Prep for Suspend, crq status = 0x%x\n",
1102 switch (vscsi
->state
) {
1103 case ERR_DISCONNECTED
:
1104 case WAIT_CONNECTION
:
1106 ibmvscsis_ready_for_suspend(vscsi
, false);
1108 case SRP_PROCESSING
:
1109 vscsi
->resume_state
= vscsi
->state
;
1110 vscsi
->flags
|= PREP_FOR_SUSPEND_PENDING
;
1111 if (crq
->status
== CRQ_ENTRY_OVERWRITTEN
)
1112 vscsi
->flags
|= PREP_FOR_SUSPEND_OVERWRITE
;
1113 ibmvscsis_post_disconnect(vscsi
, WAIT_IDLE
, 0);
1119 case ERR_DISCONNECT
:
1120 case ERR_DISCONNECT_RECONNECT
:
1122 pr_err("Invalid state for Prepare for Suspend Trans Event: 0x%x\n",
1128 case RESUME_FROM_SUSP
:
1129 pr_debug("Resume from Suspend, crq status = 0x%x\n",
1131 if (vscsi
->flags
& PREP_FOR_SUSPEND_PENDING
) {
1132 vscsi
->flags
|= PREP_FOR_SUSPEND_ABORTED
;
1134 if ((crq
->status
== CRQ_ENTRY_OVERWRITTEN
) ||
1135 (vscsi
->flags
& PREP_FOR_SUSPEND_OVERWRITE
)) {
1136 ibmvscsis_post_disconnect(vscsi
,
1137 ERR_DISCONNECT_RECONNECT
,
1139 vscsi
->flags
&= ~PREP_FOR_SUSPEND_OVERWRITE
;
1146 dev_err(&vscsi
->dev
, "trans_event: invalid format %d\n",
1148 ibmvscsis_post_disconnect(vscsi
, ERR_DISCONNECT
,
1153 rc
= vscsi
->flags
& SCHEDULE_DISCONNECT
;
1155 pr_debug("Leaving trans_event: flags 0x%x, state 0x%hx, rc %ld\n",
1156 vscsi
->flags
, vscsi
->state
, rc
);
1162 * ibmvscsis_poll_cmd_q() - Poll Command Queue
1163 * @vscsi: Pointer to our adapter structure
1165 * Called to handle command elements that may have arrived while
1166 * interrupts were disabled.
1168 * EXECUTION ENVIRONMENT:
1169 * intr_lock must be held
1171 static void ibmvscsis_poll_cmd_q(struct scsi_info
*vscsi
)
1173 struct viosrp_crq
*crq
;
1178 pr_debug("poll_cmd_q: flags 0x%x, state 0x%hx, q index %ud\n",
1179 vscsi
->flags
, vscsi
->state
, vscsi
->cmd_q
.index
);
1181 rc
= vscsi
->flags
& SCHEDULE_DISCONNECT
;
1182 crq
= vscsi
->cmd_q
.base_addr
+ vscsi
->cmd_q
.index
;
1188 vscsi
->cmd_q
.index
=
1189 (vscsi
->cmd_q
.index
+ 1) & vscsi
->cmd_q
.mask
;
1192 rc
= ibmvscsis_parse_command(vscsi
, crq
);
1194 if ((uint
)crq
->valid
== VALID_TRANS_EVENT
) {
1196 * must service the transport layer events even
1197 * in an error state, dont break out until all
1198 * the consecutive transport events have been
1201 rc
= ibmvscsis_trans_event(vscsi
, crq
);
1202 } else if (vscsi
->flags
& TRANS_EVENT
) {
1204 * if a tranport event has occurred leave
1205 * everything but transport events on the queue
1207 pr_debug("poll_cmd_q, ignoring\n");
1210 * need to decrement the queue index so we can
1211 * look at the elment again
1213 if (vscsi
->cmd_q
.index
)
1214 vscsi
->cmd_q
.index
-= 1;
1217 * index is at 0 it just wrapped.
1218 * have it index last element in q
1220 vscsi
->cmd_q
.index
= vscsi
->cmd_q
.mask
;
1225 crq
->valid
= INVALIDATE_CMD_RESP_EL
;
1227 crq
= vscsi
->cmd_q
.base_addr
+ vscsi
->cmd_q
.index
;
1234 vio_enable_interrupts(vscsi
->dma_dev
);
1236 pr_debug("poll_cmd_q, reenabling interrupts\n");
1244 pr_debug("Leaving poll_cmd_q: rc %ld\n", rc
);
1248 * ibmvscsis_free_cmd_qs() - Free elements in queue
1249 * @vscsi: Pointer to our adapter structure
1251 * Free all of the elements on all queues that are waiting for
1255 * Called with interrupt lock held
1257 static void ibmvscsis_free_cmd_qs(struct scsi_info
*vscsi
)
1259 struct ibmvscsis_cmd
*cmd
, *nxt
;
1261 pr_debug("free_cmd_qs: waiting_rsp empty %d, timer starter %d\n",
1262 (int)list_empty(&vscsi
->waiting_rsp
),
1263 vscsi
->rsp_q_timer
.started
);
1265 list_for_each_entry_safe(cmd
, nxt
, &vscsi
->waiting_rsp
, list
) {
1266 list_del(&cmd
->list
);
1267 ibmvscsis_free_cmd_resources(vscsi
, cmd
);
1272 * ibmvscsis_get_free_cmd() - Get free command from list
1273 * @vscsi: Pointer to our adapter structure
1275 * Must be called with interrupt lock held.
1277 static struct ibmvscsis_cmd
*ibmvscsis_get_free_cmd(struct scsi_info
*vscsi
)
1279 struct ibmvscsis_cmd
*cmd
= NULL
;
1280 struct iu_entry
*iue
;
1282 iue
= srp_iu_get(&vscsi
->target
);
1284 cmd
= list_first_entry_or_null(&vscsi
->free_cmd
,
1285 struct ibmvscsis_cmd
, list
);
1288 cmd
->abort_cmd
= NULL
;
1289 cmd
->flags
&= ~(DELAY_SEND
);
1290 list_del(&cmd
->list
);
1292 cmd
->type
= UNSET_TYPE
;
1293 memset(&cmd
->se_cmd
, 0, sizeof(cmd
->se_cmd
));
1303 * ibmvscsis_adapter_idle() - Helper function to handle idle adapter
1304 * @vscsi: Pointer to our adapter structure
1306 * This function is called when the adapter is idle when the driver
1307 * is attempting to clear an error condition.
1308 * The adapter is considered busy if any of its cmd queues
1309 * are non-empty. This function can be invoked
1310 * from the off level disconnect function.
1312 * EXECUTION ENVIRONMENT:
1313 * Process environment called with interrupt lock held
1315 static void ibmvscsis_adapter_idle(struct scsi_info
*vscsi
)
1317 int free_qs
= false;
1320 pr_debug("adapter_idle: flags 0x%x, state 0x%hx\n", vscsi
->flags
,
1323 /* Only need to free qs if we're disconnecting from client */
1324 if (vscsi
->state
!= WAIT_CONNECTION
|| vscsi
->flags
& TRANS_EVENT
)
1327 switch (vscsi
->state
) {
1329 ibmvscsis_free_command_q(vscsi
);
1332 if (vscsi
->flags
& CFG_SLEEPING
) {
1333 vscsi
->flags
&= ~CFG_SLEEPING
;
1334 complete(&vscsi
->unconfig
);
1337 case ERR_DISCONNECT_RECONNECT
:
1338 ibmvscsis_reset_queue(vscsi
);
1339 pr_debug("adapter_idle, disc_rec: flags 0x%x\n", vscsi
->flags
);
1342 case ERR_DISCONNECT
:
1343 ibmvscsis_free_command_q(vscsi
);
1344 vscsi
->flags
&= ~(SCHEDULE_DISCONNECT
| DISCONNECT_SCHEDULED
);
1345 vscsi
->flags
|= RESPONSE_Q_DOWN
;
1346 if (vscsi
->tport
.enabled
)
1347 vscsi
->state
= ERR_DISCONNECTED
;
1349 vscsi
->state
= WAIT_ENABLED
;
1350 pr_debug("adapter_idle, disc: flags 0x%x, state 0x%hx\n",
1351 vscsi
->flags
, vscsi
->state
);
1355 vscsi
->rsp_q_timer
.timer_pops
= 0;
1358 if (vscsi
->flags
& PREP_FOR_SUSPEND_PENDING
) {
1359 vscsi
->state
= vscsi
->resume_state
;
1360 vscsi
->resume_state
= 0;
1361 rc
= ibmvscsis_ready_for_suspend(vscsi
, true);
1362 vscsi
->flags
&= ~DISCONNECT_SCHEDULED
;
1365 } else if (vscsi
->flags
& TRANS_EVENT
) {
1366 vscsi
->state
= WAIT_CONNECTION
;
1367 vscsi
->flags
&= PRESERVE_FLAG_FIELDS
;
1369 vscsi
->state
= CONNECTED
;
1370 vscsi
->flags
&= ~DISCONNECT_SCHEDULED
;
1373 pr_debug("adapter_idle, wait: flags 0x%x, state 0x%hx\n",
1374 vscsi
->flags
, vscsi
->state
);
1375 ibmvscsis_poll_cmd_q(vscsi
);
1378 case ERR_DISCONNECTED
:
1379 vscsi
->flags
&= ~DISCONNECT_SCHEDULED
;
1380 pr_debug("adapter_idle, disconnected: flags 0x%x, state 0x%hx\n",
1381 vscsi
->flags
, vscsi
->state
);
1385 dev_err(&vscsi
->dev
, "adapter_idle: in invalid state %d\n",
1391 ibmvscsis_free_cmd_qs(vscsi
);
1394 * There is a timing window where we could lose a disconnect request.
1395 * The known path to this window occurs during the DISCONNECT_RECONNECT
1396 * case above: reset_queue calls free_command_q, which will release the
1397 * interrupt lock. During that time, a new post_disconnect call can be
1398 * made with a "more severe" state (DISCONNECT or UNCONFIGURING).
1399 * Because the DISCONNECT_SCHEDULED flag is already set, post_disconnect
1400 * will only set the new_state. Now free_command_q reacquires the intr
1401 * lock and clears the DISCONNECT_SCHEDULED flag (using PRESERVE_FLAG_
1402 * FIELDS), and the disconnect is lost. This is particularly bad when
1403 * the new disconnect was for UNCONFIGURING, since the unconfigure hangs
1405 * Fix is that free command queue sets acr state and acr flags if there
1406 * is a change under the lock
1407 * note free command queue writes to this state it clears it
1408 * before releasing the lock, different drivers call the free command
1409 * queue different times so dont initialize above
1411 if (vscsi
->phyp_acr_state
!= 0) {
1413 * set any bits in flags that may have been cleared by
1414 * a call to free command queue in switch statement
1417 vscsi
->flags
|= vscsi
->phyp_acr_flags
;
1418 ibmvscsis_post_disconnect(vscsi
, vscsi
->phyp_acr_state
, 0);
1419 vscsi
->phyp_acr_state
= 0;
1420 vscsi
->phyp_acr_flags
= 0;
1422 pr_debug("adapter_idle: flags 0x%x, state 0x%hx, acr_flags 0x%x, acr_state 0x%hx\n",
1423 vscsi
->flags
, vscsi
->state
, vscsi
->phyp_acr_flags
,
1424 vscsi
->phyp_acr_state
);
1427 pr_debug("Leaving adapter_idle: flags 0x%x, state 0x%hx, new_state 0x%x\n",
1428 vscsi
->flags
, vscsi
->state
, vscsi
->new_state
);
1432 * ibmvscsis_copy_crq_packet() - Copy CRQ Packet
1433 * @vscsi: Pointer to our adapter structure
1434 * @cmd: Pointer to command element to use to process the request
1435 * @crq: Pointer to CRQ entry containing the request
1437 * Copy the srp information unit from the hosted
1438 * partition using remote dma
1440 * EXECUTION ENVIRONMENT:
1441 * Interrupt, interrupt lock held
1443 static long ibmvscsis_copy_crq_packet(struct scsi_info
*vscsi
,
1444 struct ibmvscsis_cmd
*cmd
,
1445 struct viosrp_crq
*crq
)
1447 struct iu_entry
*iue
= cmd
->iue
;
1451 len
= be16_to_cpu(crq
->IU_length
);
1452 if ((len
> SRP_MAX_IU_LEN
) || (len
== 0)) {
1453 dev_err(&vscsi
->dev
, "copy_crq: Invalid len %d passed", len
);
1454 ibmvscsis_post_disconnect(vscsi
, ERR_DISCONNECT_RECONNECT
, 0);
1455 return SRP_VIOLATION
;
1458 rc
= h_copy_rdma(len
, vscsi
->dds
.window
[REMOTE
].liobn
,
1459 be64_to_cpu(crq
->IU_data_ptr
),
1460 vscsi
->dds
.window
[LOCAL
].liobn
, iue
->sbuf
->dma
);
1464 cmd
->init_time
= mftb();
1465 iue
->remote_token
= crq
->IU_data_ptr
;
1467 pr_debug("copy_crq: ioba 0x%llx, init_time 0x%llx\n",
1468 be64_to_cpu(crq
->IU_data_ptr
), cmd
->init_time
);
1471 if (connection_broken(vscsi
))
1472 ibmvscsis_post_disconnect(vscsi
,
1473 ERR_DISCONNECT_RECONNECT
,
1477 ibmvscsis_post_disconnect(vscsi
,
1478 ERR_DISCONNECT_RECONNECT
, 0);
1480 dev_err(&vscsi
->dev
, "copy_crq: h_copy_rdma failed, rc %ld\n",
1486 dev_err(&vscsi
->dev
, "copy_crq: h_copy_rdma failed, rc %ld\n",
1488 ibmvscsis_post_disconnect(vscsi
, ERR_DISCONNECT_RECONNECT
, 0);
1496 * ibmvscsis_adapter_info - Service an Adapter Info MAnagement Data gram
1497 * @vscsi: Pointer to our adapter structure
1498 * @iue: Information Unit containing the Adapter Info MAD request
1500 * EXECUTION ENVIRONMENT:
1501 * Interrupt adapter lock is held
1503 static long ibmvscsis_adapter_info(struct scsi_info
*vscsi
,
1504 struct iu_entry
*iue
)
1506 struct viosrp_adapter_info
*mad
= &vio_iu(iue
)->mad
.adapter_info
;
1507 struct mad_adapter_info_data
*info
;
1512 mad
->common
.status
= cpu_to_be16(VIOSRP_MAD_SUCCESS
);
1514 if (be16_to_cpu(mad
->common
.length
) > sizeof(*info
)) {
1515 mad
->common
.status
= cpu_to_be16(VIOSRP_MAD_FAILED
);
1519 info
= dma_alloc_coherent(&vscsi
->dma_dev
->dev
, sizeof(*info
), &token
,
1522 dev_err(&vscsi
->dev
, "bad dma_alloc_coherent %p\n",
1524 mad
->common
.status
= cpu_to_be16(VIOSRP_MAD_FAILED
);
1528 /* Get remote info */
1529 rc
= h_copy_rdma(be16_to_cpu(mad
->common
.length
),
1530 vscsi
->dds
.window
[REMOTE
].liobn
,
1531 be64_to_cpu(mad
->buffer
),
1532 vscsi
->dds
.window
[LOCAL
].liobn
, token
);
1534 if (rc
!= H_SUCCESS
) {
1535 if (rc
== H_PERMISSION
) {
1536 if (connection_broken(vscsi
))
1537 flag_bits
= (RESPONSE_Q_DOWN
| CLIENT_FAILED
);
1539 pr_warn("adapter_info: h_copy_rdma from client failed, rc %ld\n",
1541 pr_debug("adapter_info: ioba 0x%llx, flags 0x%x, flag_bits 0x%x\n",
1542 be64_to_cpu(mad
->buffer
), vscsi
->flags
, flag_bits
);
1543 ibmvscsis_post_disconnect(vscsi
, ERR_DISCONNECT_RECONNECT
,
1549 * Copy client info, but ignore partition number, which we
1550 * already got from phyp - unless we failed to get it from
1551 * phyp (e.g. if we're running on a p5 system).
1553 if (vscsi
->client_data
.partition_number
== 0)
1554 vscsi
->client_data
.partition_number
=
1555 be32_to_cpu(info
->partition_number
);
1556 strncpy(vscsi
->client_data
.srp_version
, info
->srp_version
,
1557 sizeof(vscsi
->client_data
.srp_version
));
1558 strncpy(vscsi
->client_data
.partition_name
, info
->partition_name
,
1559 sizeof(vscsi
->client_data
.partition_name
));
1560 vscsi
->client_data
.mad_version
= be32_to_cpu(info
->mad_version
);
1561 vscsi
->client_data
.os_type
= be32_to_cpu(info
->os_type
);
1564 strncpy(info
->srp_version
, SRP_VERSION
,
1565 sizeof(info
->srp_version
));
1566 strncpy(info
->partition_name
, vscsi
->dds
.partition_name
,
1567 sizeof(info
->partition_name
));
1568 info
->partition_number
= cpu_to_be32(vscsi
->dds
.partition_num
);
1569 info
->mad_version
= cpu_to_be32(MAD_VERSION_1
);
1570 info
->os_type
= cpu_to_be32(LINUX
);
1571 memset(&info
->port_max_txu
[0], 0, sizeof(info
->port_max_txu
));
1572 info
->port_max_txu
[0] = cpu_to_be32(MAX_TXU
);
1575 rc
= h_copy_rdma(sizeof(*info
), vscsi
->dds
.window
[LOCAL
].liobn
,
1576 token
, vscsi
->dds
.window
[REMOTE
].liobn
,
1577 be64_to_cpu(mad
->buffer
));
1585 if (connection_broken(vscsi
))
1586 flag_bits
= (RESPONSE_Q_DOWN
| CLIENT_FAILED
);
1588 dev_err(&vscsi
->dev
, "adapter_info: h_copy_rdma to client failed, rc %ld\n",
1590 ibmvscsis_post_disconnect(vscsi
,
1591 ERR_DISCONNECT_RECONNECT
,
1597 dma_free_coherent(&vscsi
->dma_dev
->dev
, sizeof(*info
), info
, token
);
1598 pr_debug("Leaving adapter_info, rc %ld\n", rc
);
1604 * ibmvscsis_cap_mad() - Service a Capabilities MAnagement Data gram
1605 * @vscsi: Pointer to our adapter structure
1606 * @iue: Information Unit containing the Capabilities MAD request
1608 * NOTE: if you return an error from this routine you must be
1609 * disconnecting or you will cause a hang
1611 * EXECUTION ENVIRONMENT:
1612 * Interrupt called with adapter lock held
1614 static int ibmvscsis_cap_mad(struct scsi_info
*vscsi
, struct iu_entry
*iue
)
1616 struct viosrp_capabilities
*mad
= &vio_iu(iue
)->mad
.capabilities
;
1617 struct capabilities
*cap
;
1618 struct mad_capability_common
*common
;
1620 u16 olen
, len
, status
, min_len
, cap_len
;
1625 olen
= be16_to_cpu(mad
->common
.length
);
1627 * struct capabilities hardcodes a couple capabilities after the
1628 * header, but the capabilities can actually be in any order.
1630 min_len
= offsetof(struct capabilities
, migration
);
1631 if ((olen
< min_len
) || (olen
> PAGE_SIZE
)) {
1632 pr_warn("cap_mad: invalid len %d\n", olen
);
1633 mad
->common
.status
= cpu_to_be16(VIOSRP_MAD_FAILED
);
1637 cap
= dma_alloc_coherent(&vscsi
->dma_dev
->dev
, olen
, &token
,
1640 dev_err(&vscsi
->dev
, "bad dma_alloc_coherent %p\n",
1642 mad
->common
.status
= cpu_to_be16(VIOSRP_MAD_FAILED
);
1645 rc
= h_copy_rdma(olen
, vscsi
->dds
.window
[REMOTE
].liobn
,
1646 be64_to_cpu(mad
->buffer
),
1647 vscsi
->dds
.window
[LOCAL
].liobn
, token
);
1648 if (rc
== H_SUCCESS
) {
1649 strncpy(cap
->name
, dev_name(&vscsi
->dma_dev
->dev
),
1652 len
= olen
- min_len
;
1653 status
= VIOSRP_MAD_SUCCESS
;
1654 common
= (struct mad_capability_common
*)&cap
->migration
;
1656 while ((len
> 0) && (status
== VIOSRP_MAD_SUCCESS
) && !rc
) {
1657 pr_debug("cap_mad: len left %hd, cap type %d, cap len %hd\n",
1658 len
, be32_to_cpu(common
->cap_type
),
1659 be16_to_cpu(common
->length
));
1661 cap_len
= be16_to_cpu(common
->length
);
1662 if (cap_len
> len
) {
1663 dev_err(&vscsi
->dev
, "cap_mad: cap len mismatch with total len\n");
1664 status
= VIOSRP_MAD_FAILED
;
1669 dev_err(&vscsi
->dev
, "cap_mad: cap len is 0\n");
1670 status
= VIOSRP_MAD_FAILED
;
1674 switch (common
->cap_type
) {
1676 pr_debug("cap_mad: unsupported capability\n");
1677 common
->server_support
= 0;
1678 flag
= cpu_to_be32((u32
)CAP_LIST_SUPPORTED
);
1679 cap
->flags
&= ~flag
;
1683 len
= len
- cap_len
;
1684 common
= (struct mad_capability_common
*)
1685 ((char *)common
+ cap_len
);
1688 mad
->common
.status
= cpu_to_be16(status
);
1691 rc
= h_copy_rdma(olen
, vscsi
->dds
.window
[LOCAL
].liobn
, token
,
1692 vscsi
->dds
.window
[REMOTE
].liobn
,
1693 be64_to_cpu(mad
->buffer
));
1695 if (rc
!= H_SUCCESS
) {
1696 pr_debug("cap_mad: failed to copy to client, rc %ld\n",
1699 if (rc
== H_PERMISSION
) {
1700 if (connection_broken(vscsi
))
1701 flag_bits
= (RESPONSE_Q_DOWN
|
1705 pr_warn("cap_mad: error copying data to client, rc %ld\n",
1707 ibmvscsis_post_disconnect(vscsi
,
1708 ERR_DISCONNECT_RECONNECT
,
1713 dma_free_coherent(&vscsi
->dma_dev
->dev
, olen
, cap
, token
);
1715 pr_debug("Leaving cap_mad, rc %ld, client_cap 0x%x\n",
1716 rc
, vscsi
->client_cap
);
1722 * ibmvscsis_process_mad() - Service a MAnagement Data gram
1723 * @vscsi: Pointer to our adapter structure
1724 * @iue: Information Unit containing the MAD request
1726 * Must be called with interrupt lock held.
1728 static long ibmvscsis_process_mad(struct scsi_info
*vscsi
, struct iu_entry
*iue
)
1730 struct mad_common
*mad
= (struct mad_common
*)&vio_iu(iue
)->mad
;
1731 struct viosrp_empty_iu
*empty
;
1732 long rc
= ADAPT_SUCCESS
;
1734 switch (be32_to_cpu(mad
->type
)) {
1735 case VIOSRP_EMPTY_IU_TYPE
:
1736 empty
= &vio_iu(iue
)->mad
.empty_iu
;
1737 vscsi
->empty_iu_id
= be64_to_cpu(empty
->buffer
);
1738 vscsi
->empty_iu_tag
= be64_to_cpu(empty
->common
.tag
);
1739 mad
->status
= cpu_to_be16(VIOSRP_MAD_SUCCESS
);
1741 case VIOSRP_ADAPTER_INFO_TYPE
:
1742 rc
= ibmvscsis_adapter_info(vscsi
, iue
);
1744 case VIOSRP_CAPABILITIES_TYPE
:
1745 rc
= ibmvscsis_cap_mad(vscsi
, iue
);
1747 case VIOSRP_ENABLE_FAST_FAIL
:
1748 if (vscsi
->state
== CONNECTED
) {
1749 vscsi
->fast_fail
= true;
1750 mad
->status
= cpu_to_be16(VIOSRP_MAD_SUCCESS
);
1752 pr_warn("fast fail mad sent after login\n");
1753 mad
->status
= cpu_to_be16(VIOSRP_MAD_FAILED
);
1757 mad
->status
= cpu_to_be16(VIOSRP_MAD_NOT_SUPPORTED
);
1765 * srp_snd_msg_failed() - Handle an error when sending a response
1766 * @vscsi: Pointer to our adapter structure
1767 * @rc: The return code from the h_send_crq command
1769 * Must be called with interrupt lock held.
1771 static void srp_snd_msg_failed(struct scsi_info
*vscsi
, long rc
)
1775 if (rc
!= H_DROPPED
) {
1776 ibmvscsis_free_cmd_qs(vscsi
);
1779 vscsi
->flags
|= CLIENT_FAILED
;
1781 /* don't flag the same problem multiple times */
1782 if (!(vscsi
->flags
& RESPONSE_Q_DOWN
)) {
1783 vscsi
->flags
|= RESPONSE_Q_DOWN
;
1784 if (!(vscsi
->state
& (ERR_DISCONNECT
|
1785 ERR_DISCONNECT_RECONNECT
|
1786 ERR_DISCONNECTED
| UNDEFINED
))) {
1787 dev_err(&vscsi
->dev
, "snd_msg_failed: setting RESPONSE_Q_DOWN, state 0x%hx, flags 0x%x, rc %ld\n",
1788 vscsi
->state
, vscsi
->flags
, rc
);
1790 ibmvscsis_post_disconnect(vscsi
,
1791 ERR_DISCONNECT_RECONNECT
, 0);
1797 * The response queue is full.
1798 * If the server is processing SRP requests, i.e.
1799 * the client has successfully done an
1800 * SRP_LOGIN, then it will wait forever for room in
1801 * the queue. However if the system admin
1802 * is attempting to unconfigure the server then one
1803 * or more children will be in a state where
1804 * they are being removed. So if there is even one
1805 * child being removed then the driver assumes
1806 * the system admin is attempting to break the
1807 * connection with the client and MAX_TIMER_POPS
1810 if ((vscsi
->rsp_q_timer
.timer_pops
< MAX_TIMER_POPS
) ||
1811 (vscsi
->state
== SRP_PROCESSING
)) {
1812 pr_debug("snd_msg_failed: response queue full, flags 0x%x, timer started %d, pops %d\n",
1813 vscsi
->flags
, (int)vscsi
->rsp_q_timer
.started
,
1814 vscsi
->rsp_q_timer
.timer_pops
);
1817 * Check if the timer is running; if it
1818 * is not then start it up.
1820 if (!vscsi
->rsp_q_timer
.started
) {
1821 if (vscsi
->rsp_q_timer
.timer_pops
<
1823 kt
= WAIT_NANO_SECONDS
;
1826 * slide the timeslice if the maximum
1827 * timer pops have already happened
1829 kt
= ktime_set(WAIT_SECONDS
, 0);
1832 vscsi
->rsp_q_timer
.started
= true;
1833 hrtimer_start(&vscsi
->rsp_q_timer
.timer
, kt
,
1838 * TBD: Do we need to worry about this? Need to get
1842 * waited a long time and it appears the system admin
1843 * is bring this driver down
1845 vscsi
->flags
|= RESPONSE_Q_DOWN
;
1846 ibmvscsis_free_cmd_qs(vscsi
);
1848 * if the driver is already attempting to disconnect
1849 * from the client and has already logged an error
1850 * trace this event but don't put it in the error log
1852 if (!(vscsi
->state
& (ERR_DISCONNECT
|
1853 ERR_DISCONNECT_RECONNECT
|
1854 ERR_DISCONNECTED
| UNDEFINED
))) {
1855 dev_err(&vscsi
->dev
, "client crq full too long\n");
1856 ibmvscsis_post_disconnect(vscsi
,
1857 ERR_DISCONNECT_RECONNECT
,
1864 * ibmvscsis_send_messages() - Send a Response
1865 * @vscsi: Pointer to our adapter structure
1867 * Send a response, first checking the waiting queue. Responses are
1868 * sent in order they are received. If the response cannot be sent,
1869 * because the client queue is full, it stays on the waiting queue.
1872 * Called with interrupt lock held
1874 static void ibmvscsis_send_messages(struct scsi_info
*vscsi
)
1877 /* note do not attempt to access the IU_data_ptr with this pointer
1880 struct viosrp_crq
*crq
= (struct viosrp_crq
*)&msg_hi
;
1881 struct ibmvscsis_cmd
*cmd
, *nxt
;
1882 struct iu_entry
*iue
;
1883 long rc
= ADAPT_SUCCESS
;
1886 if (!(vscsi
->flags
& RESPONSE_Q_DOWN
)) {
1889 list_for_each_entry_safe(cmd
, nxt
, &vscsi
->waiting_rsp
,
1892 * Check to make sure abort cmd gets processed
1893 * prior to the abort tmr cmd
1895 if (cmd
->flags
& DELAY_SEND
)
1898 if (cmd
->abort_cmd
) {
1900 cmd
->abort_cmd
->flags
&= ~(DELAY_SEND
);
1901 cmd
->abort_cmd
= NULL
;
1905 * If CMD_T_ABORTED w/o CMD_T_TAS scenarios and
1906 * the case where LIO issued a
1907 * ABORT_TASK: Sending TMR_TASK_DOES_NOT_EXIST
1908 * case then we dont send a response, since it
1911 if (cmd
->se_cmd
.transport_state
& CMD_T_ABORTED
&&
1912 !(cmd
->se_cmd
.transport_state
& CMD_T_TAS
)) {
1913 list_del(&cmd
->list
);
1914 ibmvscsis_free_cmd_resources(vscsi
,
1917 * With a successfully aborted op
1918 * through LIO we want to increment the
1919 * the vscsi credit so that when we dont
1920 * send a rsp to the original scsi abort
1921 * op (h_send_crq), but the tm rsp to
1922 * the abort is sent, the credit is
1923 * correctly sent with the abort tm rsp.
1924 * We would need 1 for the abort tm rsp
1925 * and 1 credit for the aborted scsi op.
1926 * Thus we need to increment here.
1927 * Also we want to increment the credit
1928 * here because we want to make sure
1929 * cmd is actually released first
1930 * otherwise the client will think it
1931 * it can send a new cmd, and we could
1932 * find ourselves short of cmd elements.
1938 crq
->valid
= VALID_CMD_RESP_EL
;
1939 crq
->format
= cmd
->rsp
.format
;
1941 if (cmd
->flags
& CMD_FAST_FAIL
)
1942 crq
->status
= VIOSRP_ADAPTER_FAIL
;
1944 crq
->IU_length
= cpu_to_be16(cmd
->rsp
.len
);
1946 rc
= h_send_crq(vscsi
->dma_dev
->unit_address
,
1947 be64_to_cpu(msg_hi
),
1948 be64_to_cpu(cmd
->rsp
.tag
));
1950 pr_debug("send_messages: cmd %p, tag 0x%llx, rc %ld\n",
1951 cmd
, be64_to_cpu(cmd
->rsp
.tag
), rc
);
1953 /* if all ok free up the command
1956 if (rc
== H_SUCCESS
) {
1957 /* some movement has occurred */
1958 vscsi
->rsp_q_timer
.timer_pops
= 0;
1959 list_del(&cmd
->list
);
1961 ibmvscsis_free_cmd_resources(vscsi
,
1964 srp_snd_msg_failed(vscsi
, rc
);
1973 * The timer could pop with the queue empty. If
1974 * this happens, rc will always indicate a
1975 * success; clear the pop count.
1977 vscsi
->rsp_q_timer
.timer_pops
= 0;
1980 ibmvscsis_free_cmd_qs(vscsi
);
1984 /* Called with intr lock held */
1985 static void ibmvscsis_send_mad_resp(struct scsi_info
*vscsi
,
1986 struct ibmvscsis_cmd
*cmd
,
1987 struct viosrp_crq
*crq
)
1989 struct iu_entry
*iue
= cmd
->iue
;
1990 struct mad_common
*mad
= (struct mad_common
*)&vio_iu(iue
)->mad
;
1995 rc
= h_copy_rdma(sizeof(struct mad_common
),
1996 vscsi
->dds
.window
[LOCAL
].liobn
, iue
->sbuf
->dma
,
1997 vscsi
->dds
.window
[REMOTE
].liobn
,
1998 be64_to_cpu(crq
->IU_data_ptr
));
2000 cmd
->rsp
.format
= VIOSRP_MAD_FORMAT
;
2001 cmd
->rsp
.len
= sizeof(struct mad_common
);
2002 cmd
->rsp
.tag
= mad
->tag
;
2003 list_add_tail(&cmd
->list
, &vscsi
->waiting_rsp
);
2004 ibmvscsis_send_messages(vscsi
);
2006 pr_debug("Error sending mad response, rc %ld\n", rc
);
2007 if (rc
== H_PERMISSION
) {
2008 if (connection_broken(vscsi
))
2009 flag_bits
= (RESPONSE_Q_DOWN
| CLIENT_FAILED
);
2011 dev_err(&vscsi
->dev
, "mad: failed to copy to client, rc %ld\n",
2014 ibmvscsis_free_cmd_resources(vscsi
, cmd
);
2015 ibmvscsis_post_disconnect(vscsi
, ERR_DISCONNECT_RECONNECT
,
2021 * ibmvscsis_mad() - Service a MAnagement Data gram.
2022 * @vscsi: Pointer to our adapter structure
2023 * @crq: Pointer to the CRQ entry containing the MAD request
2025 * EXECUTION ENVIRONMENT:
2026 * Interrupt, called with adapter lock held
2028 static long ibmvscsis_mad(struct scsi_info
*vscsi
, struct viosrp_crq
*crq
)
2030 struct iu_entry
*iue
;
2031 struct ibmvscsis_cmd
*cmd
;
2032 struct mad_common
*mad
;
2033 long rc
= ADAPT_SUCCESS
;
2035 switch (vscsi
->state
) {
2037 * We have not exchanged Init Msgs yet, so this MAD was sent
2038 * before the last Transport Event; client will not be
2039 * expecting a response.
2041 case WAIT_CONNECTION
:
2042 pr_debug("mad: in Wait Connection state, ignoring MAD, flags %d\n",
2044 return ADAPT_SUCCESS
;
2046 case SRP_PROCESSING
:
2051 * We should never get here while we're in these states.
2052 * Just log an error and get out.
2056 case ERR_DISCONNECT
:
2057 case ERR_DISCONNECT_RECONNECT
:
2059 dev_err(&vscsi
->dev
, "mad: invalid adapter state %d for mad\n",
2061 return ADAPT_SUCCESS
;
2064 cmd
= ibmvscsis_get_free_cmd(vscsi
);
2066 dev_err(&vscsi
->dev
, "mad: failed to get cmd, debit %d\n",
2068 ibmvscsis_post_disconnect(vscsi
, ERR_DISCONNECT_RECONNECT
, 0);
2072 cmd
->type
= ADAPTER_MAD
;
2074 rc
= ibmvscsis_copy_crq_packet(vscsi
, cmd
, crq
);
2076 mad
= (struct mad_common
*)&vio_iu(iue
)->mad
;
2078 pr_debug("mad: type %d\n", be32_to_cpu(mad
->type
));
2080 rc
= ibmvscsis_process_mad(vscsi
, iue
);
2082 pr_debug("mad: status %hd, rc %ld\n", be16_to_cpu(mad
->status
),
2086 ibmvscsis_send_mad_resp(vscsi
, cmd
, crq
);
2088 ibmvscsis_free_cmd_resources(vscsi
, cmd
);
2091 pr_debug("Leaving mad, rc %ld\n", rc
);
2096 * ibmvscsis_login_rsp() - Create/copy a login response notice to the client
2097 * @vscsi: Pointer to our adapter structure
2098 * @cmd: Pointer to the command for the SRP Login request
2100 * EXECUTION ENVIRONMENT:
2101 * Interrupt, interrupt lock held
2103 static long ibmvscsis_login_rsp(struct scsi_info
*vscsi
,
2104 struct ibmvscsis_cmd
*cmd
)
2106 struct iu_entry
*iue
= cmd
->iue
;
2107 struct srp_login_rsp
*rsp
= &vio_iu(iue
)->srp
.login_rsp
;
2108 struct format_code
*fmt
;
2110 long rc
= ADAPT_SUCCESS
;
2112 memset(rsp
, 0, sizeof(struct srp_login_rsp
));
2114 rsp
->opcode
= SRP_LOGIN_RSP
;
2115 rsp
->req_lim_delta
= cpu_to_be32(vscsi
->request_limit
);
2116 rsp
->tag
= cmd
->rsp
.tag
;
2117 rsp
->max_it_iu_len
= cpu_to_be32(SRP_MAX_IU_LEN
);
2118 rsp
->max_ti_iu_len
= cpu_to_be32(SRP_MAX_IU_LEN
);
2119 fmt
= (struct format_code
*)&rsp
->buf_fmt
;
2120 fmt
->buffers
= SUPPORTED_FORMATS
;
2123 cmd
->rsp
.len
= sizeof(struct srp_login_rsp
);
2126 rc
= h_copy_rdma(cmd
->rsp
.len
, vscsi
->dds
.window
[LOCAL
].liobn
,
2127 iue
->sbuf
->dma
, vscsi
->dds
.window
[REMOTE
].liobn
,
2128 be64_to_cpu(iue
->remote_token
));
2135 if (connection_broken(vscsi
))
2136 flag_bits
= RESPONSE_Q_DOWN
| CLIENT_FAILED
;
2137 dev_err(&vscsi
->dev
, "login_rsp: error copying to client, rc %ld\n",
2139 ibmvscsis_post_disconnect(vscsi
, ERR_DISCONNECT_RECONNECT
,
2145 dev_err(&vscsi
->dev
, "login_rsp: error copying to client, rc %ld\n",
2147 ibmvscsis_post_disconnect(vscsi
, ERR_DISCONNECT_RECONNECT
, 0);
2155 * ibmvscsis_srp_login_rej() - Create/copy a login rejection notice to client
2156 * @vscsi: Pointer to our adapter structure
2157 * @cmd: Pointer to the command for the SRP Login request
2158 * @reason: The reason the SRP Login is being rejected, per SRP protocol
2160 * EXECUTION ENVIRONMENT:
2161 * Interrupt, interrupt lock held
2163 static long ibmvscsis_srp_login_rej(struct scsi_info
*vscsi
,
2164 struct ibmvscsis_cmd
*cmd
, u32 reason
)
2166 struct iu_entry
*iue
= cmd
->iue
;
2167 struct srp_login_rej
*rej
= &vio_iu(iue
)->srp
.login_rej
;
2168 struct format_code
*fmt
;
2170 long rc
= ADAPT_SUCCESS
;
2172 memset(rej
, 0, sizeof(*rej
));
2174 rej
->opcode
= SRP_LOGIN_REJ
;
2175 rej
->reason
= cpu_to_be32(reason
);
2176 rej
->tag
= cmd
->rsp
.tag
;
2177 fmt
= (struct format_code
*)&rej
->buf_fmt
;
2178 fmt
->buffers
= SUPPORTED_FORMATS
;
2180 cmd
->rsp
.len
= sizeof(*rej
);
2183 rc
= h_copy_rdma(cmd
->rsp
.len
, vscsi
->dds
.window
[LOCAL
].liobn
,
2184 iue
->sbuf
->dma
, vscsi
->dds
.window
[REMOTE
].liobn
,
2185 be64_to_cpu(iue
->remote_token
));
2191 if (connection_broken(vscsi
))
2192 flag_bits
= RESPONSE_Q_DOWN
| CLIENT_FAILED
;
2193 dev_err(&vscsi
->dev
, "login_rej: error copying to client, rc %ld\n",
2195 ibmvscsis_post_disconnect(vscsi
, ERR_DISCONNECT_RECONNECT
,
2201 dev_err(&vscsi
->dev
, "login_rej: error copying to client, rc %ld\n",
2203 ibmvscsis_post_disconnect(vscsi
, ERR_DISCONNECT_RECONNECT
, 0);
2210 static int ibmvscsis_make_nexus(struct ibmvscsis_tport
*tport
)
2212 char *name
= tport
->tport_name
;
2213 struct ibmvscsis_nexus
*nexus
;
2216 if (tport
->ibmv_nexus
) {
2217 pr_debug("tport->ibmv_nexus already exists\n");
2221 nexus
= kzalloc(sizeof(*nexus
), GFP_KERNEL
);
2223 pr_err("Unable to allocate struct ibmvscsis_nexus\n");
2227 nexus
->se_sess
= target_alloc_session(&tport
->se_tpg
, 0, 0,
2228 TARGET_PROT_NORMAL
, name
, nexus
,
2230 if (IS_ERR(nexus
->se_sess
)) {
2231 rc
= PTR_ERR(nexus
->se_sess
);
2232 goto transport_init_fail
;
2235 tport
->ibmv_nexus
= nexus
;
2239 transport_init_fail
:
2244 static int ibmvscsis_drop_nexus(struct ibmvscsis_tport
*tport
)
2246 struct se_session
*se_sess
;
2247 struct ibmvscsis_nexus
*nexus
;
2249 nexus
= tport
->ibmv_nexus
;
2253 se_sess
= nexus
->se_sess
;
2258 * Release the SCSI I_T Nexus to the emulated ibmvscsis Target Port
2260 target_wait_for_sess_cmds(se_sess
);
2261 transport_deregister_session_configfs(se_sess
);
2262 transport_deregister_session(se_sess
);
2263 tport
->ibmv_nexus
= NULL
;
2270 * ibmvscsis_srp_login() - Process an SRP Login Request
2271 * @vscsi: Pointer to our adapter structure
2272 * @cmd: Command element to use to process the SRP Login request
2273 * @crq: Pointer to CRQ entry containing the SRP Login request
2275 * EXECUTION ENVIRONMENT:
2276 * Interrupt, called with interrupt lock held
2278 static long ibmvscsis_srp_login(struct scsi_info
*vscsi
,
2279 struct ibmvscsis_cmd
*cmd
,
2280 struct viosrp_crq
*crq
)
2282 struct iu_entry
*iue
= cmd
->iue
;
2283 struct srp_login_req
*req
= &vio_iu(iue
)->srp
.login_req
;
2285 __be64 id_extension
;
2288 struct format_code
*fmt
;
2290 long rc
= ADAPT_SUCCESS
;
2292 iport
= (struct port_id
*)req
->initiator_port_id
;
2293 tport
= (struct port_id
*)req
->target_port_id
;
2294 fmt
= (struct format_code
*)&req
->req_buf_fmt
;
2295 if (be32_to_cpu(req
->req_it_iu_len
) > SRP_MAX_IU_LEN
)
2296 reason
= SRP_LOGIN_REJ_REQ_IT_IU_LENGTH_TOO_LARGE
;
2297 else if (be32_to_cpu(req
->req_it_iu_len
) < 64)
2298 reason
= SRP_LOGIN_REJ_UNABLE_ESTABLISH_CHANNEL
;
2299 else if ((be64_to_cpu(iport
->id_extension
) > (MAX_NUM_PORTS
- 1)) ||
2300 (be64_to_cpu(tport
->id_extension
) > (MAX_NUM_PORTS
- 1)))
2301 reason
= SRP_LOGIN_REJ_UNABLE_ASSOCIATE_CHANNEL
;
2302 else if (req
->req_flags
& SRP_MULTICHAN_MULTI
)
2303 reason
= SRP_LOGIN_REJ_MULTI_CHANNEL_UNSUPPORTED
;
2304 else if (fmt
->buffers
& (~SUPPORTED_FORMATS
))
2305 reason
= SRP_LOGIN_REJ_UNSUPPORTED_DESCRIPTOR_FMT
;
2306 else if ((fmt
->buffers
& SUPPORTED_FORMATS
) == 0)
2307 reason
= SRP_LOGIN_REJ_UNSUPPORTED_DESCRIPTOR_FMT
;
2309 if (vscsi
->state
== SRP_PROCESSING
)
2310 reason
= SRP_LOGIN_REJ_CHANNEL_LIMIT_REACHED
;
2312 rc
= ibmvscsis_make_nexus(&vscsi
->tport
);
2314 reason
= SRP_LOGIN_REJ_UNABLE_ESTABLISH_CHANNEL
;
2316 cmd
->rsp
.format
= VIOSRP_SRP_FORMAT
;
2317 cmd
->rsp
.tag
= req
->tag
;
2319 pr_debug("srp_login: reason 0x%x\n", reason
);
2322 rc
= ibmvscsis_srp_login_rej(vscsi
, cmd
, reason
);
2324 rc
= ibmvscsis_login_rsp(vscsi
, cmd
);
2328 vscsi
->state
= SRP_PROCESSING
;
2330 list_add_tail(&cmd
->list
, &vscsi
->waiting_rsp
);
2331 ibmvscsis_send_messages(vscsi
);
2333 ibmvscsis_free_cmd_resources(vscsi
, cmd
);
2336 pr_debug("Leaving srp_login, rc %ld\n", rc
);
2341 * ibmvscsis_srp_i_logout() - Helper Function to close I_T Nexus
2342 * @vscsi: Pointer to our adapter structure
2343 * @cmd: Command element to use to process the Implicit Logout request
2344 * @crq: Pointer to CRQ entry containing the Implicit Logout request
2346 * Do the logic to close the I_T nexus. This function may not
2347 * behave to specification.
2349 * EXECUTION ENVIRONMENT:
2350 * Interrupt, interrupt lock held
2352 static long ibmvscsis_srp_i_logout(struct scsi_info
*vscsi
,
2353 struct ibmvscsis_cmd
*cmd
,
2354 struct viosrp_crq
*crq
)
2356 struct iu_entry
*iue
= cmd
->iue
;
2357 struct srp_i_logout
*log_out
= &vio_iu(iue
)->srp
.i_logout
;
2358 long rc
= ADAPT_SUCCESS
;
2360 if ((vscsi
->debit
> 0) || !list_empty(&vscsi
->schedule_q
) ||
2361 !list_empty(&vscsi
->waiting_rsp
)) {
2362 dev_err(&vscsi
->dev
, "i_logout: outstanding work\n");
2363 ibmvscsis_post_disconnect(vscsi
, ERR_DISCONNECT
, 0);
2365 cmd
->rsp
.format
= SRP_FORMAT
;
2366 cmd
->rsp
.tag
= log_out
->tag
;
2367 cmd
->rsp
.len
= sizeof(struct mad_common
);
2368 list_add_tail(&cmd
->list
, &vscsi
->waiting_rsp
);
2369 ibmvscsis_send_messages(vscsi
);
2371 ibmvscsis_post_disconnect(vscsi
, WAIT_IDLE
, 0);
2377 /* Called with intr lock held */
2378 static void ibmvscsis_srp_cmd(struct scsi_info
*vscsi
, struct viosrp_crq
*crq
)
2380 struct ibmvscsis_cmd
*cmd
;
2381 struct iu_entry
*iue
;
2382 struct srp_cmd
*srp
;
2383 struct srp_tsk_mgmt
*tsk
;
2386 if (vscsi
->request_limit
- vscsi
->debit
<= 0) {
2387 /* Client has exceeded request limit */
2388 dev_err(&vscsi
->dev
, "Client exceeded the request limit (%d), debit %d\n",
2389 vscsi
->request_limit
, vscsi
->debit
);
2390 ibmvscsis_post_disconnect(vscsi
, ERR_DISCONNECT_RECONNECT
, 0);
2394 cmd
= ibmvscsis_get_free_cmd(vscsi
);
2396 dev_err(&vscsi
->dev
, "srp_cmd failed to get cmd, debit %d\n",
2398 ibmvscsis_post_disconnect(vscsi
, ERR_DISCONNECT_RECONNECT
, 0);
2402 srp
= &vio_iu(iue
)->srp
.cmd
;
2404 rc
= ibmvscsis_copy_crq_packet(vscsi
, cmd
, crq
);
2406 ibmvscsis_free_cmd_resources(vscsi
, cmd
);
2410 if (vscsi
->state
== SRP_PROCESSING
) {
2411 switch (srp
->opcode
) {
2413 rc
= ibmvscsis_srp_login(vscsi
, cmd
, crq
);
2417 tsk
= &vio_iu(iue
)->srp
.tsk_mgmt
;
2418 pr_debug("tsk_mgmt tag: %llu (0x%llx)\n", tsk
->tag
,
2420 cmd
->rsp
.tag
= tsk
->tag
;
2422 cmd
->type
= TASK_MANAGEMENT
;
2423 list_add_tail(&cmd
->list
, &vscsi
->schedule_q
);
2424 queue_work(vscsi
->work_q
, &cmd
->work
);
2428 pr_debug("srp_cmd tag: %llu (0x%llx)\n", srp
->tag
,
2430 cmd
->rsp
.tag
= srp
->tag
;
2432 cmd
->type
= SCSI_CDB
;
2434 * We want to keep track of work waiting for
2437 list_add_tail(&cmd
->list
, &vscsi
->schedule_q
);
2438 queue_work(vscsi
->work_q
, &cmd
->work
);
2442 rc
= ibmvscsis_srp_i_logout(vscsi
, cmd
, crq
);
2448 ibmvscsis_free_cmd_resources(vscsi
, cmd
);
2449 dev_err(&vscsi
->dev
, "invalid srp cmd, opcode %d\n",
2451 ibmvscsis_post_disconnect(vscsi
,
2452 ERR_DISCONNECT_RECONNECT
, 0);
2455 } else if (srp
->opcode
== SRP_LOGIN_REQ
&& vscsi
->state
== CONNECTED
) {
2456 rc
= ibmvscsis_srp_login(vscsi
, cmd
, crq
);
2458 ibmvscsis_free_cmd_resources(vscsi
, cmd
);
2459 dev_err(&vscsi
->dev
, "Invalid state %d to handle srp cmd\n",
2461 ibmvscsis_post_disconnect(vscsi
, ERR_DISCONNECT_RECONNECT
, 0);
2466 * ibmvscsis_ping_response() - Respond to a ping request
2467 * @vscsi: Pointer to our adapter structure
2469 * Let the client know that the server is alive and waiting on
2470 * its native I/O stack.
2471 * If any type of error occurs from the call to queue a ping
2472 * response then the client is either not accepting or receiving
2473 * interrupts. Disconnect with an error.
2475 * EXECUTION ENVIRONMENT:
2476 * Interrupt, interrupt lock held
2478 static long ibmvscsis_ping_response(struct scsi_info
*vscsi
)
2480 struct viosrp_crq
*crq
;
2481 u64 buffer
[2] = { 0, 0 };
2484 crq
= (struct viosrp_crq
*)&buffer
;
2485 crq
->valid
= VALID_CMD_RESP_EL
;
2486 crq
->format
= (u8
)MESSAGE_IN_CRQ
;
2487 crq
->status
= PING_RESPONSE
;
2489 rc
= h_send_crq(vscsi
->dds
.unit_id
, cpu_to_be64(buffer
[MSG_HI
]),
2490 cpu_to_be64(buffer
[MSG_LOW
]));
2496 vscsi
->flags
|= CLIENT_FAILED
;
2498 vscsi
->flags
|= RESPONSE_Q_DOWN
;
2500 dev_err(&vscsi
->dev
, "ping_response: h_send_crq failed, rc %ld\n",
2502 ibmvscsis_post_disconnect(vscsi
, ERR_DISCONNECT_RECONNECT
, 0);
2505 dev_err(&vscsi
->dev
, "ping_response: h_send_crq returned unknown rc %ld\n",
2507 ibmvscsis_post_disconnect(vscsi
, ERR_DISCONNECT
, 0);
2515 * ibmvscsis_parse_command() - Parse an element taken from the cmd rsp queue.
2516 * @vscsi: Pointer to our adapter structure
2517 * @crq: Pointer to CRQ element containing the SRP request
2519 * This function will return success if the command queue element is valid
2520 * and the srp iu or MAD request it pointed to was also valid. That does
2521 * not mean that an error was not returned to the client.
2523 * EXECUTION ENVIRONMENT:
2524 * Interrupt, intr lock held
2526 static long ibmvscsis_parse_command(struct scsi_info
*vscsi
,
2527 struct viosrp_crq
*crq
)
2529 long rc
= ADAPT_SUCCESS
;
2531 switch (crq
->valid
) {
2532 case VALID_CMD_RESP_EL
:
2533 switch (crq
->format
) {
2538 if (vscsi
->flags
& PROCESSING_MAD
) {
2540 dev_err(&vscsi
->dev
, "parse_command: already processing mad\n");
2541 ibmvscsis_post_disconnect(vscsi
,
2542 ERR_DISCONNECT_RECONNECT
,
2545 vscsi
->flags
|= PROCESSING_MAD
;
2546 rc
= ibmvscsis_mad(vscsi
, crq
);
2551 ibmvscsis_srp_cmd(vscsi
, crq
);
2554 case MESSAGE_IN_CRQ
:
2555 if (crq
->status
== PING
)
2556 ibmvscsis_ping_response(vscsi
);
2560 dev_err(&vscsi
->dev
, "parse_command: invalid format %d\n",
2562 ibmvscsis_post_disconnect(vscsi
,
2563 ERR_DISCONNECT_RECONNECT
, 0);
2568 case VALID_TRANS_EVENT
:
2569 rc
= ibmvscsis_trans_event(vscsi
, crq
);
2572 case VALID_INIT_MSG
:
2573 rc
= ibmvscsis_init_msg(vscsi
, crq
);
2577 dev_err(&vscsi
->dev
, "parse_command: invalid valid field %d\n",
2579 ibmvscsis_post_disconnect(vscsi
, ERR_DISCONNECT_RECONNECT
, 0);
2584 * Return only what the interrupt handler cares
2585 * about. Most errors we keep right on trucking.
2587 rc
= vscsi
->flags
& SCHEDULE_DISCONNECT
;
2592 static int read_dma_window(struct scsi_info
*vscsi
)
2594 struct vio_dev
*vdev
= vscsi
->dma_dev
;
2595 const __be32
*dma_window
;
2598 /* TODO Using of_parse_dma_window would be better, but it doesn't give
2599 * a way to read multiple windows without already knowing the size of
2600 * a window or the number of windows.
2602 dma_window
= (const __be32
*)vio_get_attribute(vdev
,
2603 "ibm,my-dma-window",
2606 pr_err("Couldn't find ibm,my-dma-window property\n");
2610 vscsi
->dds
.window
[LOCAL
].liobn
= be32_to_cpu(*dma_window
);
2613 prop
= (const __be32
*)vio_get_attribute(vdev
, "ibm,#dma-address-cells",
2616 pr_warn("Couldn't find ibm,#dma-address-cells property\n");
2619 dma_window
+= be32_to_cpu(*prop
);
2622 prop
= (const __be32
*)vio_get_attribute(vdev
, "ibm,#dma-size-cells",
2625 pr_warn("Couldn't find ibm,#dma-size-cells property\n");
2628 dma_window
+= be32_to_cpu(*prop
);
2631 /* dma_window should point to the second window now */
2632 vscsi
->dds
.window
[REMOTE
].liobn
= be32_to_cpu(*dma_window
);
2637 static struct ibmvscsis_tport
*ibmvscsis_lookup_port(const char *name
)
2639 struct ibmvscsis_tport
*tport
= NULL
;
2640 struct vio_dev
*vdev
;
2641 struct scsi_info
*vscsi
;
2643 spin_lock_bh(&ibmvscsis_dev_lock
);
2644 list_for_each_entry(vscsi
, &ibmvscsis_dev_list
, list
) {
2645 vdev
= vscsi
->dma_dev
;
2646 if (!strcmp(dev_name(&vdev
->dev
), name
)) {
2647 tport
= &vscsi
->tport
;
2651 spin_unlock_bh(&ibmvscsis_dev_lock
);
2657 * ibmvscsis_parse_cmd() - Parse SRP Command
2658 * @vscsi: Pointer to our adapter structure
2659 * @cmd: Pointer to command element with SRP command
2661 * Parse the srp command; if it is valid then submit it to tcm.
2662 * Note: The return code does not reflect the status of the SCSI CDB.
2664 * EXECUTION ENVIRONMENT:
2667 static void ibmvscsis_parse_cmd(struct scsi_info
*vscsi
,
2668 struct ibmvscsis_cmd
*cmd
)
2670 struct iu_entry
*iue
= cmd
->iue
;
2671 struct srp_cmd
*srp
= (struct srp_cmd
*)iue
->sbuf
->buf
;
2672 struct ibmvscsis_nexus
*nexus
;
2674 enum dma_data_direction dir
;
2678 nexus
= vscsi
->tport
.ibmv_nexus
;
2680 * additional length in bytes. Note that the SRP spec says that
2681 * additional length is in 4-byte words, but technically the
2682 * additional length field is only the upper 6 bits of the byte.
2683 * The lower 2 bits are reserved. If the lower 2 bits are 0 (as
2684 * all reserved fields should be), then interpreting the byte as
2685 * an int will yield the length in bytes.
2687 if (srp
->add_cdb_len
& 0x03) {
2688 dev_err(&vscsi
->dev
, "parse_cmd: reserved bits set in IU\n");
2689 spin_lock_bh(&vscsi
->intr_lock
);
2690 ibmvscsis_post_disconnect(vscsi
, ERR_DISCONNECT_RECONNECT
, 0);
2691 ibmvscsis_free_cmd_resources(vscsi
, cmd
);
2692 spin_unlock_bh(&vscsi
->intr_lock
);
2696 if (srp_get_desc_table(srp
, &dir
, &data_len
)) {
2697 dev_err(&vscsi
->dev
, "0x%llx: parsing SRP descriptor table failed.\n",
2702 cmd
->rsp
.sol_not
= srp
->sol_not
;
2704 switch (srp
->task_attr
) {
2705 case SRP_SIMPLE_TASK
:
2706 attr
= TCM_SIMPLE_TAG
;
2708 case SRP_ORDERED_TASK
:
2709 attr
= TCM_ORDERED_TAG
;
2712 attr
= TCM_HEAD_TAG
;
2718 dev_err(&vscsi
->dev
, "Invalid task attribute %d\n",
2723 cmd
->se_cmd
.tag
= be64_to_cpu(srp
->tag
);
2725 spin_lock_bh(&vscsi
->intr_lock
);
2726 list_add_tail(&cmd
->list
, &vscsi
->active_q
);
2727 spin_unlock_bh(&vscsi
->intr_lock
);
2729 srp
->lun
.scsi_lun
[0] &= 0x3f;
2731 rc
= target_submit_cmd(&cmd
->se_cmd
, nexus
->se_sess
, srp
->cdb
,
2732 cmd
->sense_buf
, scsilun_to_int(&srp
->lun
),
2733 data_len
, attr
, dir
, 0);
2735 dev_err(&vscsi
->dev
, "target_submit_cmd failed, rc %d\n", rc
);
2736 spin_lock_bh(&vscsi
->intr_lock
);
2737 list_del(&cmd
->list
);
2738 ibmvscsis_free_cmd_resources(vscsi
, cmd
);
2739 spin_unlock_bh(&vscsi
->intr_lock
);
2745 spin_lock_bh(&vscsi
->intr_lock
);
2746 ibmvscsis_post_disconnect(vscsi
, ERR_DISCONNECT_RECONNECT
, 0);
2747 spin_unlock_bh(&vscsi
->intr_lock
);
2751 * ibmvscsis_parse_task() - Parse SRP Task Management Request
2752 * @vscsi: Pointer to our adapter structure
2753 * @cmd: Pointer to command element with SRP task management request
2755 * Parse the srp task management request; if it is valid then submit it to tcm.
2756 * Note: The return code does not reflect the status of the task management
2759 * EXECUTION ENVIRONMENT:
2762 static void ibmvscsis_parse_task(struct scsi_info
*vscsi
,
2763 struct ibmvscsis_cmd
*cmd
)
2765 struct iu_entry
*iue
= cmd
->iue
;
2766 struct srp_tsk_mgmt
*srp_tsk
= &vio_iu(iue
)->srp
.tsk_mgmt
;
2768 u64 tag_to_abort
= 0;
2770 struct ibmvscsis_nexus
*nexus
;
2772 nexus
= vscsi
->tport
.ibmv_nexus
;
2774 cmd
->rsp
.sol_not
= srp_tsk
->sol_not
;
2776 switch (srp_tsk
->tsk_mgmt_func
) {
2777 case SRP_TSK_ABORT_TASK
:
2778 tcm_type
= TMR_ABORT_TASK
;
2779 tag_to_abort
= be64_to_cpu(srp_tsk
->task_tag
);
2781 case SRP_TSK_ABORT_TASK_SET
:
2782 tcm_type
= TMR_ABORT_TASK_SET
;
2784 case SRP_TSK_CLEAR_TASK_SET
:
2785 tcm_type
= TMR_CLEAR_TASK_SET
;
2787 case SRP_TSK_LUN_RESET
:
2788 tcm_type
= TMR_LUN_RESET
;
2790 case SRP_TSK_CLEAR_ACA
:
2791 tcm_type
= TMR_CLEAR_ACA
;
2794 dev_err(&vscsi
->dev
, "unknown task mgmt func %d\n",
2795 srp_tsk
->tsk_mgmt_func
);
2796 cmd
->se_cmd
.se_tmr_req
->response
=
2797 TMR_TASK_MGMT_FUNCTION_NOT_SUPPORTED
;
2803 cmd
->se_cmd
.tag
= be64_to_cpu(srp_tsk
->tag
);
2805 spin_lock_bh(&vscsi
->intr_lock
);
2806 list_add_tail(&cmd
->list
, &vscsi
->active_q
);
2807 spin_unlock_bh(&vscsi
->intr_lock
);
2809 srp_tsk
->lun
.scsi_lun
[0] &= 0x3f;
2811 pr_debug("calling submit_tmr, func %d\n",
2812 srp_tsk
->tsk_mgmt_func
);
2813 rc
= target_submit_tmr(&cmd
->se_cmd
, nexus
->se_sess
, NULL
,
2814 scsilun_to_int(&srp_tsk
->lun
), srp_tsk
,
2815 tcm_type
, GFP_KERNEL
, tag_to_abort
, 0);
2817 dev_err(&vscsi
->dev
, "target_submit_tmr failed, rc %d\n",
2819 spin_lock_bh(&vscsi
->intr_lock
);
2820 list_del(&cmd
->list
);
2821 spin_unlock_bh(&vscsi
->intr_lock
);
2822 cmd
->se_cmd
.se_tmr_req
->response
=
2823 TMR_FUNCTION_REJECTED
;
2828 transport_send_check_condition_and_sense(&cmd
->se_cmd
, 0, 0);
2831 static void ibmvscsis_scheduler(struct work_struct
*work
)
2833 struct ibmvscsis_cmd
*cmd
= container_of(work
, struct ibmvscsis_cmd
,
2835 struct scsi_info
*vscsi
= cmd
->adapter
;
2837 spin_lock_bh(&vscsi
->intr_lock
);
2839 /* Remove from schedule_q */
2840 list_del(&cmd
->list
);
2842 /* Don't submit cmd if we're disconnecting */
2843 if (vscsi
->flags
& (SCHEDULE_DISCONNECT
| DISCONNECT_SCHEDULED
)) {
2844 ibmvscsis_free_cmd_resources(vscsi
, cmd
);
2846 /* ibmvscsis_disconnect might be waiting for us */
2847 if (list_empty(&vscsi
->active_q
) &&
2848 list_empty(&vscsi
->schedule_q
) &&
2849 (vscsi
->flags
& WAIT_FOR_IDLE
)) {
2850 vscsi
->flags
&= ~WAIT_FOR_IDLE
;
2851 complete(&vscsi
->wait_idle
);
2854 spin_unlock_bh(&vscsi
->intr_lock
);
2858 spin_unlock_bh(&vscsi
->intr_lock
);
2860 switch (cmd
->type
) {
2862 ibmvscsis_parse_cmd(vscsi
, cmd
);
2864 case TASK_MANAGEMENT
:
2865 ibmvscsis_parse_task(vscsi
, cmd
);
2868 dev_err(&vscsi
->dev
, "scheduler, invalid cmd type %d\n",
2870 spin_lock_bh(&vscsi
->intr_lock
);
2871 ibmvscsis_free_cmd_resources(vscsi
, cmd
);
2872 spin_unlock_bh(&vscsi
->intr_lock
);
2877 static int ibmvscsis_alloc_cmds(struct scsi_info
*vscsi
, int num
)
2879 struct ibmvscsis_cmd
*cmd
;
2882 INIT_LIST_HEAD(&vscsi
->free_cmd
);
2883 vscsi
->cmd_pool
= kcalloc(num
, sizeof(struct ibmvscsis_cmd
),
2885 if (!vscsi
->cmd_pool
)
2888 for (i
= 0, cmd
= (struct ibmvscsis_cmd
*)vscsi
->cmd_pool
; i
< num
;
2890 cmd
->abort_cmd
= NULL
;
2891 cmd
->adapter
= vscsi
;
2892 INIT_WORK(&cmd
->work
, ibmvscsis_scheduler
);
2893 list_add_tail(&cmd
->list
, &vscsi
->free_cmd
);
2899 static void ibmvscsis_free_cmds(struct scsi_info
*vscsi
)
2901 kfree(vscsi
->cmd_pool
);
2902 vscsi
->cmd_pool
= NULL
;
2903 INIT_LIST_HEAD(&vscsi
->free_cmd
);
2907 * ibmvscsis_service_wait_q() - Service Waiting Queue
2908 * @timer: Pointer to timer which has expired
2910 * This routine is called when the timer pops to service the waiting
2911 * queue. Elements on the queue have completed, their responses have been
2912 * copied to the client, but the client's response queue was full so
2913 * the queue message could not be sent. The routine grabs the proper locks
2914 * and calls send messages.
2916 * EXECUTION ENVIRONMENT:
2917 * called at interrupt level
2919 static enum hrtimer_restart
ibmvscsis_service_wait_q(struct hrtimer
*timer
)
2921 struct timer_cb
*p_timer
= container_of(timer
, struct timer_cb
, timer
);
2922 struct scsi_info
*vscsi
= container_of(p_timer
, struct scsi_info
,
2925 spin_lock_bh(&vscsi
->intr_lock
);
2926 p_timer
->timer_pops
+= 1;
2927 p_timer
->started
= false;
2928 ibmvscsis_send_messages(vscsi
);
2929 spin_unlock_bh(&vscsi
->intr_lock
);
2931 return HRTIMER_NORESTART
;
2934 static long ibmvscsis_alloctimer(struct scsi_info
*vscsi
)
2936 struct timer_cb
*p_timer
;
2938 p_timer
= &vscsi
->rsp_q_timer
;
2939 hrtimer_init(&p_timer
->timer
, CLOCK_MONOTONIC
, HRTIMER_MODE_REL
);
2941 p_timer
->timer
.function
= ibmvscsis_service_wait_q
;
2942 p_timer
->started
= false;
2943 p_timer
->timer_pops
= 0;
2945 return ADAPT_SUCCESS
;
2948 static void ibmvscsis_freetimer(struct scsi_info
*vscsi
)
2950 struct timer_cb
*p_timer
;
2952 p_timer
= &vscsi
->rsp_q_timer
;
2954 (void)hrtimer_cancel(&p_timer
->timer
);
2956 p_timer
->started
= false;
2957 p_timer
->timer_pops
= 0;
2960 static irqreturn_t
ibmvscsis_interrupt(int dummy
, void *data
)
2962 struct scsi_info
*vscsi
= data
;
2964 vio_disable_interrupts(vscsi
->dma_dev
);
2965 tasklet_schedule(&vscsi
->work_task
);
2971 * ibmvscsis_enable_change_state() - Set new state based on enabled status
2972 * @vscsi: Pointer to our adapter structure
2974 * This function determines our new state now that we are enabled. This
2975 * may involve sending an Init Complete message to the client.
2977 * Must be called with interrupt lock held.
2979 static long ibmvscsis_enable_change_state(struct scsi_info
*vscsi
)
2982 long rc
= ADAPT_SUCCESS
;
2984 bytes
= vscsi
->cmd_q
.size
* PAGE_SIZE
;
2985 rc
= h_reg_crq(vscsi
->dds
.unit_id
, vscsi
->cmd_q
.crq_token
, bytes
);
2986 if (rc
== H_CLOSED
|| rc
== H_SUCCESS
) {
2987 vscsi
->state
= WAIT_CONNECTION
;
2988 rc
= ibmvscsis_establish_new_q(vscsi
);
2991 if (rc
!= ADAPT_SUCCESS
) {
2992 vscsi
->state
= ERR_DISCONNECTED
;
2993 vscsi
->flags
|= RESPONSE_Q_DOWN
;
3000 * ibmvscsis_create_command_q() - Create Command Queue
3001 * @vscsi: Pointer to our adapter structure
3002 * @num_cmds: Currently unused. In the future, may be used to determine
3003 * the size of the CRQ.
3005 * Allocates memory for command queue maps remote memory into an ioba
3006 * initializes the command response queue
3008 * EXECUTION ENVIRONMENT:
3009 * Process level only
3011 static long ibmvscsis_create_command_q(struct scsi_info
*vscsi
, int num_cmds
)
3014 struct vio_dev
*vdev
= vscsi
->dma_dev
;
3016 /* We might support multiple pages in the future, but just 1 for now */
3019 vscsi
->cmd_q
.size
= pages
;
3021 vscsi
->cmd_q
.base_addr
=
3022 (struct viosrp_crq
*)get_zeroed_page(GFP_KERNEL
);
3023 if (!vscsi
->cmd_q
.base_addr
)
3026 vscsi
->cmd_q
.mask
= ((uint
)pages
* CRQ_PER_PAGE
) - 1;
3028 vscsi
->cmd_q
.crq_token
= dma_map_single(&vdev
->dev
,
3029 vscsi
->cmd_q
.base_addr
,
3030 PAGE_SIZE
, DMA_BIDIRECTIONAL
);
3031 if (dma_mapping_error(&vdev
->dev
, vscsi
->cmd_q
.crq_token
)) {
3032 free_page((unsigned long)vscsi
->cmd_q
.base_addr
);
3040 * ibmvscsis_destroy_command_q - Destroy Command Queue
3041 * @vscsi: Pointer to our adapter structure
3043 * Releases memory for command queue and unmaps mapped remote memory.
3045 * EXECUTION ENVIRONMENT:
3046 * Process level only
3048 static void ibmvscsis_destroy_command_q(struct scsi_info
*vscsi
)
3050 dma_unmap_single(&vscsi
->dma_dev
->dev
, vscsi
->cmd_q
.crq_token
,
3051 PAGE_SIZE
, DMA_BIDIRECTIONAL
);
3052 free_page((unsigned long)vscsi
->cmd_q
.base_addr
);
3053 vscsi
->cmd_q
.base_addr
= NULL
;
3054 vscsi
->state
= NO_QUEUE
;
3057 static u8
ibmvscsis_fast_fail(struct scsi_info
*vscsi
,
3058 struct ibmvscsis_cmd
*cmd
)
3060 struct iu_entry
*iue
= cmd
->iue
;
3061 struct se_cmd
*se_cmd
= &cmd
->se_cmd
;
3062 struct srp_cmd
*srp
= (struct srp_cmd
*)iue
->sbuf
->buf
;
3063 struct scsi_sense_hdr sshdr
;
3064 u8 rc
= se_cmd
->scsi_status
;
3066 if (vscsi
->fast_fail
&& (READ_CMD(srp
->cdb
) || WRITE_CMD(srp
->cdb
)))
3067 if (scsi_normalize_sense(se_cmd
->sense_buffer
,
3068 se_cmd
->scsi_sense_length
, &sshdr
))
3069 if (sshdr
.sense_key
== HARDWARE_ERROR
&&
3070 (se_cmd
->residual_count
== 0 ||
3071 se_cmd
->residual_count
== se_cmd
->data_length
)) {
3073 cmd
->flags
|= CMD_FAST_FAIL
;
3080 * srp_build_response() - Build an SRP response buffer
3081 * @vscsi: Pointer to our adapter structure
3082 * @cmd: Pointer to command for which to send the response
3083 * @len_p: Where to return the length of the IU response sent. This
3084 * is needed to construct the CRQ response.
3086 * Build the SRP response buffer and copy it to the client's memory space.
3088 static long srp_build_response(struct scsi_info
*vscsi
,
3089 struct ibmvscsis_cmd
*cmd
, uint
*len_p
)
3091 struct iu_entry
*iue
= cmd
->iue
;
3092 struct se_cmd
*se_cmd
= &cmd
->se_cmd
;
3093 struct srp_rsp
*rsp
;
3098 long rc
= ADAPT_SUCCESS
;
3100 spin_lock_bh(&vscsi
->intr_lock
);
3102 rsp
= &vio_iu(iue
)->srp
.rsp
;
3104 memset(rsp
, 0, len
);
3107 rsp
->opcode
= SRP_RSP
;
3109 rsp
->req_lim_delta
= cpu_to_be32(1 + vscsi
->credit
);
3110 rsp
->tag
= cmd
->rsp
.tag
;
3113 if (cmd
->type
== SCSI_CDB
) {
3114 rsp
->status
= ibmvscsis_fast_fail(vscsi
, cmd
);
3116 pr_debug("build_resp: cmd %p, scsi status %d\n", cmd
,
3118 ibmvscsis_determine_resid(se_cmd
, rsp
);
3119 if (se_cmd
->scsi_sense_length
&& se_cmd
->sense_buffer
) {
3120 rsp
->sense_data_len
=
3121 cpu_to_be32(se_cmd
->scsi_sense_length
);
3122 rsp
->flags
|= SRP_RSP_FLAG_SNSVALID
;
3123 len
+= se_cmd
->scsi_sense_length
;
3124 memcpy(data
, se_cmd
->sense_buffer
,
3125 se_cmd
->scsi_sense_length
);
3127 rsp
->sol_not
= (cmd
->rsp
.sol_not
& UCSOLNT
) >>
3129 } else if (cmd
->flags
& CMD_FAST_FAIL
) {
3130 pr_debug("build_resp: cmd %p, fast fail\n", cmd
);
3131 rsp
->sol_not
= (cmd
->rsp
.sol_not
& UCSOLNT
) >>
3134 rsp
->sol_not
= (cmd
->rsp
.sol_not
& SCSOLNT
) >>
3138 /* this is task management */
3140 rsp
->resp_data_len
= cpu_to_be32(4);
3141 rsp
->flags
|= SRP_RSP_FLAG_RSPVALID
;
3143 switch (se_cmd
->se_tmr_req
->response
) {
3144 case TMR_FUNCTION_COMPLETE
:
3145 case TMR_TASK_DOES_NOT_EXIST
:
3146 rsp_code
= SRP_TASK_MANAGEMENT_FUNCTION_COMPLETE
;
3147 rsp
->sol_not
= (cmd
->rsp
.sol_not
& SCSOLNT
) >>
3150 case TMR_TASK_MGMT_FUNCTION_NOT_SUPPORTED
:
3151 case TMR_LUN_DOES_NOT_EXIST
:
3152 rsp_code
= SRP_TASK_MANAGEMENT_FUNCTION_NOT_SUPPORTED
;
3153 rsp
->sol_not
= (cmd
->rsp
.sol_not
& UCSOLNT
) >>
3156 case TMR_FUNCTION_FAILED
:
3157 case TMR_FUNCTION_REJECTED
:
3159 rsp_code
= SRP_TASK_MANAGEMENT_FUNCTION_FAILED
;
3160 rsp
->sol_not
= (cmd
->rsp
.sol_not
& UCSOLNT
) >>
3165 tsk_status
= (u32
*)data
;
3166 *tsk_status
= cpu_to_be32(rsp_code
);
3167 data
= (char *)(tsk_status
+ 1);
3172 rc
= h_copy_rdma(len
, vscsi
->dds
.window
[LOCAL
].liobn
, iue
->sbuf
->dma
,
3173 vscsi
->dds
.window
[REMOTE
].liobn
,
3174 be64_to_cpu(iue
->remote_token
));
3182 if (connection_broken(vscsi
))
3183 vscsi
->flags
|= RESPONSE_Q_DOWN
| CLIENT_FAILED
;
3185 dev_err(&vscsi
->dev
, "build_response: error copying to client, rc %ld, flags 0x%x, state 0x%hx\n",
3186 rc
, vscsi
->flags
, vscsi
->state
);
3191 dev_err(&vscsi
->dev
, "build_response: error copying to client, rc %ld\n",
3196 spin_unlock_bh(&vscsi
->intr_lock
);
3201 static int ibmvscsis_rdma(struct ibmvscsis_cmd
*cmd
, struct scatterlist
*sg
,
3202 int nsg
, struct srp_direct_buf
*md
, int nmd
,
3203 enum dma_data_direction dir
, unsigned int bytes
)
3205 struct iu_entry
*iue
= cmd
->iue
;
3206 struct srp_target
*target
= iue
->target
;
3207 struct scsi_info
*vscsi
= target
->ldata
;
3208 struct scatterlist
*sgp
;
3209 dma_addr_t client_ioba
, server_ioba
;
3211 ulong client_len
, server_len
;
3226 if (client_len
== 0) {
3227 if (md_idx
>= nmd
) {
3228 dev_err(&vscsi
->dev
, "rdma: ran out of client memory descriptors\n");
3232 client_ioba
= be64_to_cpu(md
[md_idx
].va
);
3233 client_len
= be32_to_cpu(md
[md_idx
].len
);
3235 if (server_len
== 0) {
3237 dev_err(&vscsi
->dev
, "rdma: ran out of scatter/gather list\n");
3241 server_ioba
= sg_dma_address(sgp
);
3242 server_len
= sg_dma_len(sgp
);
3247 if (buf_len
> client_len
)
3248 buf_len
= client_len
;
3250 if (buf_len
> server_len
)
3251 buf_len
= server_len
;
3253 if (buf_len
> max_vdma_size
)
3254 buf_len
= max_vdma_size
;
3256 if (dir
== DMA_TO_DEVICE
) {
3257 /* read from client */
3258 rc
= h_copy_rdma(buf_len
,
3259 vscsi
->dds
.window
[REMOTE
].liobn
,
3261 vscsi
->dds
.window
[LOCAL
].liobn
,
3264 /* The h_copy_rdma will cause phyp, running in another
3265 * partition, to read memory, so we need to make sure
3266 * the data has been written out, hence these syncs.
3268 /* ensure that everything is in memory */
3270 /* ensure that memory has been made visible */
3272 rc
= h_copy_rdma(buf_len
,
3273 vscsi
->dds
.window
[LOCAL
].liobn
,
3275 vscsi
->dds
.window
[REMOTE
].liobn
,
3284 if (connection_broken(vscsi
)) {
3285 spin_lock_bh(&vscsi
->intr_lock
);
3287 (RESPONSE_Q_DOWN
| CLIENT_FAILED
);
3288 spin_unlock_bh(&vscsi
->intr_lock
);
3290 dev_err(&vscsi
->dev
, "rdma: h_copy_rdma failed, rc %ld\n",
3295 dev_err(&vscsi
->dev
, "rdma: unknown error %ld from h_copy_rdma\n",
3303 client_len
-= buf_len
;
3304 if (client_len
== 0)
3307 client_ioba
+= buf_len
;
3309 server_len
-= buf_len
;
3310 if (server_len
== 0)
3313 server_ioba
+= buf_len
;
3324 * ibmvscsis_handle_crq() - Handle CRQ
3325 * @data: Pointer to our adapter structure
3327 * Read the command elements from the command queue and copy the payloads
3328 * associated with the command elements to local memory and execute the
3331 * Note: this is an edge triggered interrupt. It can not be shared.
3333 static void ibmvscsis_handle_crq(unsigned long data
)
3335 struct scsi_info
*vscsi
= (struct scsi_info
*)data
;
3336 struct viosrp_crq
*crq
;
3341 spin_lock_bh(&vscsi
->intr_lock
);
3343 pr_debug("got interrupt\n");
3346 * if we are in a path where we are waiting for all pending commands
3347 * to complete because we received a transport event and anything in
3348 * the command queue is for a new connection, do nothing
3350 if (TARGET_STOP(vscsi
)) {
3351 vio_enable_interrupts(vscsi
->dma_dev
);
3353 pr_debug("handle_crq, don't process: flags 0x%x, state 0x%hx\n",
3354 vscsi
->flags
, vscsi
->state
);
3355 spin_unlock_bh(&vscsi
->intr_lock
);
3359 rc
= vscsi
->flags
& SCHEDULE_DISCONNECT
;
3360 crq
= vscsi
->cmd_q
.base_addr
+ vscsi
->cmd_q
.index
;
3366 * These are edege triggered interrupts. After dropping out of
3367 * the while loop, the code must check for work since an
3368 * interrupt could be lost, and an elment be left on the queue,
3372 vscsi
->cmd_q
.index
=
3373 (vscsi
->cmd_q
.index
+ 1) & vscsi
->cmd_q
.mask
;
3376 rc
= ibmvscsis_parse_command(vscsi
, crq
);
3378 if ((uint
)crq
->valid
== VALID_TRANS_EVENT
) {
3380 * must service the transport layer events even
3381 * in an error state, dont break out until all
3382 * the consecutive transport events have been
3385 rc
= ibmvscsis_trans_event(vscsi
, crq
);
3386 } else if (vscsi
->flags
& TRANS_EVENT
) {
3388 * if a transport event has occurred leave
3389 * everything but transport events on the queue
3391 * need to decrement the queue index so we can
3392 * look at the element again
3394 if (vscsi
->cmd_q
.index
)
3395 vscsi
->cmd_q
.index
-= 1;
3398 * index is at 0 it just wrapped.
3399 * have it index last element in q
3401 vscsi
->cmd_q
.index
= vscsi
->cmd_q
.mask
;
3406 crq
->valid
= INVALIDATE_CMD_RESP_EL
;
3408 crq
= vscsi
->cmd_q
.base_addr
+ vscsi
->cmd_q
.index
;
3415 vio_enable_interrupts(vscsi
->dma_dev
);
3417 pr_debug("handle_crq, reenabling interrupts\n");
3424 pr_debug("handle_crq, error: flags 0x%x, state 0x%hx, crq index 0x%x\n",
3425 vscsi
->flags
, vscsi
->state
, vscsi
->cmd_q
.index
);
3428 pr_debug("Leaving handle_crq: schedule_q empty %d, flags 0x%x, state 0x%hx\n",
3429 (int)list_empty(&vscsi
->schedule_q
), vscsi
->flags
,
3432 spin_unlock_bh(&vscsi
->intr_lock
);
3435 static int ibmvscsis_probe(struct vio_dev
*vdev
,
3436 const struct vio_device_id
*id
)
3438 struct scsi_info
*vscsi
;
3443 vscsi
= kzalloc(sizeof(*vscsi
), GFP_KERNEL
);
3446 pr_err("probe: allocation of adapter failed\n");
3450 vscsi
->dma_dev
= vdev
;
3451 vscsi
->dev
= vdev
->dev
;
3452 INIT_LIST_HEAD(&vscsi
->schedule_q
);
3453 INIT_LIST_HEAD(&vscsi
->waiting_rsp
);
3454 INIT_LIST_HEAD(&vscsi
->active_q
);
3456 snprintf(vscsi
->tport
.tport_name
, IBMVSCSIS_NAMELEN
, "%s",
3457 dev_name(&vdev
->dev
));
3459 pr_debug("probe tport_name: %s\n", vscsi
->tport
.tport_name
);
3461 rc
= read_dma_window(vscsi
);
3464 pr_debug("Probe: liobn 0x%x, riobn 0x%x\n",
3465 vscsi
->dds
.window
[LOCAL
].liobn
,
3466 vscsi
->dds
.window
[REMOTE
].liobn
);
3468 strcpy(vscsi
->eye
, "VSCSI ");
3469 strncat(vscsi
->eye
, vdev
->name
, MAX_EYE
);
3471 vscsi
->dds
.unit_id
= vdev
->unit_address
;
3472 strncpy(vscsi
->dds
.partition_name
, partition_name
,
3473 sizeof(vscsi
->dds
.partition_name
));
3474 vscsi
->dds
.partition_num
= partition_number
;
3476 spin_lock_bh(&ibmvscsis_dev_lock
);
3477 list_add_tail(&vscsi
->list
, &ibmvscsis_dev_list
);
3478 spin_unlock_bh(&ibmvscsis_dev_lock
);
3481 * TBD: How do we determine # of cmds to request? Do we know how
3482 * many "children" we have?
3484 vscsi
->request_limit
= INITIAL_SRP_LIMIT
;
3485 rc
= srp_target_alloc(&vscsi
->target
, &vdev
->dev
, vscsi
->request_limit
,
3490 vscsi
->target
.ldata
= vscsi
;
3492 rc
= ibmvscsis_alloc_cmds(vscsi
, vscsi
->request_limit
);
3494 dev_err(&vscsi
->dev
, "alloc_cmds failed, rc %d, num %d\n",
3495 rc
, vscsi
->request_limit
);
3500 * Note: the lock is used in freeing timers, so must initialize
3501 * first so that ordering in case of error is correct.
3503 spin_lock_init(&vscsi
->intr_lock
);
3505 rc
= ibmvscsis_alloctimer(vscsi
);
3507 dev_err(&vscsi
->dev
, "probe: alloctimer failed, rc %d\n", rc
);
3511 rc
= ibmvscsis_create_command_q(vscsi
, 256);
3513 dev_err(&vscsi
->dev
, "probe: create_command_q failed, rc %d\n",
3518 vscsi
->map_buf
= kzalloc(PAGE_SIZE
, GFP_KERNEL
);
3519 if (!vscsi
->map_buf
) {
3521 dev_err(&vscsi
->dev
, "probe: allocating cmd buffer failed\n");
3525 vscsi
->map_ioba
= dma_map_single(&vdev
->dev
, vscsi
->map_buf
, PAGE_SIZE
,
3527 if (dma_mapping_error(&vdev
->dev
, vscsi
->map_ioba
)) {
3529 dev_err(&vscsi
->dev
, "probe: error mapping command buffer\n");
3533 hrc
= h_vioctl(vscsi
->dds
.unit_id
, H_GET_PARTNER_INFO
,
3534 (u64
)vscsi
->map_ioba
| ((u64
)PAGE_SIZE
<< 32), 0, 0, 0,
3536 if (hrc
== H_SUCCESS
)
3537 vscsi
->client_data
.partition_number
=
3538 be64_to_cpu(*(u64
*)vscsi
->map_buf
);
3540 * We expect the VIOCTL to fail if we're configured as "any
3541 * client can connect" and the client isn't activated yet.
3542 * We'll make the call again when he sends an init msg.
3544 pr_debug("probe hrc %ld, client partition num %d\n",
3545 hrc
, vscsi
->client_data
.partition_number
);
3547 tasklet_init(&vscsi
->work_task
, ibmvscsis_handle_crq
,
3548 (unsigned long)vscsi
);
3550 init_completion(&vscsi
->wait_idle
);
3551 init_completion(&vscsi
->unconfig
);
3553 snprintf(wq_name
, 24, "ibmvscsis%s", dev_name(&vdev
->dev
));
3554 vscsi
->work_q
= create_workqueue(wq_name
);
3555 if (!vscsi
->work_q
) {
3557 dev_err(&vscsi
->dev
, "create_workqueue failed\n");
3561 rc
= request_irq(vdev
->irq
, ibmvscsis_interrupt
, 0, "ibmvscsis", vscsi
);
3564 dev_err(&vscsi
->dev
, "probe: request_irq failed, rc %d\n", rc
);
3568 vscsi
->state
= WAIT_ENABLED
;
3570 dev_set_drvdata(&vdev
->dev
, vscsi
);
3575 destroy_workqueue(vscsi
->work_q
);
3577 dma_unmap_single(&vdev
->dev
, vscsi
->map_ioba
, PAGE_SIZE
,
3580 kfree(vscsi
->map_buf
);
3582 tasklet_kill(&vscsi
->work_task
);
3583 ibmvscsis_unregister_command_q(vscsi
);
3584 ibmvscsis_destroy_command_q(vscsi
);
3586 ibmvscsis_freetimer(vscsi
);
3588 ibmvscsis_free_cmds(vscsi
);
3590 srp_target_free(&vscsi
->target
);
3592 spin_lock_bh(&ibmvscsis_dev_lock
);
3593 list_del(&vscsi
->list
);
3594 spin_unlock_bh(&ibmvscsis_dev_lock
);
3601 static int ibmvscsis_remove(struct vio_dev
*vdev
)
3603 struct scsi_info
*vscsi
= dev_get_drvdata(&vdev
->dev
);
3605 pr_debug("remove (%s)\n", dev_name(&vscsi
->dma_dev
->dev
));
3607 spin_lock_bh(&vscsi
->intr_lock
);
3608 ibmvscsis_post_disconnect(vscsi
, UNCONFIGURING
, 0);
3609 vscsi
->flags
|= CFG_SLEEPING
;
3610 spin_unlock_bh(&vscsi
->intr_lock
);
3611 wait_for_completion(&vscsi
->unconfig
);
3613 vio_disable_interrupts(vdev
);
3614 free_irq(vdev
->irq
, vscsi
);
3615 destroy_workqueue(vscsi
->work_q
);
3616 dma_unmap_single(&vdev
->dev
, vscsi
->map_ioba
, PAGE_SIZE
,
3618 kfree(vscsi
->map_buf
);
3619 tasklet_kill(&vscsi
->work_task
);
3620 ibmvscsis_destroy_command_q(vscsi
);
3621 ibmvscsis_freetimer(vscsi
);
3622 ibmvscsis_free_cmds(vscsi
);
3623 srp_target_free(&vscsi
->target
);
3624 spin_lock_bh(&ibmvscsis_dev_lock
);
3625 list_del(&vscsi
->list
);
3626 spin_unlock_bh(&ibmvscsis_dev_lock
);
3632 static ssize_t
system_id_show(struct device
*dev
,
3633 struct device_attribute
*attr
, char *buf
)
3635 return snprintf(buf
, PAGE_SIZE
, "%s\n", system_id
);
3638 static ssize_t
partition_number_show(struct device
*dev
,
3639 struct device_attribute
*attr
, char *buf
)
3641 return snprintf(buf
, PAGE_SIZE
, "%x\n", partition_number
);
3644 static ssize_t
unit_address_show(struct device
*dev
,
3645 struct device_attribute
*attr
, char *buf
)
3647 struct scsi_info
*vscsi
= container_of(dev
, struct scsi_info
, dev
);
3649 return snprintf(buf
, PAGE_SIZE
, "%x\n", vscsi
->dma_dev
->unit_address
);
3652 static int ibmvscsis_get_system_info(void)
3654 struct device_node
*rootdn
, *vdevdn
;
3655 const char *id
, *model
, *name
;
3658 rootdn
= of_find_node_by_path("/");
3662 model
= of_get_property(rootdn
, "model", NULL
);
3663 id
= of_get_property(rootdn
, "system-id", NULL
);
3665 snprintf(system_id
, sizeof(system_id
), "%s-%s", model
, id
);
3667 name
= of_get_property(rootdn
, "ibm,partition-name", NULL
);
3669 strncpy(partition_name
, name
, sizeof(partition_name
));
3671 num
= of_get_property(rootdn
, "ibm,partition-no", NULL
);
3673 partition_number
= of_read_number(num
, 1);
3675 of_node_put(rootdn
);
3677 vdevdn
= of_find_node_by_path("/vdevice");
3681 mvds
= of_get_property(vdevdn
, "ibm,max-virtual-dma-size",
3684 max_vdma_size
= *mvds
;
3685 of_node_put(vdevdn
);
3691 static char *ibmvscsis_get_fabric_name(void)
3696 static char *ibmvscsis_get_fabric_wwn(struct se_portal_group
*se_tpg
)
3698 struct ibmvscsis_tport
*tport
=
3699 container_of(se_tpg
, struct ibmvscsis_tport
, se_tpg
);
3701 return tport
->tport_name
;
3704 static u16
ibmvscsis_get_tag(struct se_portal_group
*se_tpg
)
3706 struct ibmvscsis_tport
*tport
=
3707 container_of(se_tpg
, struct ibmvscsis_tport
, se_tpg
);
3709 return tport
->tport_tpgt
;
3712 static u32
ibmvscsis_get_default_depth(struct se_portal_group
*se_tpg
)
3717 static int ibmvscsis_check_true(struct se_portal_group
*se_tpg
)
3722 static int ibmvscsis_check_false(struct se_portal_group
*se_tpg
)
3727 static u32
ibmvscsis_tpg_get_inst_index(struct se_portal_group
*se_tpg
)
3732 static int ibmvscsis_check_stop_free(struct se_cmd
*se_cmd
)
3734 return target_put_sess_cmd(se_cmd
);
3737 static void ibmvscsis_release_cmd(struct se_cmd
*se_cmd
)
3739 struct ibmvscsis_cmd
*cmd
= container_of(se_cmd
, struct ibmvscsis_cmd
,
3741 struct scsi_info
*vscsi
= cmd
->adapter
;
3743 spin_lock_bh(&vscsi
->intr_lock
);
3744 /* Remove from active_q */
3745 list_move_tail(&cmd
->list
, &vscsi
->waiting_rsp
);
3746 ibmvscsis_send_messages(vscsi
);
3747 spin_unlock_bh(&vscsi
->intr_lock
);
3750 static u32
ibmvscsis_sess_get_index(struct se_session
*se_sess
)
3755 static int ibmvscsis_write_pending(struct se_cmd
*se_cmd
)
3757 struct ibmvscsis_cmd
*cmd
= container_of(se_cmd
, struct ibmvscsis_cmd
,
3759 struct scsi_info
*vscsi
= cmd
->adapter
;
3760 struct iu_entry
*iue
= cmd
->iue
;
3764 * If CLIENT_FAILED OR RESPONSE_Q_DOWN, then just return success
3765 * since LIO can't do anything about it, and we dont want to
3766 * attempt an srp_transfer_data.
3768 if ((vscsi
->flags
& (CLIENT_FAILED
| RESPONSE_Q_DOWN
))) {
3769 pr_err("write_pending failed since: %d\n", vscsi
->flags
);
3773 rc
= srp_transfer_data(cmd
, &vio_iu(iue
)->srp
.cmd
, ibmvscsis_rdma
,
3776 pr_err("srp_transfer_data() failed: %d\n", rc
);
3780 * We now tell TCM to add this WRITE CDB directly into the TCM storage
3781 * object execution queue.
3783 target_execute_cmd(se_cmd
);
3787 static int ibmvscsis_write_pending_status(struct se_cmd
*se_cmd
)
3792 static void ibmvscsis_set_default_node_attrs(struct se_node_acl
*nacl
)
3796 static int ibmvscsis_get_cmd_state(struct se_cmd
*se_cmd
)
3801 static int ibmvscsis_queue_data_in(struct se_cmd
*se_cmd
)
3803 struct ibmvscsis_cmd
*cmd
= container_of(se_cmd
, struct ibmvscsis_cmd
,
3805 struct iu_entry
*iue
= cmd
->iue
;
3806 struct scsi_info
*vscsi
= cmd
->adapter
;
3811 rc
= srp_transfer_data(cmd
, &vio_iu(iue
)->srp
.cmd
, ibmvscsis_rdma
, 1,
3814 pr_err("srp_transfer_data failed: %d\n", rc
);
3815 sd
= se_cmd
->sense_buffer
;
3816 se_cmd
->scsi_sense_length
= 18;
3817 memset(se_cmd
->sense_buffer
, 0, se_cmd
->scsi_sense_length
);
3818 /* Logical Unit Communication Time-out asc/ascq = 0x0801 */
3819 scsi_build_sense_buffer(0, se_cmd
->sense_buffer
, MEDIUM_ERROR
,
3823 srp_build_response(vscsi
, cmd
, &len
);
3824 cmd
->rsp
.format
= SRP_FORMAT
;
3830 static int ibmvscsis_queue_status(struct se_cmd
*se_cmd
)
3832 struct ibmvscsis_cmd
*cmd
= container_of(se_cmd
, struct ibmvscsis_cmd
,
3834 struct scsi_info
*vscsi
= cmd
->adapter
;
3837 pr_debug("queue_status %p\n", se_cmd
);
3839 srp_build_response(vscsi
, cmd
, &len
);
3840 cmd
->rsp
.format
= SRP_FORMAT
;
3846 static void ibmvscsis_queue_tm_rsp(struct se_cmd
*se_cmd
)
3848 struct ibmvscsis_cmd
*cmd
= container_of(se_cmd
, struct ibmvscsis_cmd
,
3850 struct scsi_info
*vscsi
= cmd
->adapter
;
3851 struct ibmvscsis_cmd
*cmd_itr
;
3852 struct iu_entry
*iue
= iue
= cmd
->iue
;
3853 struct srp_tsk_mgmt
*srp_tsk
= &vio_iu(iue
)->srp
.tsk_mgmt
;
3854 u64 tag_to_abort
= be64_to_cpu(srp_tsk
->task_tag
);
3857 pr_debug("queue_tm_rsp %p, status %d\n",
3858 se_cmd
, (int)se_cmd
->se_tmr_req
->response
);
3860 if (srp_tsk
->tsk_mgmt_func
== SRP_TSK_ABORT_TASK
&&
3861 cmd
->se_cmd
.se_tmr_req
->response
== TMR_TASK_DOES_NOT_EXIST
) {
3862 spin_lock_bh(&vscsi
->intr_lock
);
3863 list_for_each_entry(cmd_itr
, &vscsi
->active_q
, list
) {
3864 if (tag_to_abort
== cmd_itr
->se_cmd
.tag
) {
3865 cmd_itr
->abort_cmd
= cmd
;
3866 cmd
->flags
|= DELAY_SEND
;
3870 spin_unlock_bh(&vscsi
->intr_lock
);
3873 srp_build_response(vscsi
, cmd
, &len
);
3874 cmd
->rsp
.format
= SRP_FORMAT
;
3878 static void ibmvscsis_aborted_task(struct se_cmd
*se_cmd
)
3880 pr_debug("ibmvscsis_aborted_task %p task_tag: %llu\n",
3881 se_cmd
, se_cmd
->tag
);
3884 static struct se_wwn
*ibmvscsis_make_tport(struct target_fabric_configfs
*tf
,
3885 struct config_group
*group
,
3888 struct ibmvscsis_tport
*tport
;
3890 tport
= ibmvscsis_lookup_port(name
);
3892 tport
->tport_proto_id
= SCSI_PROTOCOL_SRP
;
3893 pr_debug("make_tport(%s), pointer:%p, tport_id:%x\n",
3894 name
, tport
, tport
->tport_proto_id
);
3895 return &tport
->tport_wwn
;
3898 return ERR_PTR(-EINVAL
);
3901 static void ibmvscsis_drop_tport(struct se_wwn
*wwn
)
3903 struct ibmvscsis_tport
*tport
= container_of(wwn
,
3904 struct ibmvscsis_tport
,
3907 pr_debug("drop_tport(%s)\n",
3908 config_item_name(&tport
->tport_wwn
.wwn_group
.cg_item
));
3911 static struct se_portal_group
*ibmvscsis_make_tpg(struct se_wwn
*wwn
,
3912 struct config_group
*group
,
3915 struct ibmvscsis_tport
*tport
=
3916 container_of(wwn
, struct ibmvscsis_tport
, tport_wwn
);
3920 if (strstr(name
, "tpgt_") != name
)
3921 return ERR_PTR(-EINVAL
);
3922 rc
= kstrtou16(name
+ 5, 0, &tpgt
);
3925 tport
->tport_tpgt
= tpgt
;
3927 tport
->releasing
= false;
3929 rc
= core_tpg_register(&tport
->tport_wwn
, &tport
->se_tpg
,
3930 tport
->tport_proto_id
);
3934 return &tport
->se_tpg
;
3937 static void ibmvscsis_drop_tpg(struct se_portal_group
*se_tpg
)
3939 struct ibmvscsis_tport
*tport
= container_of(se_tpg
,
3940 struct ibmvscsis_tport
,
3943 tport
->releasing
= true;
3944 tport
->enabled
= false;
3947 * Release the virtual I_T Nexus for this ibmvscsis TPG
3949 ibmvscsis_drop_nexus(tport
);
3951 * Deregister the se_tpg from TCM..
3953 core_tpg_deregister(se_tpg
);
3956 static ssize_t
ibmvscsis_wwn_version_show(struct config_item
*item
,
3959 return scnprintf(page
, PAGE_SIZE
, "%s\n", IBMVSCSIS_VERSION
);
3961 CONFIGFS_ATTR_RO(ibmvscsis_wwn_
, version
);
3963 static struct configfs_attribute
*ibmvscsis_wwn_attrs
[] = {
3964 &ibmvscsis_wwn_attr_version
,
3968 static ssize_t
ibmvscsis_tpg_enable_show(struct config_item
*item
,
3971 struct se_portal_group
*se_tpg
= to_tpg(item
);
3972 struct ibmvscsis_tport
*tport
= container_of(se_tpg
,
3973 struct ibmvscsis_tport
,
3976 return snprintf(page
, PAGE_SIZE
, "%d\n", (tport
->enabled
) ? 1 : 0);
3979 static ssize_t
ibmvscsis_tpg_enable_store(struct config_item
*item
,
3980 const char *page
, size_t count
)
3982 struct se_portal_group
*se_tpg
= to_tpg(item
);
3983 struct ibmvscsis_tport
*tport
= container_of(se_tpg
,
3984 struct ibmvscsis_tport
,
3986 struct scsi_info
*vscsi
= container_of(tport
, struct scsi_info
, tport
);
3991 rc
= kstrtoul(page
, 0, &tmp
);
3993 pr_err("Unable to extract srpt_tpg_store_enable\n");
3997 if ((tmp
!= 0) && (tmp
!= 1)) {
3998 pr_err("Illegal value for srpt_tpg_store_enable\n");
4003 spin_lock_bh(&vscsi
->intr_lock
);
4004 tport
->enabled
= true;
4005 lrc
= ibmvscsis_enable_change_state(vscsi
);
4007 pr_err("enable_change_state failed, rc %ld state %d\n",
4009 spin_unlock_bh(&vscsi
->intr_lock
);
4011 spin_lock_bh(&vscsi
->intr_lock
);
4012 tport
->enabled
= false;
4013 /* This simulates the server going down */
4014 ibmvscsis_post_disconnect(vscsi
, ERR_DISCONNECT
, 0);
4015 spin_unlock_bh(&vscsi
->intr_lock
);
4018 pr_debug("tpg_enable_store, tmp %ld, state %d\n", tmp
, vscsi
->state
);
4022 CONFIGFS_ATTR(ibmvscsis_tpg_
, enable
);
4024 static struct configfs_attribute
*ibmvscsis_tpg_attrs
[] = {
4025 &ibmvscsis_tpg_attr_enable
,
4029 static const struct target_core_fabric_ops ibmvscsis_ops
= {
4030 .module
= THIS_MODULE
,
4031 .name
= "ibmvscsis",
4032 .max_data_sg_nents
= MAX_TXU
/ PAGE_SIZE
,
4033 .get_fabric_name
= ibmvscsis_get_fabric_name
,
4034 .tpg_get_wwn
= ibmvscsis_get_fabric_wwn
,
4035 .tpg_get_tag
= ibmvscsis_get_tag
,
4036 .tpg_get_default_depth
= ibmvscsis_get_default_depth
,
4037 .tpg_check_demo_mode
= ibmvscsis_check_true
,
4038 .tpg_check_demo_mode_cache
= ibmvscsis_check_true
,
4039 .tpg_check_demo_mode_write_protect
= ibmvscsis_check_false
,
4040 .tpg_check_prod_mode_write_protect
= ibmvscsis_check_false
,
4041 .tpg_get_inst_index
= ibmvscsis_tpg_get_inst_index
,
4042 .check_stop_free
= ibmvscsis_check_stop_free
,
4043 .release_cmd
= ibmvscsis_release_cmd
,
4044 .sess_get_index
= ibmvscsis_sess_get_index
,
4045 .write_pending
= ibmvscsis_write_pending
,
4046 .write_pending_status
= ibmvscsis_write_pending_status
,
4047 .set_default_node_attributes
= ibmvscsis_set_default_node_attrs
,
4048 .get_cmd_state
= ibmvscsis_get_cmd_state
,
4049 .queue_data_in
= ibmvscsis_queue_data_in
,
4050 .queue_status
= ibmvscsis_queue_status
,
4051 .queue_tm_rsp
= ibmvscsis_queue_tm_rsp
,
4052 .aborted_task
= ibmvscsis_aborted_task
,
4054 * Setup function pointers for logic in target_core_fabric_configfs.c
4056 .fabric_make_wwn
= ibmvscsis_make_tport
,
4057 .fabric_drop_wwn
= ibmvscsis_drop_tport
,
4058 .fabric_make_tpg
= ibmvscsis_make_tpg
,
4059 .fabric_drop_tpg
= ibmvscsis_drop_tpg
,
4061 .tfc_wwn_attrs
= ibmvscsis_wwn_attrs
,
4062 .tfc_tpg_base_attrs
= ibmvscsis_tpg_attrs
,
4065 static void ibmvscsis_dev_release(struct device
*dev
) {};
4067 static struct device_attribute dev_attr_system_id
=
4068 __ATTR(system_id
, S_IRUGO
, system_id_show
, NULL
);
4070 static struct device_attribute dev_attr_partition_number
=
4071 __ATTR(partition_number
, S_IRUGO
, partition_number_show
, NULL
);
4073 static struct device_attribute dev_attr_unit_address
=
4074 __ATTR(unit_address
, S_IRUGO
, unit_address_show
, NULL
);
4076 static struct attribute
*ibmvscsis_dev_attrs
[] = {
4077 &dev_attr_system_id
.attr
,
4078 &dev_attr_partition_number
.attr
,
4079 &dev_attr_unit_address
.attr
,
4081 ATTRIBUTE_GROUPS(ibmvscsis_dev
);
4083 static struct class ibmvscsis_class
= {
4084 .name
= "ibmvscsis",
4085 .dev_release
= ibmvscsis_dev_release
,
4086 .dev_groups
= ibmvscsis_dev_groups
,
4089 static struct vio_device_id ibmvscsis_device_table
[] = {
4090 { "v-scsi-host", "IBM,v-scsi-host" },
4093 MODULE_DEVICE_TABLE(vio
, ibmvscsis_device_table
);
4095 static struct vio_driver ibmvscsis_driver
= {
4096 .name
= "ibmvscsis",
4097 .id_table
= ibmvscsis_device_table
,
4098 .probe
= ibmvscsis_probe
,
4099 .remove
= ibmvscsis_remove
,
4103 * ibmvscsis_init() - Kernel Module initialization
4105 * Note: vio_register_driver() registers callback functions, and at least one
4106 * of those callback functions calls TCM - Linux IO Target Subsystem, thus
4107 * the SCSI Target template must be registered before vio_register_driver()
4110 static int __init
ibmvscsis_init(void)
4114 rc
= ibmvscsis_get_system_info();
4116 pr_err("rc %d from get_system_info\n", rc
);
4120 rc
= class_register(&ibmvscsis_class
);
4122 pr_err("failed class register\n");
4126 rc
= target_register_template(&ibmvscsis_ops
);
4128 pr_err("rc %d from target_register_template\n", rc
);
4129 goto unregister_class
;
4132 rc
= vio_register_driver(&ibmvscsis_driver
);
4134 pr_err("rc %d from vio_register_driver\n", rc
);
4135 goto unregister_target
;
4141 target_unregister_template(&ibmvscsis_ops
);
4143 class_unregister(&ibmvscsis_class
);
4148 static void __exit
ibmvscsis_exit(void)
4150 pr_info("Unregister IBM virtual SCSI host driver\n");
4151 vio_unregister_driver(&ibmvscsis_driver
);
4152 target_unregister_template(&ibmvscsis_ops
);
4153 class_unregister(&ibmvscsis_class
);
4156 MODULE_DESCRIPTION("IBMVSCSIS fabric driver");
4157 MODULE_AUTHOR("Bryant G. Ly and Michael Cyr");
4158 MODULE_LICENSE("GPL");
4159 MODULE_VERSION(IBMVSCSIS_VERSION
);
4160 module_init(ibmvscsis_init
);
4161 module_exit(ibmvscsis_exit
);