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