[SCSI] libsas: remove ata_port.lock management duties from lldds
[linux-2.6.git] / drivers / scsi / isci / task.c
1 /*
2  * This file is provided under a dual BSD/GPLv2 license.  When using or
3  * redistributing this file, you may do so under either license.
4  *
5  * GPL LICENSE SUMMARY
6  *
7  * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of version 2 of the GNU General Public License as
11  * published by the Free Software Foundation.
12  *
13  * This program is distributed in the hope that it will be useful, but
14  * WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
21  * The full GNU General Public License is included in this distribution
22  * in the file called LICENSE.GPL.
23  *
24  * BSD LICENSE
25  *
26  * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
27  * All rights reserved.
28  *
29  * Redistribution and use in source and binary forms, with or without
30  * modification, are permitted provided that the following conditions
31  * are met:
32  *
33  *   * Redistributions of source code must retain the above copyright
34  *     notice, this list of conditions and the following disclaimer.
35  *   * Redistributions in binary form must reproduce the above copyright
36  *     notice, this list of conditions and the following disclaimer in
37  *     the documentation and/or other materials provided with the
38  *     distribution.
39  *   * Neither the name of Intel Corporation nor the names of its
40  *     contributors may be used to endorse or promote products derived
41  *     from this software without specific prior written permission.
42  *
43  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
44  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
45  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
46  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
47  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
48  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
49  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
50  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
51  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
52  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
53  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
54  */
55
56 #include <linux/completion.h>
57 #include <linux/irqflags.h>
58 #include "sas.h"
59 #include <scsi/libsas.h>
60 #include "remote_device.h"
61 #include "remote_node_context.h"
62 #include "isci.h"
63 #include "request.h"
64 #include "task.h"
65 #include "host.h"
66
67 /**
68 * isci_task_refuse() - complete the request to the upper layer driver in
69 *     the case where an I/O needs to be completed back in the submit path.
70 * @ihost: host on which the the request was queued
71 * @task: request to complete
72 * @response: response code for the completed task.
73 * @status: status code for the completed task.
74 *
75 */
76 static void isci_task_refuse(struct isci_host *ihost, struct sas_task *task,
77                              enum service_response response,
78                              enum exec_status status)
79
80 {
81         enum isci_completion_selection disposition;
82
83         disposition = isci_perform_normal_io_completion;
84         disposition = isci_task_set_completion_status(task, response, status,
85                                                       disposition);
86
87         /* Tasks aborted specifically by a call to the lldd_abort_task
88          * function should not be completed to the host in the regular path.
89          */
90         switch (disposition) {
91         case isci_perform_normal_io_completion:
92                 /* Normal notification (task_done) */
93                 dev_dbg(&ihost->pdev->dev,
94                         "%s: Normal - task = %p, response=%d, "
95                         "status=%d\n",
96                         __func__, task, response, status);
97
98                 task->lldd_task = NULL;
99                 task->task_done(task);
100                 break;
101
102         case isci_perform_aborted_io_completion:
103                 /*
104                  * No notification because this request is already in the
105                  * abort path.
106                  */
107                 dev_dbg(&ihost->pdev->dev,
108                         "%s: Aborted - task = %p, response=%d, "
109                         "status=%d\n",
110                         __func__, task, response, status);
111                 break;
112
113         case isci_perform_error_io_completion:
114                 /* Use sas_task_abort */
115                 dev_dbg(&ihost->pdev->dev,
116                         "%s: Error - task = %p, response=%d, "
117                         "status=%d\n",
118                         __func__, task, response, status);
119                 sas_task_abort(task);
120                 break;
121
122         default:
123                 dev_dbg(&ihost->pdev->dev,
124                         "%s: isci task notification default case!",
125                         __func__);
126                 sas_task_abort(task);
127                 break;
128         }
129 }
130
131 #define for_each_sas_task(num, task) \
132         for (; num > 0; num--,\
133              task = list_entry(task->list.next, struct sas_task, list))
134
135
136 static inline int isci_device_io_ready(struct isci_remote_device *idev,
137                                        struct sas_task *task)
138 {
139         return idev ? test_bit(IDEV_IO_READY, &idev->flags) ||
140                       (test_bit(IDEV_IO_NCQERROR, &idev->flags) &&
141                        isci_task_is_ncq_recovery(task))
142                     : 0;
143 }
144 /**
145  * isci_task_execute_task() - This function is one of the SAS Domain Template
146  *    functions. This function is called by libsas to send a task down to
147  *    hardware.
148  * @task: This parameter specifies the SAS task to send.
149  * @num: This parameter specifies the number of tasks to queue.
150  * @gfp_flags: This parameter specifies the context of this call.
151  *
152  * status, zero indicates success.
153  */
154 int isci_task_execute_task(struct sas_task *task, int num, gfp_t gfp_flags)
155 {
156         struct isci_host *ihost = dev_to_ihost(task->dev);
157         struct isci_remote_device *idev;
158         unsigned long flags;
159         bool io_ready;
160         u16 tag;
161
162         dev_dbg(&ihost->pdev->dev, "%s: num=%d\n", __func__, num);
163
164         for_each_sas_task(num, task) {
165                 enum sci_status status = SCI_FAILURE;
166
167                 spin_lock_irqsave(&ihost->scic_lock, flags);
168                 idev = isci_lookup_device(task->dev);
169                 io_ready = isci_device_io_ready(idev, task);
170                 tag = isci_alloc_tag(ihost);
171                 spin_unlock_irqrestore(&ihost->scic_lock, flags);
172
173                 dev_dbg(&ihost->pdev->dev,
174                         "task: %p, num: %d dev: %p idev: %p:%#lx cmd = %p\n",
175                         task, num, task->dev, idev, idev ? idev->flags : 0,
176                         task->uldd_task);
177
178                 if (!idev) {
179                         isci_task_refuse(ihost, task, SAS_TASK_UNDELIVERED,
180                                          SAS_DEVICE_UNKNOWN);
181                 } else if (!io_ready || tag == SCI_CONTROLLER_INVALID_IO_TAG) {
182                         /* Indicate QUEUE_FULL so that the scsi midlayer
183                          * retries.
184                           */
185                         isci_task_refuse(ihost, task, SAS_TASK_COMPLETE,
186                                          SAS_QUEUE_FULL);
187                 } else {
188                         /* There is a device and it's ready for I/O. */
189                         spin_lock_irqsave(&task->task_state_lock, flags);
190
191                         if (task->task_state_flags & SAS_TASK_STATE_ABORTED) {
192                                 /* The I/O was aborted. */
193                                 spin_unlock_irqrestore(&task->task_state_lock,
194                                                        flags);
195
196                                 isci_task_refuse(ihost, task,
197                                                  SAS_TASK_UNDELIVERED,
198                                                  SAM_STAT_TASK_ABORTED);
199                         } else {
200                                 task->task_state_flags |= SAS_TASK_AT_INITIATOR;
201                                 spin_unlock_irqrestore(&task->task_state_lock, flags);
202
203                                 /* build and send the request. */
204                                 status = isci_request_execute(ihost, idev, task, tag);
205
206                                 if (status != SCI_SUCCESS) {
207
208                                         spin_lock_irqsave(&task->task_state_lock, flags);
209                                         /* Did not really start this command. */
210                                         task->task_state_flags &= ~SAS_TASK_AT_INITIATOR;
211                                         spin_unlock_irqrestore(&task->task_state_lock, flags);
212
213                                         if (test_bit(IDEV_GONE, &idev->flags)) {
214
215                                                 /* Indicate that the device
216                                                  * is gone.
217                                                  */
218                                                 isci_task_refuse(ihost, task,
219                                                         SAS_TASK_UNDELIVERED,
220                                                         SAS_DEVICE_UNKNOWN);
221                                         } else {
222                                                 /* Indicate QUEUE_FULL so that
223                                                  * the scsi midlayer retries.
224                                                  * If the request failed for
225                                                  * remote device reasons, it
226                                                  * gets returned as
227                                                  * SAS_TASK_UNDELIVERED next
228                                                  * time through.
229                                                  */
230                                                 isci_task_refuse(ihost, task,
231                                                         SAS_TASK_COMPLETE,
232                                                         SAS_QUEUE_FULL);
233                                         }
234                                 }
235                         }
236                 }
237                 if (status != SCI_SUCCESS && tag != SCI_CONTROLLER_INVALID_IO_TAG) {
238                         spin_lock_irqsave(&ihost->scic_lock, flags);
239                         /* command never hit the device, so just free
240                          * the tci and skip the sequence increment
241                          */
242                         isci_tci_free(ihost, ISCI_TAG_TCI(tag));
243                         spin_unlock_irqrestore(&ihost->scic_lock, flags);
244                 }
245                 isci_put_device(idev);
246         }
247         return 0;
248 }
249
250 static enum sci_status isci_sata_management_task_request_build(struct isci_request *ireq)
251 {
252         struct isci_tmf *isci_tmf;
253         enum sci_status status;
254
255         if (!test_bit(IREQ_TMF, &ireq->flags))
256                 return SCI_FAILURE;
257
258         isci_tmf = isci_request_access_tmf(ireq);
259
260         switch (isci_tmf->tmf_code) {
261
262         case isci_tmf_sata_srst_high:
263         case isci_tmf_sata_srst_low: {
264                 struct host_to_dev_fis *fis = &ireq->stp.cmd;
265
266                 memset(fis, 0, sizeof(*fis));
267
268                 fis->fis_type  =  0x27;
269                 fis->flags     &= ~0x80;
270                 fis->flags     &= 0xF0;
271                 if (isci_tmf->tmf_code == isci_tmf_sata_srst_high)
272                         fis->control |= ATA_SRST;
273                 else
274                         fis->control &= ~ATA_SRST;
275                 break;
276         }
277         /* other management commnd go here... */
278         default:
279                 return SCI_FAILURE;
280         }
281
282         /* core builds the protocol specific request
283          *  based on the h2d fis.
284          */
285         status = sci_task_request_construct_sata(ireq);
286
287         return status;
288 }
289
290 static struct isci_request *isci_task_request_build(struct isci_host *ihost,
291                                                     struct isci_remote_device *idev,
292                                                     u16 tag, struct isci_tmf *isci_tmf)
293 {
294         enum sci_status status = SCI_FAILURE;
295         struct isci_request *ireq = NULL;
296         struct domain_device *dev;
297
298         dev_dbg(&ihost->pdev->dev,
299                 "%s: isci_tmf = %p\n", __func__, isci_tmf);
300
301         dev = idev->domain_dev;
302
303         /* do common allocation and init of request object. */
304         ireq = isci_tmf_request_from_tag(ihost, isci_tmf, tag);
305         if (!ireq)
306                 return NULL;
307
308         /* let the core do it's construct. */
309         status = sci_task_request_construct(ihost, idev, tag,
310                                              ireq);
311
312         if (status != SCI_SUCCESS) {
313                 dev_warn(&ihost->pdev->dev,
314                          "%s: sci_task_request_construct failed - "
315                          "status = 0x%x\n",
316                          __func__,
317                          status);
318                 return NULL;
319         }
320
321         /* XXX convert to get this from task->tproto like other drivers */
322         if (dev->dev_type == SAS_END_DEV) {
323                 isci_tmf->proto = SAS_PROTOCOL_SSP;
324                 status = sci_task_request_construct_ssp(ireq);
325                 if (status != SCI_SUCCESS)
326                         return NULL;
327         }
328
329         if (dev->dev_type == SATA_DEV || (dev->tproto & SAS_PROTOCOL_STP)) {
330                 isci_tmf->proto = SAS_PROTOCOL_SATA;
331                 status = isci_sata_management_task_request_build(ireq);
332
333                 if (status != SCI_SUCCESS)
334                         return NULL;
335         }
336         return ireq;
337 }
338
339 /**
340 * isci_request_mark_zombie() - This function must be called with scic_lock held.
341 */
342 static void isci_request_mark_zombie(struct isci_host *ihost, struct isci_request *ireq)
343 {
344         struct completion *tmf_completion = NULL;
345         struct completion *req_completion;
346
347         /* Set the request state to "dead". */
348         ireq->status = dead;
349
350         req_completion = ireq->io_request_completion;
351         ireq->io_request_completion = NULL;
352
353         if (test_bit(IREQ_TMF, &ireq->flags)) {
354                 /* Break links with the TMF request. */
355                 struct isci_tmf *tmf = isci_request_access_tmf(ireq);
356
357                 /* In the case where a task request is dying,
358                  * the thread waiting on the complete will sit and
359                  * timeout unless we wake it now.  Since the TMF
360                  * has a default error status, complete it here
361                  * to wake the waiting thread.
362                  */
363                 if (tmf) {
364                         tmf_completion = tmf->complete;
365                         tmf->complete = NULL;
366                 }
367                 ireq->ttype_ptr.tmf_task_ptr = NULL;
368                 dev_dbg(&ihost->pdev->dev, "%s: tmf_code %d, managed tag %#x\n",
369                         __func__, tmf->tmf_code, tmf->io_tag);
370         } else {
371                 /* Break links with the sas_task - the callback is done
372                  * elsewhere.
373                  */
374                 struct sas_task *task = isci_request_access_task(ireq);
375
376                 if (task)
377                         task->lldd_task = NULL;
378
379                 ireq->ttype_ptr.io_task_ptr = NULL;
380         }
381
382         dev_warn(&ihost->pdev->dev, "task context unrecoverable (tag: %#x)\n",
383                  ireq->io_tag);
384
385         /* Don't force waiting threads to timeout. */
386         if (req_completion)
387                 complete(req_completion);
388
389         if (tmf_completion != NULL)
390                 complete(tmf_completion);
391 }
392
393 static int isci_task_execute_tmf(struct isci_host *ihost,
394                                  struct isci_remote_device *idev,
395                                  struct isci_tmf *tmf, unsigned long timeout_ms)
396 {
397         DECLARE_COMPLETION_ONSTACK(completion);
398         enum sci_task_status status = SCI_TASK_FAILURE;
399         struct isci_request *ireq;
400         int ret = TMF_RESP_FUNC_FAILED;
401         unsigned long flags;
402         unsigned long timeleft;
403         u16 tag;
404
405         spin_lock_irqsave(&ihost->scic_lock, flags);
406         tag = isci_alloc_tag(ihost);
407         spin_unlock_irqrestore(&ihost->scic_lock, flags);
408
409         if (tag == SCI_CONTROLLER_INVALID_IO_TAG)
410                 return ret;
411
412         /* sanity check, return TMF_RESP_FUNC_FAILED
413          * if the device is not there and ready.
414          */
415         if (!idev ||
416             (!test_bit(IDEV_IO_READY, &idev->flags) &&
417              !test_bit(IDEV_IO_NCQERROR, &idev->flags))) {
418                 dev_dbg(&ihost->pdev->dev,
419                         "%s: idev = %p not ready (%#lx)\n",
420                         __func__,
421                         idev, idev ? idev->flags : 0);
422                 goto err_tci;
423         } else
424                 dev_dbg(&ihost->pdev->dev,
425                         "%s: idev = %p\n",
426                         __func__, idev);
427
428         /* Assign the pointer to the TMF's completion kernel wait structure. */
429         tmf->complete = &completion;
430         tmf->status = SCI_FAILURE_TIMEOUT;
431
432         ireq = isci_task_request_build(ihost, idev, tag, tmf);
433         if (!ireq)
434                 goto err_tci;
435
436         spin_lock_irqsave(&ihost->scic_lock, flags);
437
438         /* start the TMF io. */
439         status = sci_controller_start_task(ihost, idev, ireq);
440
441         if (status != SCI_TASK_SUCCESS) {
442                 dev_dbg(&ihost->pdev->dev,
443                          "%s: start_io failed - status = 0x%x, request = %p\n",
444                          __func__,
445                          status,
446                          ireq);
447                 spin_unlock_irqrestore(&ihost->scic_lock, flags);
448                 goto err_tci;
449         }
450
451         if (tmf->cb_state_func != NULL)
452                 tmf->cb_state_func(isci_tmf_started, tmf, tmf->cb_data);
453
454         isci_request_change_state(ireq, started);
455
456         /* add the request to the remote device request list. */
457         list_add(&ireq->dev_node, &idev->reqs_in_process);
458
459         spin_unlock_irqrestore(&ihost->scic_lock, flags);
460
461         /* Wait for the TMF to complete, or a timeout. */
462         timeleft = wait_for_completion_timeout(&completion,
463                                                msecs_to_jiffies(timeout_ms));
464
465         if (timeleft == 0) {
466                 /* The TMF did not complete - this could be because
467                  * of an unplug.  Terminate the TMF request now.
468                  */
469                 spin_lock_irqsave(&ihost->scic_lock, flags);
470
471                 if (tmf->cb_state_func != NULL)
472                         tmf->cb_state_func(isci_tmf_timed_out, tmf,
473                                            tmf->cb_data);
474
475                 sci_controller_terminate_request(ihost, idev, ireq);
476
477                 spin_unlock_irqrestore(&ihost->scic_lock, flags);
478
479                 timeleft = wait_for_completion_timeout(
480                         &completion,
481                         msecs_to_jiffies(ISCI_TERMINATION_TIMEOUT_MSEC));
482
483                 if (!timeleft) {
484                         /* Strange condition - the termination of the TMF
485                          * request timed-out.
486                          */
487                         spin_lock_irqsave(&ihost->scic_lock, flags);
488
489                         /* If the TMF status has not changed, kill it. */
490                         if (tmf->status == SCI_FAILURE_TIMEOUT)
491                                 isci_request_mark_zombie(ihost, ireq);
492
493                         spin_unlock_irqrestore(&ihost->scic_lock, flags);
494                 }
495         }
496
497         isci_print_tmf(ihost, tmf);
498
499         if (tmf->status == SCI_SUCCESS)
500                 ret =  TMF_RESP_FUNC_COMPLETE;
501         else if (tmf->status == SCI_FAILURE_IO_RESPONSE_VALID) {
502                 dev_dbg(&ihost->pdev->dev,
503                         "%s: tmf.status == "
504                         "SCI_FAILURE_IO_RESPONSE_VALID\n",
505                         __func__);
506                 ret =  TMF_RESP_FUNC_COMPLETE;
507         }
508         /* Else - leave the default "failed" status alone. */
509
510         dev_dbg(&ihost->pdev->dev,
511                 "%s: completed request = %p\n",
512                 __func__,
513                 ireq);
514
515         return ret;
516
517  err_tci:
518         spin_lock_irqsave(&ihost->scic_lock, flags);
519         isci_tci_free(ihost, ISCI_TAG_TCI(tag));
520         spin_unlock_irqrestore(&ihost->scic_lock, flags);
521
522         return ret;
523 }
524
525 static void isci_task_build_tmf(struct isci_tmf *tmf,
526                                 enum isci_tmf_function_codes code,
527                                 void (*tmf_sent_cb)(enum isci_tmf_cb_state,
528                                                     struct isci_tmf *,
529                                                     void *),
530                                 void *cb_data)
531 {
532         memset(tmf, 0, sizeof(*tmf));
533
534         tmf->tmf_code      = code;
535         tmf->cb_state_func = tmf_sent_cb;
536         tmf->cb_data       = cb_data;
537 }
538
539 static void isci_task_build_abort_task_tmf(struct isci_tmf *tmf,
540                                            enum isci_tmf_function_codes code,
541                                            void (*tmf_sent_cb)(enum isci_tmf_cb_state,
542                                                                struct isci_tmf *,
543                                                                void *),
544                                            struct isci_request *old_request)
545 {
546         isci_task_build_tmf(tmf, code, tmf_sent_cb, old_request);
547         tmf->io_tag = old_request->io_tag;
548 }
549
550 /**
551  * isci_task_validate_request_to_abort() - This function checks the given I/O
552  *    against the "started" state.  If the request is still "started", it's
553  *    state is changed to aborted. NOTE: isci_host->scic_lock MUST BE HELD
554  *    BEFORE CALLING THIS FUNCTION.
555  * @isci_request: This parameter specifies the request object to control.
556  * @isci_host: This parameter specifies the ISCI host object
557  * @isci_device: This is the device to which the request is pending.
558  * @aborted_io_completion: This is a completion structure that will be added to
559  *    the request in case it is changed to aborting; this completion is
560  *    triggered when the request is fully completed.
561  *
562  * Either "started" on successful change of the task status to "aborted", or
563  * "unallocated" if the task cannot be controlled.
564  */
565 static enum isci_request_status isci_task_validate_request_to_abort(
566         struct isci_request *isci_request,
567         struct isci_host *isci_host,
568         struct isci_remote_device *isci_device,
569         struct completion *aborted_io_completion)
570 {
571         enum isci_request_status old_state = unallocated;
572
573         /* Only abort the task if it's in the
574          *  device's request_in_process list
575          */
576         if (isci_request && !list_empty(&isci_request->dev_node)) {
577                 old_state = isci_request_change_started_to_aborted(
578                         isci_request, aborted_io_completion);
579
580         }
581
582         return old_state;
583 }
584
585 static int isci_request_is_dealloc_managed(enum isci_request_status stat)
586 {
587         switch (stat) {
588         case aborted:
589         case aborting:
590         case terminating:
591         case completed:
592         case dead:
593                 return true;
594         default:
595                 return false;
596         }
597 }
598
599 /**
600  * isci_terminate_request_core() - This function will terminate the given
601  *    request, and wait for it to complete.  This function must only be called
602  *    from a thread that can wait.  Note that the request is terminated and
603  *    completed (back to the host, if started there).
604  * @ihost: This SCU.
605  * @idev: The target.
606  * @isci_request: The I/O request to be terminated.
607  *
608  */
609 static void isci_terminate_request_core(struct isci_host *ihost,
610                                         struct isci_remote_device *idev,
611                                         struct isci_request *isci_request)
612 {
613         enum sci_status status      = SCI_SUCCESS;
614         bool was_terminated         = false;
615         bool needs_cleanup_handling = false;
616         unsigned long     flags;
617         unsigned long     termination_completed = 1;
618         struct completion *io_request_completion;
619
620         dev_dbg(&ihost->pdev->dev,
621                 "%s: device = %p; request = %p\n",
622                 __func__, idev, isci_request);
623
624         spin_lock_irqsave(&ihost->scic_lock, flags);
625
626         io_request_completion = isci_request->io_request_completion;
627
628         /* Note that we are not going to control
629          * the target to abort the request.
630          */
631         set_bit(IREQ_COMPLETE_IN_TARGET, &isci_request->flags);
632
633         /* Make sure the request wasn't just sitting around signalling
634          * device condition (if the request handle is NULL, then the
635          * request completed but needed additional handling here).
636          */
637         if (!test_bit(IREQ_TERMINATED, &isci_request->flags)) {
638                 was_terminated = true;
639                 needs_cleanup_handling = true;
640                 status = sci_controller_terminate_request(ihost,
641                                                            idev,
642                                                            isci_request);
643         }
644         spin_unlock_irqrestore(&ihost->scic_lock, flags);
645
646         /*
647          * The only time the request to terminate will
648          * fail is when the io request is completed and
649          * being aborted.
650          */
651         if (status != SCI_SUCCESS) {
652                 dev_dbg(&ihost->pdev->dev,
653                         "%s: sci_controller_terminate_request"
654                         " returned = 0x%x\n",
655                         __func__, status);
656
657                 isci_request->io_request_completion = NULL;
658
659         } else {
660                 if (was_terminated) {
661                         dev_dbg(&ihost->pdev->dev,
662                                 "%s: before completion wait (%p/%p)\n",
663                                 __func__, isci_request, io_request_completion);
664
665                         /* Wait here for the request to complete. */
666                         termination_completed
667                                 = wait_for_completion_timeout(
668                                    io_request_completion,
669                                    msecs_to_jiffies(ISCI_TERMINATION_TIMEOUT_MSEC));
670
671                         if (!termination_completed) {
672
673                                 /* The request to terminate has timed out.  */
674                                 spin_lock_irqsave(&ihost->scic_lock, flags);
675
676                                 /* Check for state changes. */
677                                 if (!test_bit(IREQ_TERMINATED,
678                                               &isci_request->flags)) {
679
680                                         /* The best we can do is to have the
681                                          * request die a silent death if it
682                                          * ever really completes.
683                                          */
684                                         isci_request_mark_zombie(ihost,
685                                                                  isci_request);
686                                         needs_cleanup_handling = true;
687                                 } else
688                                         termination_completed = 1;
689
690                                 spin_unlock_irqrestore(&ihost->scic_lock,
691                                                        flags);
692
693                                 if (!termination_completed) {
694
695                                         dev_dbg(&ihost->pdev->dev,
696                                                 "%s: *** Timeout waiting for "
697                                                 "termination(%p/%p)\n",
698                                                 __func__, io_request_completion,
699                                                 isci_request);
700
701                                         /* The request can no longer be referenced
702                                          * safely since it may go away if the
703                                          * termination every really does complete.
704                                          */
705                                         isci_request = NULL;
706                                 }
707                         }
708                         if (termination_completed)
709                                 dev_dbg(&ihost->pdev->dev,
710                                         "%s: after completion wait (%p/%p)\n",
711                                         __func__, isci_request, io_request_completion);
712                 }
713
714                 if (termination_completed) {
715
716                         isci_request->io_request_completion = NULL;
717
718                         /* Peek at the status of the request.  This will tell
719                          * us if there was special handling on the request such that it
720                          * needs to be detached and freed here.
721                          */
722                         spin_lock_irqsave(&isci_request->state_lock, flags);
723
724                         needs_cleanup_handling
725                                 = isci_request_is_dealloc_managed(
726                                         isci_request->status);
727
728                         spin_unlock_irqrestore(&isci_request->state_lock, flags);
729
730                 }
731                 if (needs_cleanup_handling) {
732
733                         dev_dbg(&ihost->pdev->dev,
734                                 "%s: cleanup isci_device=%p, request=%p\n",
735                                 __func__, idev, isci_request);
736
737                         if (isci_request != NULL) {
738                                 spin_lock_irqsave(&ihost->scic_lock, flags);
739                                 isci_free_tag(ihost, isci_request->io_tag);
740                                 isci_request_change_state(isci_request, unallocated);
741                                 list_del_init(&isci_request->dev_node);
742                                 spin_unlock_irqrestore(&ihost->scic_lock, flags);
743                         }
744                 }
745         }
746 }
747
748 /**
749  * isci_terminate_pending_requests() - This function will change the all of the
750  *    requests on the given device's state to "aborting", will terminate the
751  *    requests, and wait for them to complete.  This function must only be
752  *    called from a thread that can wait.  Note that the requests are all
753  *    terminated and completed (back to the host, if started there).
754  * @isci_host: This parameter specifies SCU.
755  * @idev: This parameter specifies the target.
756  *
757  */
758 void isci_terminate_pending_requests(struct isci_host *ihost,
759                                      struct isci_remote_device *idev)
760 {
761         struct completion request_completion;
762         enum isci_request_status old_state;
763         unsigned long flags;
764         LIST_HEAD(list);
765
766         spin_lock_irqsave(&ihost->scic_lock, flags);
767         list_splice_init(&idev->reqs_in_process, &list);
768
769         /* assumes that isci_terminate_request_core deletes from the list */
770         while (!list_empty(&list)) {
771                 struct isci_request *ireq = list_entry(list.next, typeof(*ireq), dev_node);
772
773                 /* Change state to "terminating" if it is currently
774                  * "started".
775                  */
776                 old_state = isci_request_change_started_to_newstate(ireq,
777                                                                     &request_completion,
778                                                                     terminating);
779                 switch (old_state) {
780                 case started:
781                 case completed:
782                 case aborting:
783                         break;
784                 default:
785                         /* termination in progress, or otherwise dispositioned.
786                          * We know the request was on 'list' so should be safe
787                          * to move it back to reqs_in_process
788                          */
789                         list_move(&ireq->dev_node, &idev->reqs_in_process);
790                         ireq = NULL;
791                         break;
792                 }
793
794                 if (!ireq)
795                         continue;
796                 spin_unlock_irqrestore(&ihost->scic_lock, flags);
797
798                 init_completion(&request_completion);
799
800                 dev_dbg(&ihost->pdev->dev,
801                          "%s: idev=%p request=%p; task=%p old_state=%d\n",
802                          __func__, idev, ireq,
803                         (!test_bit(IREQ_TMF, &ireq->flags)
804                                 ? isci_request_access_task(ireq)
805                                 : NULL),
806                         old_state);
807
808                 /* If the old_state is started:
809                  * This request was not already being aborted. If it had been,
810                  * then the aborting I/O (ie. the TMF request) would not be in
811                  * the aborting state, and thus would be terminated here.  Note
812                  * that since the TMF completion's call to the kernel function
813                  * "complete()" does not happen until the pending I/O request
814                  * terminate fully completes, we do not have to implement a
815                  * special wait here for already aborting requests - the
816                  * termination of the TMF request will force the request
817                  * to finish it's already started terminate.
818                  *
819                  * If old_state == completed:
820                  * This request completed from the SCU hardware perspective
821                  * and now just needs cleaning up in terms of freeing the
822                  * request and potentially calling up to libsas.
823                  *
824                  * If old_state == aborting:
825                  * This request has already gone through a TMF timeout, but may
826                  * not have been terminated; needs cleaning up at least.
827                  */
828                 isci_terminate_request_core(ihost, idev, ireq);
829                 spin_lock_irqsave(&ihost->scic_lock, flags);
830         }
831         spin_unlock_irqrestore(&ihost->scic_lock, flags);
832 }
833
834 /**
835  * isci_task_send_lu_reset_sas() - This function is called by of the SAS Domain
836  *    Template functions.
837  * @lun: This parameter specifies the lun to be reset.
838  *
839  * status, zero indicates success.
840  */
841 static int isci_task_send_lu_reset_sas(
842         struct isci_host *isci_host,
843         struct isci_remote_device *isci_device,
844         u8 *lun)
845 {
846         struct isci_tmf tmf;
847         int ret = TMF_RESP_FUNC_FAILED;
848
849         dev_dbg(&isci_host->pdev->dev,
850                 "%s: isci_host = %p, isci_device = %p\n",
851                 __func__, isci_host, isci_device);
852         /* Send the LUN reset to the target.  By the time the call returns,
853          * the TMF has fully exected in the target (in which case the return
854          * value is "TMF_RESP_FUNC_COMPLETE", or the request timed-out (or
855          * was otherwise unable to be executed ("TMF_RESP_FUNC_FAILED").
856          */
857         isci_task_build_tmf(&tmf, isci_tmf_ssp_lun_reset, NULL, NULL);
858
859         #define ISCI_LU_RESET_TIMEOUT_MS 2000 /* 2 second timeout. */
860         ret = isci_task_execute_tmf(isci_host, isci_device, &tmf, ISCI_LU_RESET_TIMEOUT_MS);
861
862         if (ret == TMF_RESP_FUNC_COMPLETE)
863                 dev_dbg(&isci_host->pdev->dev,
864                         "%s: %p: TMF_LU_RESET passed\n",
865                         __func__, isci_device);
866         else
867                 dev_dbg(&isci_host->pdev->dev,
868                         "%s: %p: TMF_LU_RESET failed (%x)\n",
869                         __func__, isci_device, ret);
870
871         return ret;
872 }
873
874 static int isci_task_send_lu_reset_sata(struct isci_host *ihost,
875                                  struct isci_remote_device *idev, u8 *lun)
876 {
877         int ret = TMF_RESP_FUNC_FAILED;
878         struct isci_tmf tmf;
879
880         /* Send the soft reset to the target */
881         #define ISCI_SRST_TIMEOUT_MS 25000 /* 25 second timeout. */
882         isci_task_build_tmf(&tmf, isci_tmf_sata_srst_high, NULL, NULL);
883
884         ret = isci_task_execute_tmf(ihost, idev, &tmf, ISCI_SRST_TIMEOUT_MS);
885
886         if (ret != TMF_RESP_FUNC_COMPLETE) {
887                 dev_dbg(&ihost->pdev->dev,
888                          "%s: Assert SRST failed (%p) = %x",
889                          __func__, idev, ret);
890
891                 /* Return the failure so that the LUN reset is escalated
892                  * to a target reset.
893                  */
894         }
895         return ret;
896 }
897
898 /**
899  * isci_task_lu_reset() - This function is one of the SAS Domain Template
900  *    functions. This is one of the Task Management functoins called by libsas,
901  *    to reset the given lun. Note the assumption that while this call is
902  *    executing, no I/O will be sent by the host to the device.
903  * @lun: This parameter specifies the lun to be reset.
904  *
905  * status, zero indicates success.
906  */
907 int isci_task_lu_reset(struct domain_device *domain_device, u8 *lun)
908 {
909         struct isci_host *isci_host = dev_to_ihost(domain_device);
910         struct isci_remote_device *isci_device;
911         unsigned long flags;
912         int ret;
913
914         spin_lock_irqsave(&isci_host->scic_lock, flags);
915         isci_device = isci_lookup_device(domain_device);
916         spin_unlock_irqrestore(&isci_host->scic_lock, flags);
917
918         dev_dbg(&isci_host->pdev->dev,
919                 "%s: domain_device=%p, isci_host=%p; isci_device=%p\n",
920                  __func__, domain_device, isci_host, isci_device);
921
922         if (!isci_device) {
923                 /* If the device is gone, stop the escalations. */
924                 dev_dbg(&isci_host->pdev->dev, "%s: No dev\n", __func__);
925
926                 ret = TMF_RESP_FUNC_COMPLETE;
927                 goto out;
928         }
929         set_bit(IDEV_EH, &isci_device->flags);
930
931         /* Send the task management part of the reset. */
932         if (sas_protocol_ata(domain_device->tproto)) {
933                 ret = isci_task_send_lu_reset_sata(isci_host, isci_device, lun);
934         } else
935                 ret = isci_task_send_lu_reset_sas(isci_host, isci_device, lun);
936
937         /* If the LUN reset worked, all the I/O can now be terminated. */
938         if (ret == TMF_RESP_FUNC_COMPLETE)
939                 /* Terminate all I/O now. */
940                 isci_terminate_pending_requests(isci_host,
941                                                 isci_device);
942
943  out:
944         isci_put_device(isci_device);
945         return ret;
946 }
947
948
949 /*       int (*lldd_clear_nexus_port)(struct asd_sas_port *); */
950 int isci_task_clear_nexus_port(struct asd_sas_port *port)
951 {
952         return TMF_RESP_FUNC_FAILED;
953 }
954
955
956
957 int isci_task_clear_nexus_ha(struct sas_ha_struct *ha)
958 {
959         return TMF_RESP_FUNC_FAILED;
960 }
961
962 /* Task Management Functions. Must be called from process context.       */
963
964 /**
965  * isci_abort_task_process_cb() - This is a helper function for the abort task
966  *    TMF command.  It manages the request state with respect to the successful
967  *    transmission / completion of the abort task request.
968  * @cb_state: This parameter specifies when this function was called - after
969  *    the TMF request has been started and after it has timed-out.
970  * @tmf: This parameter specifies the TMF in progress.
971  *
972  *
973  */
974 static void isci_abort_task_process_cb(
975         enum isci_tmf_cb_state cb_state,
976         struct isci_tmf *tmf,
977         void *cb_data)
978 {
979         struct isci_request *old_request;
980
981         old_request = (struct isci_request *)cb_data;
982
983         dev_dbg(&old_request->isci_host->pdev->dev,
984                 "%s: tmf=%p, old_request=%p\n",
985                 __func__, tmf, old_request);
986
987         switch (cb_state) {
988
989         case isci_tmf_started:
990                 /* The TMF has been started.  Nothing to do here, since the
991                  * request state was already set to "aborted" by the abort
992                  * task function.
993                  */
994                 if ((old_request->status != aborted)
995                         && (old_request->status != completed))
996                         dev_dbg(&old_request->isci_host->pdev->dev,
997                                 "%s: Bad request status (%d): tmf=%p, old_request=%p\n",
998                                 __func__, old_request->status, tmf, old_request);
999                 break;
1000
1001         case isci_tmf_timed_out:
1002
1003                 /* Set the task's state to "aborting", since the abort task
1004                  * function thread set it to "aborted" (above) in anticipation
1005                  * of the task management request working correctly.  Since the
1006                  * timeout has now fired, the TMF request failed.  We set the
1007                  * state such that the request completion will indicate the
1008                  * device is no longer present.
1009                  */
1010                 isci_request_change_state(old_request, aborting);
1011                 break;
1012
1013         default:
1014                 dev_dbg(&old_request->isci_host->pdev->dev,
1015                         "%s: Bad cb_state (%d): tmf=%p, old_request=%p\n",
1016                         __func__, cb_state, tmf, old_request);
1017                 break;
1018         }
1019 }
1020
1021 /**
1022  * isci_task_abort_task() - This function is one of the SAS Domain Template
1023  *    functions. This function is called by libsas to abort a specified task.
1024  * @task: This parameter specifies the SAS task to abort.
1025  *
1026  * status, zero indicates success.
1027  */
1028 int isci_task_abort_task(struct sas_task *task)
1029 {
1030         struct isci_host *isci_host = dev_to_ihost(task->dev);
1031         DECLARE_COMPLETION_ONSTACK(aborted_io_completion);
1032         struct isci_request       *old_request = NULL;
1033         enum isci_request_status  old_state;
1034         struct isci_remote_device *isci_device = NULL;
1035         struct isci_tmf           tmf;
1036         int                       ret = TMF_RESP_FUNC_FAILED;
1037         unsigned long             flags;
1038         int                       perform_termination = 0;
1039
1040         /* Get the isci_request reference from the task.  Note that
1041          * this check does not depend on the pending request list
1042          * in the device, because tasks driving resets may land here
1043          * after completion in the core.
1044          */
1045         spin_lock_irqsave(&isci_host->scic_lock, flags);
1046         spin_lock(&task->task_state_lock);
1047
1048         old_request = task->lldd_task;
1049
1050         /* If task is already done, the request isn't valid */
1051         if (!(task->task_state_flags & SAS_TASK_STATE_DONE) &&
1052             (task->task_state_flags & SAS_TASK_AT_INITIATOR) &&
1053             old_request)
1054                 isci_device = isci_lookup_device(task->dev);
1055
1056         spin_unlock(&task->task_state_lock);
1057         spin_unlock_irqrestore(&isci_host->scic_lock, flags);
1058
1059         dev_dbg(&isci_host->pdev->dev,
1060                 "%s: dev = %p, task = %p, old_request == %p\n",
1061                 __func__, isci_device, task, old_request);
1062
1063         if (isci_device)
1064                 set_bit(IDEV_EH, &isci_device->flags);
1065
1066         /* Device reset conditions signalled in task_state_flags are the
1067          * responsbility of libsas to observe at the start of the error
1068          * handler thread.
1069          */
1070         if (!isci_device || !old_request) {
1071                 /* The request has already completed and there
1072                 * is nothing to do here other than to set the task
1073                 * done bit, and indicate that the task abort function
1074                 * was sucessful.
1075                 */
1076                 spin_lock_irqsave(&task->task_state_lock, flags);
1077                 task->task_state_flags |= SAS_TASK_STATE_DONE;
1078                 task->task_state_flags &= ~(SAS_TASK_AT_INITIATOR |
1079                                             SAS_TASK_STATE_PENDING);
1080                 spin_unlock_irqrestore(&task->task_state_lock, flags);
1081
1082                 ret = TMF_RESP_FUNC_COMPLETE;
1083
1084                 dev_dbg(&isci_host->pdev->dev,
1085                         "%s: abort task not needed for %p\n",
1086                         __func__, task);
1087                 goto out;
1088         }
1089
1090         spin_lock_irqsave(&isci_host->scic_lock, flags);
1091
1092         /* Check the request status and change to "aborted" if currently
1093          * "starting"; if true then set the I/O kernel completion
1094          * struct that will be triggered when the request completes.
1095          */
1096         old_state = isci_task_validate_request_to_abort(
1097                                 old_request, isci_host, isci_device,
1098                                 &aborted_io_completion);
1099         if ((old_state != started) &&
1100             (old_state != completed) &&
1101             (old_state != aborting)) {
1102
1103                 spin_unlock_irqrestore(&isci_host->scic_lock, flags);
1104
1105                 /* The request was already being handled by someone else (because
1106                 * they got to set the state away from started).
1107                 */
1108                 dev_dbg(&isci_host->pdev->dev,
1109                         "%s:  device = %p; old_request %p already being aborted\n",
1110                         __func__,
1111                         isci_device, old_request);
1112                 ret = TMF_RESP_FUNC_COMPLETE;
1113                 goto out;
1114         }
1115         if (task->task_proto == SAS_PROTOCOL_SMP ||
1116             sas_protocol_ata(task->task_proto) ||
1117             test_bit(IREQ_COMPLETE_IN_TARGET, &old_request->flags)) {
1118
1119                 spin_unlock_irqrestore(&isci_host->scic_lock, flags);
1120
1121                 dev_dbg(&isci_host->pdev->dev,
1122                         "%s: %s request"
1123                         " or complete_in_target (%d), thus no TMF\n",
1124                         __func__,
1125                         ((task->task_proto == SAS_PROTOCOL_SMP)
1126                                 ? "SMP"
1127                                 : (sas_protocol_ata(task->task_proto)
1128                                         ? "SATA/STP"
1129                                         : "<other>")
1130                          ),
1131                         test_bit(IREQ_COMPLETE_IN_TARGET, &old_request->flags));
1132
1133                 if (test_bit(IREQ_COMPLETE_IN_TARGET, &old_request->flags)) {
1134                         spin_lock_irqsave(&task->task_state_lock, flags);
1135                         task->task_state_flags |= SAS_TASK_STATE_DONE;
1136                         task->task_state_flags &= ~(SAS_TASK_AT_INITIATOR |
1137                                                     SAS_TASK_STATE_PENDING);
1138                         spin_unlock_irqrestore(&task->task_state_lock, flags);
1139                         ret = TMF_RESP_FUNC_COMPLETE;
1140                 } else {
1141                         spin_lock_irqsave(&task->task_state_lock, flags);
1142                         task->task_state_flags &= ~(SAS_TASK_AT_INITIATOR |
1143                                                     SAS_TASK_STATE_PENDING);
1144                         spin_unlock_irqrestore(&task->task_state_lock, flags);
1145                 }
1146
1147                 /* STP and SMP devices are not sent a TMF, but the
1148                  * outstanding I/O request is terminated below.  This is
1149                  * because SATA/STP and SMP discovery path timeouts directly
1150                  * call the abort task interface for cleanup.
1151                  */
1152                 perform_termination = 1;
1153
1154         } else {
1155                 /* Fill in the tmf stucture */
1156                 isci_task_build_abort_task_tmf(&tmf, isci_tmf_ssp_task_abort,
1157                                                isci_abort_task_process_cb,
1158                                                old_request);
1159
1160                 spin_unlock_irqrestore(&isci_host->scic_lock, flags);
1161
1162                 #define ISCI_ABORT_TASK_TIMEOUT_MS 500 /* 1/2 second timeout */
1163                 ret = isci_task_execute_tmf(isci_host, isci_device, &tmf,
1164                                             ISCI_ABORT_TASK_TIMEOUT_MS);
1165
1166                 if (ret == TMF_RESP_FUNC_COMPLETE)
1167                         perform_termination = 1;
1168                 else
1169                         dev_dbg(&isci_host->pdev->dev,
1170                                 "%s: isci_task_send_tmf failed\n", __func__);
1171         }
1172         if (perform_termination) {
1173                 set_bit(IREQ_COMPLETE_IN_TARGET, &old_request->flags);
1174
1175                 /* Clean up the request on our side, and wait for the aborted
1176                  * I/O to complete.
1177                  */
1178                 isci_terminate_request_core(isci_host, isci_device,
1179                                             old_request);
1180         }
1181
1182         /* Make sure we do not leave a reference to aborted_io_completion */
1183         old_request->io_request_completion = NULL;
1184  out:
1185         isci_put_device(isci_device);
1186         return ret;
1187 }
1188
1189 /**
1190  * isci_task_abort_task_set() - This function is one of the SAS Domain Template
1191  *    functions. This is one of the Task Management functoins called by libsas,
1192  *    to abort all task for the given lun.
1193  * @d_device: This parameter specifies the domain device associated with this
1194  *    request.
1195  * @lun: This parameter specifies the lun associated with this request.
1196  *
1197  * status, zero indicates success.
1198  */
1199 int isci_task_abort_task_set(
1200         struct domain_device *d_device,
1201         u8 *lun)
1202 {
1203         return TMF_RESP_FUNC_FAILED;
1204 }
1205
1206
1207 /**
1208  * isci_task_clear_aca() - This function is one of the SAS Domain Template
1209  *    functions. This is one of the Task Management functoins called by libsas.
1210  * @d_device: This parameter specifies the domain device associated with this
1211  *    request.
1212  * @lun: This parameter specifies the lun        associated with this request.
1213  *
1214  * status, zero indicates success.
1215  */
1216 int isci_task_clear_aca(
1217         struct domain_device *d_device,
1218         u8 *lun)
1219 {
1220         return TMF_RESP_FUNC_FAILED;
1221 }
1222
1223
1224
1225 /**
1226  * isci_task_clear_task_set() - This function is one of the SAS Domain Template
1227  *    functions. This is one of the Task Management functoins called by libsas.
1228  * @d_device: This parameter specifies the domain device associated with this
1229  *    request.
1230  * @lun: This parameter specifies the lun        associated with this request.
1231  *
1232  * status, zero indicates success.
1233  */
1234 int isci_task_clear_task_set(
1235         struct domain_device *d_device,
1236         u8 *lun)
1237 {
1238         return TMF_RESP_FUNC_FAILED;
1239 }
1240
1241
1242 /**
1243  * isci_task_query_task() - This function is implemented to cause libsas to
1244  *    correctly escalate the failed abort to a LUN or target reset (this is
1245  *    because sas_scsi_find_task libsas function does not correctly interpret
1246  *    all return codes from the abort task call).  When TMF_RESP_FUNC_SUCC is
1247  *    returned, libsas turns this into a LUN reset; when FUNC_FAILED is
1248  *    returned, libsas will turn this into a target reset
1249  * @task: This parameter specifies the sas task being queried.
1250  * @lun: This parameter specifies the lun associated with this request.
1251  *
1252  * status, zero indicates success.
1253  */
1254 int isci_task_query_task(
1255         struct sas_task *task)
1256 {
1257         /* See if there is a pending device reset for this device. */
1258         if (task->task_state_flags & SAS_TASK_NEED_DEV_RESET)
1259                 return TMF_RESP_FUNC_FAILED;
1260         else
1261                 return TMF_RESP_FUNC_SUCC;
1262 }
1263
1264 /*
1265  * isci_task_request_complete() - This function is called by the sci core when
1266  *    an task request completes.
1267  * @ihost: This parameter specifies the ISCI host object
1268  * @ireq: This parameter is the completed isci_request object.
1269  * @completion_status: This parameter specifies the completion status from the
1270  *    sci core.
1271  *
1272  * none.
1273  */
1274 void
1275 isci_task_request_complete(struct isci_host *ihost,
1276                            struct isci_request *ireq,
1277                            enum sci_task_status completion_status)
1278 {
1279         struct isci_tmf *tmf = isci_request_access_tmf(ireq);
1280         struct completion *tmf_complete = NULL;
1281         struct completion *request_complete = ireq->io_request_completion;
1282
1283         dev_dbg(&ihost->pdev->dev,
1284                 "%s: request = %p, status=%d\n",
1285                 __func__, ireq, completion_status);
1286
1287         isci_request_change_state(ireq, completed);
1288
1289         set_bit(IREQ_COMPLETE_IN_TARGET, &ireq->flags);
1290
1291         if (tmf) {
1292                 tmf->status = completion_status;
1293
1294                 if (tmf->proto == SAS_PROTOCOL_SSP) {
1295                         memcpy(&tmf->resp.resp_iu,
1296                                &ireq->ssp.rsp,
1297                                SSP_RESP_IU_MAX_SIZE);
1298                 } else if (tmf->proto == SAS_PROTOCOL_SATA) {
1299                         memcpy(&tmf->resp.d2h_fis,
1300                                &ireq->stp.rsp,
1301                                sizeof(struct dev_to_host_fis));
1302                 }
1303                 /* PRINT_TMF( ((struct isci_tmf *)request->task)); */
1304                 tmf_complete = tmf->complete;
1305         }
1306         sci_controller_complete_io(ihost, ireq->target_device, ireq);
1307         /* set the 'terminated' flag handle to make sure it cannot be terminated
1308          *  or completed again.
1309          */
1310         set_bit(IREQ_TERMINATED, &ireq->flags);
1311
1312         /* As soon as something is in the terminate path, deallocation is
1313          * managed there.  Note that the final non-managed state of a task
1314          * request is "completed".
1315          */
1316         if ((ireq->status == completed) ||
1317             !isci_request_is_dealloc_managed(ireq->status)) {
1318                 isci_request_change_state(ireq, unallocated);
1319                 isci_free_tag(ihost, ireq->io_tag);
1320                 list_del_init(&ireq->dev_node);
1321         }
1322
1323         /* "request_complete" is set if the task was being terminated. */
1324         if (request_complete)
1325                 complete(request_complete);
1326
1327         /* The task management part completes last. */
1328         if (tmf_complete)
1329                 complete(tmf_complete);
1330 }
1331
1332 static int isci_reset_device(struct isci_host *ihost,
1333                              struct isci_remote_device *idev)
1334 {
1335         struct sas_phy *phy = sas_find_local_phy(idev->domain_dev);
1336         enum sci_status status;
1337         unsigned long flags;
1338         int rc;
1339
1340         dev_dbg(&ihost->pdev->dev, "%s: idev %p\n", __func__, idev);
1341
1342         spin_lock_irqsave(&ihost->scic_lock, flags);
1343         status = sci_remote_device_reset(idev);
1344         if (status != SCI_SUCCESS) {
1345                 spin_unlock_irqrestore(&ihost->scic_lock, flags);
1346
1347                 dev_dbg(&ihost->pdev->dev,
1348                          "%s: sci_remote_device_reset(%p) returned %d!\n",
1349                          __func__, idev, status);
1350
1351                 return TMF_RESP_FUNC_FAILED;
1352         }
1353         spin_unlock_irqrestore(&ihost->scic_lock, flags);
1354
1355         rc = sas_phy_reset(phy, true);
1356
1357         /* Terminate in-progress I/O now. */
1358         isci_remote_device_nuke_requests(ihost, idev);
1359
1360         /* Since all pending TCs have been cleaned, resume the RNC. */
1361         spin_lock_irqsave(&ihost->scic_lock, flags);
1362         status = sci_remote_device_reset_complete(idev);
1363         spin_unlock_irqrestore(&ihost->scic_lock, flags);
1364
1365         if (status != SCI_SUCCESS) {
1366                 dev_dbg(&ihost->pdev->dev,
1367                          "%s: sci_remote_device_reset_complete(%p) "
1368                          "returned %d!\n", __func__, idev, status);
1369         }
1370
1371         dev_dbg(&ihost->pdev->dev, "%s: idev %p complete.\n", __func__, idev);
1372
1373         return rc;
1374 }
1375
1376 int isci_task_I_T_nexus_reset(struct domain_device *dev)
1377 {
1378         struct isci_host *ihost = dev_to_ihost(dev);
1379         struct isci_remote_device *idev;
1380         unsigned long flags;
1381         int ret;
1382
1383         spin_lock_irqsave(&ihost->scic_lock, flags);
1384         idev = isci_lookup_device(dev);
1385         spin_unlock_irqrestore(&ihost->scic_lock, flags);
1386
1387         if (!idev || !test_bit(IDEV_EH, &idev->flags)) {
1388                 ret = TMF_RESP_FUNC_COMPLETE;
1389                 goto out;
1390         }
1391
1392         ret = isci_reset_device(ihost, idev);
1393  out:
1394         isci_put_device(idev);
1395         return ret;
1396 }
1397
1398 int isci_bus_reset_handler(struct scsi_cmnd *cmd)
1399 {
1400         struct domain_device *dev = sdev_to_domain_dev(cmd->device);
1401         struct isci_host *ihost = dev_to_ihost(dev);
1402         struct isci_remote_device *idev;
1403         unsigned long flags;
1404         int ret;
1405
1406         spin_lock_irqsave(&ihost->scic_lock, flags);
1407         idev = isci_lookup_device(dev);
1408         spin_unlock_irqrestore(&ihost->scic_lock, flags);
1409
1410         if (!idev) {
1411                 ret = TMF_RESP_FUNC_COMPLETE;
1412                 goto out;
1413         }
1414
1415         ret = isci_reset_device(ihost, idev);
1416  out:
1417         isci_put_device(idev);
1418         return ret;
1419 }