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