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