Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/linville/wirel...
[firefly-linux-kernel-4.4.55.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         unsigned long flags;
82
83         /* Normal notification (task_done) */
84         dev_dbg(&ihost->pdev->dev, "%s: task = %p, response=%d, status=%d\n",
85                 __func__, task, response, status);
86
87         spin_lock_irqsave(&task->task_state_lock, flags);
88
89         task->task_status.resp = response;
90         task->task_status.stat = status;
91
92         /* Normal notification (task_done) */
93         task->task_state_flags |= SAS_TASK_STATE_DONE;
94         task->task_state_flags &= ~(SAS_TASK_AT_INITIATOR |
95                                     SAS_TASK_STATE_PENDING);
96         task->lldd_task = NULL;
97         spin_unlock_irqrestore(&task->task_state_lock, flags);
98
99         task->task_done(task);
100 }
101
102 #define for_each_sas_task(num, task) \
103         for (; num > 0; num--,\
104              task = list_entry(task->list.next, struct sas_task, list))
105
106
107 static inline int isci_device_io_ready(struct isci_remote_device *idev,
108                                        struct sas_task *task)
109 {
110         return idev ? test_bit(IDEV_IO_READY, &idev->flags) ||
111                       (test_bit(IDEV_IO_NCQERROR, &idev->flags) &&
112                        isci_task_is_ncq_recovery(task))
113                     : 0;
114 }
115 /**
116  * isci_task_execute_task() - This function is one of the SAS Domain Template
117  *    functions. This function is called by libsas to send a task down to
118  *    hardware.
119  * @task: This parameter specifies the SAS task to send.
120  * @num: This parameter specifies the number of tasks to queue.
121  * @gfp_flags: This parameter specifies the context of this call.
122  *
123  * status, zero indicates success.
124  */
125 int isci_task_execute_task(struct sas_task *task, int num, gfp_t gfp_flags)
126 {
127         struct isci_host *ihost = dev_to_ihost(task->dev);
128         struct isci_remote_device *idev;
129         unsigned long flags;
130         bool io_ready;
131         u16 tag;
132
133         dev_dbg(&ihost->pdev->dev, "%s: num=%d\n", __func__, num);
134
135         for_each_sas_task(num, task) {
136                 enum sci_status status = SCI_FAILURE;
137
138                 spin_lock_irqsave(&ihost->scic_lock, flags);
139                 idev = isci_lookup_device(task->dev);
140                 io_ready = isci_device_io_ready(idev, task);
141                 tag = isci_alloc_tag(ihost);
142                 spin_unlock_irqrestore(&ihost->scic_lock, flags);
143
144                 dev_dbg(&ihost->pdev->dev,
145                         "task: %p, num: %d dev: %p idev: %p:%#lx cmd = %p\n",
146                         task, num, task->dev, idev, idev ? idev->flags : 0,
147                         task->uldd_task);
148
149                 if (!idev) {
150                         isci_task_refuse(ihost, task, SAS_TASK_UNDELIVERED,
151                                          SAS_DEVICE_UNKNOWN);
152                 } else if (!io_ready || tag == SCI_CONTROLLER_INVALID_IO_TAG) {
153                         /* Indicate QUEUE_FULL so that the scsi midlayer
154                          * retries.
155                           */
156                         isci_task_refuse(ihost, task, SAS_TASK_COMPLETE,
157                                          SAS_QUEUE_FULL);
158                 } else {
159                         /* There is a device and it's ready for I/O. */
160                         spin_lock_irqsave(&task->task_state_lock, flags);
161
162                         if (task->task_state_flags & SAS_TASK_STATE_ABORTED) {
163                                 /* The I/O was aborted. */
164                                 spin_unlock_irqrestore(&task->task_state_lock,
165                                                        flags);
166
167                                 isci_task_refuse(ihost, task,
168                                                  SAS_TASK_UNDELIVERED,
169                                                  SAM_STAT_TASK_ABORTED);
170                         } else {
171                                 task->task_state_flags |= SAS_TASK_AT_INITIATOR;
172                                 spin_unlock_irqrestore(&task->task_state_lock, flags);
173
174                                 /* build and send the request. */
175                                 status = isci_request_execute(ihost, idev, task, tag);
176
177                                 if (status != SCI_SUCCESS) {
178
179                                         spin_lock_irqsave(&task->task_state_lock, flags);
180                                         /* Did not really start this command. */
181                                         task->task_state_flags &= ~SAS_TASK_AT_INITIATOR;
182                                         spin_unlock_irqrestore(&task->task_state_lock, flags);
183
184                                         if (test_bit(IDEV_GONE, &idev->flags)) {
185
186                                                 /* Indicate that the device
187                                                  * is gone.
188                                                  */
189                                                 isci_task_refuse(ihost, task,
190                                                         SAS_TASK_UNDELIVERED,
191                                                         SAS_DEVICE_UNKNOWN);
192                                         } else {
193                                                 /* Indicate QUEUE_FULL so that
194                                                  * the scsi midlayer retries.
195                                                  * If the request failed for
196                                                  * remote device reasons, it
197                                                  * gets returned as
198                                                  * SAS_TASK_UNDELIVERED next
199                                                  * time through.
200                                                  */
201                                                 isci_task_refuse(ihost, task,
202                                                         SAS_TASK_COMPLETE,
203                                                         SAS_QUEUE_FULL);
204                                         }
205                                 }
206                         }
207                 }
208                 if (status != SCI_SUCCESS && tag != SCI_CONTROLLER_INVALID_IO_TAG) {
209                         spin_lock_irqsave(&ihost->scic_lock, flags);
210                         /* command never hit the device, so just free
211                          * the tci and skip the sequence increment
212                          */
213                         isci_tci_free(ihost, ISCI_TAG_TCI(tag));
214                         spin_unlock_irqrestore(&ihost->scic_lock, flags);
215                 }
216                 isci_put_device(idev);
217         }
218         return 0;
219 }
220
221 static struct isci_request *isci_task_request_build(struct isci_host *ihost,
222                                                     struct isci_remote_device *idev,
223                                                     u16 tag, struct isci_tmf *isci_tmf)
224 {
225         enum sci_status status = SCI_FAILURE;
226         struct isci_request *ireq = NULL;
227         struct domain_device *dev;
228
229         dev_dbg(&ihost->pdev->dev,
230                 "%s: isci_tmf = %p\n", __func__, isci_tmf);
231
232         dev = idev->domain_dev;
233
234         /* do common allocation and init of request object. */
235         ireq = isci_tmf_request_from_tag(ihost, isci_tmf, tag);
236         if (!ireq)
237                 return NULL;
238
239         /* let the core do it's construct. */
240         status = sci_task_request_construct(ihost, idev, tag,
241                                              ireq);
242
243         if (status != SCI_SUCCESS) {
244                 dev_warn(&ihost->pdev->dev,
245                          "%s: sci_task_request_construct failed - "
246                          "status = 0x%x\n",
247                          __func__,
248                          status);
249                 return NULL;
250         }
251
252         /* XXX convert to get this from task->tproto like other drivers */
253         if (dev->dev_type == SAS_END_DEVICE) {
254                 isci_tmf->proto = SAS_PROTOCOL_SSP;
255                 status = sci_task_request_construct_ssp(ireq);
256                 if (status != SCI_SUCCESS)
257                         return NULL;
258         }
259
260         return ireq;
261 }
262
263 static int isci_task_execute_tmf(struct isci_host *ihost,
264                                  struct isci_remote_device *idev,
265                                  struct isci_tmf *tmf, unsigned long timeout_ms)
266 {
267         DECLARE_COMPLETION_ONSTACK(completion);
268         enum sci_task_status status = SCI_TASK_FAILURE;
269         struct isci_request *ireq;
270         int ret = TMF_RESP_FUNC_FAILED;
271         unsigned long flags;
272         unsigned long timeleft;
273         u16 tag;
274
275         spin_lock_irqsave(&ihost->scic_lock, flags);
276         tag = isci_alloc_tag(ihost);
277         spin_unlock_irqrestore(&ihost->scic_lock, flags);
278
279         if (tag == SCI_CONTROLLER_INVALID_IO_TAG)
280                 return ret;
281
282         /* sanity check, return TMF_RESP_FUNC_FAILED
283          * if the device is not there and ready.
284          */
285         if (!idev ||
286             (!test_bit(IDEV_IO_READY, &idev->flags) &&
287              !test_bit(IDEV_IO_NCQERROR, &idev->flags))) {
288                 dev_dbg(&ihost->pdev->dev,
289                         "%s: idev = %p not ready (%#lx)\n",
290                         __func__,
291                         idev, idev ? idev->flags : 0);
292                 goto err_tci;
293         } else
294                 dev_dbg(&ihost->pdev->dev,
295                         "%s: idev = %p\n",
296                         __func__, idev);
297
298         /* Assign the pointer to the TMF's completion kernel wait structure. */
299         tmf->complete = &completion;
300         tmf->status = SCI_FAILURE_TIMEOUT;
301
302         ireq = isci_task_request_build(ihost, idev, tag, tmf);
303         if (!ireq)
304                 goto err_tci;
305
306         spin_lock_irqsave(&ihost->scic_lock, flags);
307
308         /* start the TMF io. */
309         status = sci_controller_start_task(ihost, idev, ireq);
310
311         if (status != SCI_TASK_SUCCESS) {
312                 dev_dbg(&ihost->pdev->dev,
313                          "%s: start_io failed - status = 0x%x, request = %p\n",
314                          __func__,
315                          status,
316                          ireq);
317                 spin_unlock_irqrestore(&ihost->scic_lock, flags);
318                 goto err_tci;
319         }
320         spin_unlock_irqrestore(&ihost->scic_lock, flags);
321
322         /* The RNC must be unsuspended before the TMF can get a response. */
323         isci_remote_device_resume_from_abort(ihost, idev);
324
325         /* Wait for the TMF to complete, or a timeout. */
326         timeleft = wait_for_completion_timeout(&completion,
327                                                msecs_to_jiffies(timeout_ms));
328
329         if (timeleft == 0) {
330                 /* The TMF did not complete - this could be because
331                  * of an unplug.  Terminate the TMF request now.
332                  */
333                 isci_remote_device_suspend_terminate(ihost, idev, ireq);
334         }
335
336         isci_print_tmf(ihost, tmf);
337
338         if (tmf->status == SCI_SUCCESS)
339                 ret =  TMF_RESP_FUNC_COMPLETE;
340         else if (tmf->status == SCI_FAILURE_IO_RESPONSE_VALID) {
341                 dev_dbg(&ihost->pdev->dev,
342                         "%s: tmf.status == "
343                         "SCI_FAILURE_IO_RESPONSE_VALID\n",
344                         __func__);
345                 ret =  TMF_RESP_FUNC_COMPLETE;
346         }
347         /* Else - leave the default "failed" status alone. */
348
349         dev_dbg(&ihost->pdev->dev,
350                 "%s: completed request = %p\n",
351                 __func__,
352                 ireq);
353
354         return ret;
355
356  err_tci:
357         spin_lock_irqsave(&ihost->scic_lock, flags);
358         isci_tci_free(ihost, ISCI_TAG_TCI(tag));
359         spin_unlock_irqrestore(&ihost->scic_lock, flags);
360
361         return ret;
362 }
363
364 static void isci_task_build_tmf(struct isci_tmf *tmf,
365                                 enum isci_tmf_function_codes code)
366 {
367         memset(tmf, 0, sizeof(*tmf));
368         tmf->tmf_code = code;
369 }
370
371 static void isci_task_build_abort_task_tmf(struct isci_tmf *tmf,
372                                            enum isci_tmf_function_codes code,
373                                            struct isci_request *old_request)
374 {
375         isci_task_build_tmf(tmf, code);
376         tmf->io_tag = old_request->io_tag;
377 }
378
379 /**
380  * isci_task_send_lu_reset_sas() - This function is called by of the SAS Domain
381  *    Template functions.
382  * @lun: This parameter specifies the lun to be reset.
383  *
384  * status, zero indicates success.
385  */
386 static int isci_task_send_lu_reset_sas(
387         struct isci_host *isci_host,
388         struct isci_remote_device *isci_device,
389         u8 *lun)
390 {
391         struct isci_tmf tmf;
392         int ret = TMF_RESP_FUNC_FAILED;
393
394         dev_dbg(&isci_host->pdev->dev,
395                 "%s: isci_host = %p, isci_device = %p\n",
396                 __func__, isci_host, isci_device);
397         /* Send the LUN reset to the target.  By the time the call returns,
398          * the TMF has fully exected in the target (in which case the return
399          * value is "TMF_RESP_FUNC_COMPLETE", or the request timed-out (or
400          * was otherwise unable to be executed ("TMF_RESP_FUNC_FAILED").
401          */
402         isci_task_build_tmf(&tmf, isci_tmf_ssp_lun_reset);
403
404         #define ISCI_LU_RESET_TIMEOUT_MS 2000 /* 2 second timeout. */
405         ret = isci_task_execute_tmf(isci_host, isci_device, &tmf, ISCI_LU_RESET_TIMEOUT_MS);
406
407         if (ret == TMF_RESP_FUNC_COMPLETE)
408                 dev_dbg(&isci_host->pdev->dev,
409                         "%s: %p: TMF_LU_RESET passed\n",
410                         __func__, isci_device);
411         else
412                 dev_dbg(&isci_host->pdev->dev,
413                         "%s: %p: TMF_LU_RESET failed (%x)\n",
414                         __func__, isci_device, ret);
415
416         return ret;
417 }
418
419 int isci_task_lu_reset(struct domain_device *dev, u8 *lun)
420 {
421         struct isci_host *ihost = dev_to_ihost(dev);
422         struct isci_remote_device *idev;
423         unsigned long flags;
424         int ret = TMF_RESP_FUNC_COMPLETE;
425
426         spin_lock_irqsave(&ihost->scic_lock, flags);
427         idev = isci_get_device(dev->lldd_dev);
428         spin_unlock_irqrestore(&ihost->scic_lock, flags);
429
430         dev_dbg(&ihost->pdev->dev,
431                 "%s: domain_device=%p, isci_host=%p; isci_device=%p\n",
432                 __func__, dev, ihost, idev);
433
434         if (!idev) {
435                 /* If the device is gone, escalate to I_T_Nexus_Reset. */
436                 dev_dbg(&ihost->pdev->dev, "%s: No dev\n", __func__);
437
438                 ret = TMF_RESP_FUNC_FAILED;
439                 goto out;
440         }
441
442         /* Suspend the RNC, kill all TCs */
443         if (isci_remote_device_suspend_terminate(ihost, idev, NULL)
444             != SCI_SUCCESS) {
445                 /* The suspend/terminate only fails if isci_get_device fails */
446                 ret = TMF_RESP_FUNC_FAILED;
447                 goto out;
448         }
449         /* All pending I/Os have been terminated and cleaned up. */
450         if (!test_bit(IDEV_GONE, &idev->flags)) {
451                 if (dev_is_sata(dev))
452                         sas_ata_schedule_reset(dev);
453                 else
454                         /* Send the task management part of the reset. */
455                         ret = isci_task_send_lu_reset_sas(ihost, idev, lun);
456         }
457  out:
458         isci_put_device(idev);
459         return ret;
460 }
461
462
463 /*       int (*lldd_clear_nexus_port)(struct asd_sas_port *); */
464 int isci_task_clear_nexus_port(struct asd_sas_port *port)
465 {
466         return TMF_RESP_FUNC_FAILED;
467 }
468
469
470
471 int isci_task_clear_nexus_ha(struct sas_ha_struct *ha)
472 {
473         return TMF_RESP_FUNC_FAILED;
474 }
475
476 /* Task Management Functions. Must be called from process context.       */
477
478 /**
479  * isci_task_abort_task() - This function is one of the SAS Domain Template
480  *    functions. This function is called by libsas to abort a specified task.
481  * @task: This parameter specifies the SAS task to abort.
482  *
483  * status, zero indicates success.
484  */
485 int isci_task_abort_task(struct sas_task *task)
486 {
487         struct isci_host *ihost = dev_to_ihost(task->dev);
488         DECLARE_COMPLETION_ONSTACK(aborted_io_completion);
489         struct isci_request       *old_request = NULL;
490         struct isci_remote_device *idev = NULL;
491         struct isci_tmf           tmf;
492         int                       ret = TMF_RESP_FUNC_FAILED;
493         unsigned long             flags;
494         int                       target_done_already = 0;
495
496         /* Get the isci_request reference from the task.  Note that
497          * this check does not depend on the pending request list
498          * in the device, because tasks driving resets may land here
499          * after completion in the core.
500          */
501         spin_lock_irqsave(&ihost->scic_lock, flags);
502         spin_lock(&task->task_state_lock);
503
504         old_request = task->lldd_task;
505
506         /* If task is already done, the request isn't valid */
507         if (!(task->task_state_flags & SAS_TASK_STATE_DONE) &&
508             (task->task_state_flags & SAS_TASK_AT_INITIATOR) &&
509             old_request) {
510                 idev = isci_get_device(task->dev->lldd_dev);
511                 target_done_already = test_bit(IREQ_COMPLETE_IN_TARGET,
512                                                &old_request->flags);
513         }
514         spin_unlock(&task->task_state_lock);
515         spin_unlock_irqrestore(&ihost->scic_lock, flags);
516
517         dev_warn(&ihost->pdev->dev,
518                  "%s: dev = %p (%s%s), task = %p, old_request == %p\n",
519                  __func__, idev,
520                  (dev_is_sata(task->dev) ? "STP/SATA"
521                                          : ((dev_is_expander(task->dev))
522                                                 ? "SMP"
523                                                 : "SSP")),
524                  ((idev) ? ((test_bit(IDEV_GONE, &idev->flags))
525                            ? " IDEV_GONE"
526                            : "")
527                          : " <NULL>"),
528                  task, old_request);
529
530         /* Device reset conditions signalled in task_state_flags are the
531          * responsbility of libsas to observe at the start of the error
532          * handler thread.
533          */
534         if (!idev || !old_request) {
535                 /* The request has already completed and there
536                 * is nothing to do here other than to set the task
537                 * done bit, and indicate that the task abort function
538                 * was successful.
539                 */
540                 spin_lock_irqsave(&task->task_state_lock, flags);
541                 task->task_state_flags |= SAS_TASK_STATE_DONE;
542                 task->task_state_flags &= ~(SAS_TASK_AT_INITIATOR |
543                                             SAS_TASK_STATE_PENDING);
544                 spin_unlock_irqrestore(&task->task_state_lock, flags);
545
546                 ret = TMF_RESP_FUNC_COMPLETE;
547
548                 dev_warn(&ihost->pdev->dev,
549                          "%s: abort task not needed for %p\n",
550                          __func__, task);
551                 goto out;
552         }
553         /* Suspend the RNC, kill the TC */
554         if (isci_remote_device_suspend_terminate(ihost, idev, old_request)
555             != SCI_SUCCESS) {
556                 dev_warn(&ihost->pdev->dev,
557                          "%s: isci_remote_device_reset_terminate(dev=%p, "
558                                  "req=%p, task=%p) failed\n",
559                          __func__, idev, old_request, task);
560                 ret = TMF_RESP_FUNC_FAILED;
561                 goto out;
562         }
563         spin_lock_irqsave(&ihost->scic_lock, flags);
564
565         if (task->task_proto == SAS_PROTOCOL_SMP ||
566             sas_protocol_ata(task->task_proto) ||
567             target_done_already ||
568             test_bit(IDEV_GONE, &idev->flags)) {
569
570                 spin_unlock_irqrestore(&ihost->scic_lock, flags);
571
572                 /* No task to send, so explicitly resume the device here */
573                 isci_remote_device_resume_from_abort(ihost, idev);
574
575                 dev_warn(&ihost->pdev->dev,
576                          "%s: %s request"
577                                  " or complete_in_target (%d), "
578                                  "or IDEV_GONE (%d), thus no TMF\n",
579                          __func__,
580                          ((task->task_proto == SAS_PROTOCOL_SMP)
581                           ? "SMP"
582                           : (sas_protocol_ata(task->task_proto)
583                                 ? "SATA/STP"
584                                 : "<other>")
585                           ),
586                          test_bit(IREQ_COMPLETE_IN_TARGET,
587                                   &old_request->flags),
588                          test_bit(IDEV_GONE, &idev->flags));
589
590                 spin_lock_irqsave(&task->task_state_lock, flags);
591                 task->task_state_flags &= ~(SAS_TASK_AT_INITIATOR |
592                                             SAS_TASK_STATE_PENDING);
593                 task->task_state_flags |= SAS_TASK_STATE_DONE;
594                 spin_unlock_irqrestore(&task->task_state_lock, flags);
595
596                 ret = TMF_RESP_FUNC_COMPLETE;
597         } else {
598                 /* Fill in the tmf stucture */
599                 isci_task_build_abort_task_tmf(&tmf, isci_tmf_ssp_task_abort,
600                                                old_request);
601
602                 spin_unlock_irqrestore(&ihost->scic_lock, flags);
603
604                 /* Send the task management request. */
605                 #define ISCI_ABORT_TASK_TIMEOUT_MS 500 /* 1/2 second timeout */
606                 ret = isci_task_execute_tmf(ihost, idev, &tmf,
607                                             ISCI_ABORT_TASK_TIMEOUT_MS);
608         }
609 out:
610         dev_warn(&ihost->pdev->dev,
611                  "%s: Done; dev = %p, task = %p , old_request == %p\n",
612                  __func__, idev, task, old_request);
613         isci_put_device(idev);
614         return ret;
615 }
616
617 /**
618  * isci_task_abort_task_set() - This function is one of the SAS Domain Template
619  *    functions. This is one of the Task Management functoins called by libsas,
620  *    to abort all task for the given lun.
621  * @d_device: This parameter specifies the domain device associated with this
622  *    request.
623  * @lun: This parameter specifies the lun associated with this request.
624  *
625  * status, zero indicates success.
626  */
627 int isci_task_abort_task_set(
628         struct domain_device *d_device,
629         u8 *lun)
630 {
631         return TMF_RESP_FUNC_FAILED;
632 }
633
634
635 /**
636  * isci_task_clear_aca() - This function is one of the SAS Domain Template
637  *    functions. This is one of the Task Management functoins called by libsas.
638  * @d_device: This parameter specifies the domain device associated with this
639  *    request.
640  * @lun: This parameter specifies the lun        associated with this request.
641  *
642  * status, zero indicates success.
643  */
644 int isci_task_clear_aca(
645         struct domain_device *d_device,
646         u8 *lun)
647 {
648         return TMF_RESP_FUNC_FAILED;
649 }
650
651
652
653 /**
654  * isci_task_clear_task_set() - This function is one of the SAS Domain Template
655  *    functions. This is one of the Task Management functoins called by libsas.
656  * @d_device: This parameter specifies the domain device associated with this
657  *    request.
658  * @lun: This parameter specifies the lun        associated with this request.
659  *
660  * status, zero indicates success.
661  */
662 int isci_task_clear_task_set(
663         struct domain_device *d_device,
664         u8 *lun)
665 {
666         return TMF_RESP_FUNC_FAILED;
667 }
668
669
670 /**
671  * isci_task_query_task() - This function is implemented to cause libsas to
672  *    correctly escalate the failed abort to a LUN or target reset (this is
673  *    because sas_scsi_find_task libsas function does not correctly interpret
674  *    all return codes from the abort task call).  When TMF_RESP_FUNC_SUCC is
675  *    returned, libsas turns this into a LUN reset; when FUNC_FAILED is
676  *    returned, libsas will turn this into a target reset
677  * @task: This parameter specifies the sas task being queried.
678  * @lun: This parameter specifies the lun associated with this request.
679  *
680  * status, zero indicates success.
681  */
682 int isci_task_query_task(
683         struct sas_task *task)
684 {
685         /* See if there is a pending device reset for this device. */
686         if (task->task_state_flags & SAS_TASK_NEED_DEV_RESET)
687                 return TMF_RESP_FUNC_FAILED;
688         else
689                 return TMF_RESP_FUNC_SUCC;
690 }
691
692 /*
693  * isci_task_request_complete() - This function is called by the sci core when
694  *    an task request completes.
695  * @ihost: This parameter specifies the ISCI host object
696  * @ireq: This parameter is the completed isci_request object.
697  * @completion_status: This parameter specifies the completion status from the
698  *    sci core.
699  *
700  * none.
701  */
702 void
703 isci_task_request_complete(struct isci_host *ihost,
704                            struct isci_request *ireq,
705                            enum sci_task_status completion_status)
706 {
707         struct isci_tmf *tmf = isci_request_access_tmf(ireq);
708         struct completion *tmf_complete = NULL;
709
710         dev_dbg(&ihost->pdev->dev,
711                 "%s: request = %p, status=%d\n",
712                 __func__, ireq, completion_status);
713
714         set_bit(IREQ_COMPLETE_IN_TARGET, &ireq->flags);
715
716         if (tmf) {
717                 tmf->status = completion_status;
718
719                 if (tmf->proto == SAS_PROTOCOL_SSP) {
720                         memcpy(&tmf->resp.resp_iu,
721                                &ireq->ssp.rsp,
722                                SSP_RESP_IU_MAX_SIZE);
723                 } else if (tmf->proto == SAS_PROTOCOL_SATA) {
724                         memcpy(&tmf->resp.d2h_fis,
725                                &ireq->stp.rsp,
726                                sizeof(struct dev_to_host_fis));
727                 }
728                 /* PRINT_TMF( ((struct isci_tmf *)request->task)); */
729                 tmf_complete = tmf->complete;
730         }
731         sci_controller_complete_io(ihost, ireq->target_device, ireq);
732         /* set the 'terminated' flag handle to make sure it cannot be terminated
733          *  or completed again.
734          */
735         set_bit(IREQ_TERMINATED, &ireq->flags);
736
737         if (test_and_clear_bit(IREQ_ABORT_PATH_ACTIVE, &ireq->flags))
738                 wake_up_all(&ihost->eventq);
739
740         if (!test_bit(IREQ_NO_AUTO_FREE_TAG, &ireq->flags))
741                 isci_free_tag(ihost, ireq->io_tag);
742
743         /* The task management part completes last. */
744         if (tmf_complete)
745                 complete(tmf_complete);
746 }
747
748 static int isci_reset_device(struct isci_host *ihost,
749                              struct domain_device *dev,
750                              struct isci_remote_device *idev)
751 {
752         int rc = TMF_RESP_FUNC_COMPLETE, reset_stat = -1;
753         struct sas_phy *phy = sas_get_local_phy(dev);
754         struct isci_port *iport = dev->port->lldd_port;
755
756         dev_dbg(&ihost->pdev->dev, "%s: idev %p\n", __func__, idev);
757
758         /* Suspend the RNC, terminate all outstanding TCs. */
759         if (isci_remote_device_suspend_terminate(ihost, idev, NULL)
760             != SCI_SUCCESS) {
761                 rc = TMF_RESP_FUNC_FAILED;
762                 goto out;
763         }
764         /* Note that since the termination for outstanding requests succeeded,
765          * this function will return success.  This is because the resets will
766          * only fail if the device has been removed (ie. hotplug), and the
767          * primary duty of this function is to cleanup tasks, so that is the
768          * relevant status.
769          */
770         if (!test_bit(IDEV_GONE, &idev->flags)) {
771                 if (scsi_is_sas_phy_local(phy)) {
772                         struct isci_phy *iphy = &ihost->phys[phy->number];
773
774                         reset_stat = isci_port_perform_hard_reset(ihost, iport,
775                                                                   iphy);
776                 } else
777                         reset_stat = sas_phy_reset(phy, !dev_is_sata(dev));
778         }
779         /* Explicitly resume the RNC here, since there was no task sent. */
780         isci_remote_device_resume_from_abort(ihost, idev);
781
782         dev_dbg(&ihost->pdev->dev, "%s: idev %p complete, reset_stat=%d.\n",
783                 __func__, idev, reset_stat);
784  out:
785         sas_put_local_phy(phy);
786         return rc;
787 }
788
789 int isci_task_I_T_nexus_reset(struct domain_device *dev)
790 {
791         struct isci_host *ihost = dev_to_ihost(dev);
792         struct isci_remote_device *idev;
793         unsigned long flags;
794         int ret;
795
796         spin_lock_irqsave(&ihost->scic_lock, flags);
797         idev = isci_get_device(dev->lldd_dev);
798         spin_unlock_irqrestore(&ihost->scic_lock, flags);
799
800         if (!idev) {
801                 /* XXX: need to cleanup any ireqs targeting this
802                  * domain_device
803                  */
804                 ret = TMF_RESP_FUNC_COMPLETE;
805                 goto out;
806         }
807
808         ret = isci_reset_device(ihost, dev, idev);
809  out:
810         isci_put_device(idev);
811         return ret;
812 }