Commit | Line | Data |
---|---|---|
6f231dda DW |
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 | */ | |
2d9c2240 | 55 | #include <scsi/sas.h> |
7e629841 | 56 | #include <linux/bitops.h> |
88f3b62a DW |
57 | #include "isci.h" |
58 | #include "port.h" | |
59 | #include "remote_device.h" | |
60 | #include "request.h" | |
88f3b62a | 61 | #include "remote_node_context.h" |
88f3b62a DW |
62 | #include "scu_event_codes.h" |
63 | #include "task.h" | |
64 | ||
d7a0ccdd DW |
65 | #undef C |
66 | #define C(a) (#a) | |
67 | const char *dev_state_name(enum sci_remote_device_states state) | |
68 | { | |
69 | static const char * const strings[] = REMOTE_DEV_STATES; | |
70 | ||
71 | return strings[state]; | |
72 | } | |
73 | #undef C | |
74 | ||
87805162 JS |
75 | enum sci_status sci_remote_device_suspend(struct isci_remote_device *idev, |
76 | enum sci_remote_node_suspension_reasons reason) | |
23ec2aa9 | 77 | { |
447bfbce JS |
78 | return sci_remote_node_context_suspend(&idev->rnc, reason, |
79 | SCI_SOFTWARE_SUSPEND_EXPECTED_EVENT); | |
23ec2aa9 JS |
80 | } |
81 | ||
ab2e8f7d | 82 | /** |
d9dcb4ba | 83 | * isci_remote_device_ready() - This function is called by the ihost when the |
ab2e8f7d DW |
84 | * remote device is ready. We mark the isci device as ready and signal the |
85 | * waiting proccess. | |
86 | * @ihost: our valid isci_host | |
87 | * @idev: remote device | |
88 | * | |
89 | */ | |
90 | static void isci_remote_device_ready(struct isci_host *ihost, struct isci_remote_device *idev) | |
91 | { | |
92 | dev_dbg(&ihost->pdev->dev, | |
93 | "%s: idev = %p\n", __func__, idev); | |
94 | ||
9274f45e | 95 | clear_bit(IDEV_IO_NCQERROR, &idev->flags); |
f2088267 | 96 | set_bit(IDEV_IO_READY, &idev->flags); |
ab2e8f7d DW |
97 | if (test_and_clear_bit(IDEV_START_PENDING, &idev->flags)) |
98 | wake_up(&ihost->eventq); | |
99 | } | |
100 | ||
14aaa9f0 JS |
101 | static enum sci_status sci_remote_device_terminate_req( |
102 | struct isci_host *ihost, | |
103 | struct isci_remote_device *idev, | |
104 | int check_abort, | |
105 | struct isci_request *ireq) | |
106 | { | |
14aaa9f0 JS |
107 | if (!test_bit(IREQ_ACTIVE, &ireq->flags) || |
108 | (ireq->target_device != idev) || | |
109 | (check_abort && !test_bit(IREQ_PENDING_ABORT, &ireq->flags))) | |
110 | return SCI_SUCCESS; | |
111 | ||
621120ca JS |
112 | dev_dbg(&ihost->pdev->dev, |
113 | "%s: idev=%p; flags=%lx; req=%p; req target=%p\n", | |
114 | __func__, idev, idev->flags, ireq, ireq->target_device); | |
115 | ||
14aaa9f0 JS |
116 | set_bit(IREQ_ABORT_PATH_ACTIVE, &ireq->flags); |
117 | ||
118 | return sci_controller_terminate_request(ihost, idev, ireq); | |
119 | } | |
120 | ||
121 | static enum sci_status sci_remote_device_terminate_reqs_checkabort( | |
122 | struct isci_remote_device *idev, | |
123 | int chk) | |
5b6bf225 | 124 | { |
14aaa9f0 JS |
125 | struct isci_host *ihost = idev->owning_port->owning_controller; |
126 | enum sci_status status = SCI_SUCCESS; | |
127 | u32 i; | |
128 | ||
129 | for (i = 0; i < SCI_MAX_IO_REQUESTS; i++) { | |
130 | struct isci_request *ireq = ihost->reqs[i]; | |
131 | enum sci_status s; | |
132 | ||
133 | s = sci_remote_device_terminate_req(ihost, idev, chk, ireq); | |
134 | if (s != SCI_SUCCESS) | |
135 | status = s; | |
136 | } | |
137 | return status; | |
5b6bf225 JS |
138 | } |
139 | ||
31a38ef0 JS |
140 | static bool isci_compare_suspendcount( |
141 | struct isci_remote_device *idev, | |
142 | u32 localcount) | |
143 | { | |
144 | smp_rmb(); | |
1f053889 JS |
145 | |
146 | /* Check for a change in the suspend count, or the RNC | |
147 | * being destroyed. | |
148 | */ | |
149 | return (localcount != idev->rnc.suspend_count) | |
150 | || sci_remote_node_context_is_being_destroyed(&idev->rnc); | |
31a38ef0 JS |
151 | } |
152 | ||
033d19d2 JS |
153 | static bool isci_check_reqterm( |
154 | struct isci_host *ihost, | |
155 | struct isci_remote_device *idev, | |
156 | struct isci_request *ireq, | |
157 | u32 localcount) | |
158 | { | |
159 | unsigned long flags; | |
160 | bool res; | |
161 | ||
162 | spin_lock_irqsave(&ihost->scic_lock, flags); | |
163 | res = isci_compare_suspendcount(idev, localcount) | |
164 | && !test_bit(IREQ_ABORT_PATH_ACTIVE, &ireq->flags); | |
165 | spin_unlock_irqrestore(&ihost->scic_lock, flags); | |
166 | ||
167 | return res; | |
168 | } | |
169 | ||
170 | static bool isci_check_devempty( | |
171 | struct isci_host *ihost, | |
172 | struct isci_remote_device *idev, | |
173 | u32 localcount) | |
174 | { | |
175 | unsigned long flags; | |
176 | bool res; | |
177 | ||
178 | spin_lock_irqsave(&ihost->scic_lock, flags); | |
179 | res = isci_compare_suspendcount(idev, localcount) | |
180 | && idev->started_request_count == 0; | |
181 | spin_unlock_irqrestore(&ihost->scic_lock, flags); | |
182 | ||
183 | return res; | |
184 | } | |
185 | ||
14aaa9f0 | 186 | enum sci_status isci_remote_device_terminate_requests( |
726980d5 | 187 | struct isci_host *ihost, |
14aaa9f0 JS |
188 | struct isci_remote_device *idev, |
189 | struct isci_request *ireq) | |
726980d5 | 190 | { |
14aaa9f0 | 191 | enum sci_status status = SCI_SUCCESS; |
726980d5 | 192 | unsigned long flags; |
31a38ef0 | 193 | u32 rnc_suspend_count; |
726980d5 JS |
194 | |
195 | spin_lock_irqsave(&ihost->scic_lock, flags); | |
31a38ef0 | 196 | |
14aaa9f0 JS |
197 | if (isci_get_device(idev) == NULL) { |
198 | dev_dbg(&ihost->pdev->dev, "%s: failed isci_get_device(idev=%p)\n", | |
199 | __func__, idev); | |
726980d5 JS |
200 | spin_unlock_irqrestore(&ihost->scic_lock, flags); |
201 | status = SCI_FAILURE; | |
202 | } else { | |
31a38ef0 JS |
203 | /* If already suspended, don't wait for another suspension. */ |
204 | smp_rmb(); | |
205 | rnc_suspend_count | |
206 | = sci_remote_node_context_is_suspended(&idev->rnc) | |
207 | ? 0 : idev->rnc.suspend_count; | |
208 | ||
14aaa9f0 JS |
209 | dev_dbg(&ihost->pdev->dev, |
210 | "%s: idev=%p, ireq=%p; started_request_count=%d, " | |
31a38ef0 | 211 | "rnc_suspend_count=%d, rnc.suspend_count=%d" |
14aaa9f0 | 212 | "about to wait\n", |
31a38ef0 JS |
213 | __func__, idev, ireq, idev->started_request_count, |
214 | rnc_suspend_count, idev->rnc.suspend_count); | |
8c731888 JS |
215 | |
216 | #define MAX_SUSPEND_MSECS 10000 | |
14aaa9f0 JS |
217 | if (ireq) { |
218 | /* Terminate a specific TC. */ | |
621120ca | 219 | set_bit(IREQ_NO_AUTO_FREE_TAG, &ireq->flags); |
14aaa9f0 JS |
220 | sci_remote_device_terminate_req(ihost, idev, 0, ireq); |
221 | spin_unlock_irqrestore(&ihost->scic_lock, flags); | |
8c731888 JS |
222 | if (!wait_event_timeout(ihost->eventq, |
223 | isci_check_reqterm(ihost, idev, ireq, | |
224 | rnc_suspend_count), | |
225 | msecs_to_jiffies(MAX_SUSPEND_MSECS))) { | |
226 | ||
227 | dev_warn(&ihost->pdev->dev, "%s host%d timeout single\n", | |
228 | __func__, ihost->id); | |
229 | dev_dbg(&ihost->pdev->dev, | |
230 | "%s: ******* Timeout waiting for " | |
231 | "suspend; idev=%p, current state %s; " | |
232 | "started_request_count=%d, flags=%lx\n\t" | |
233 | "rnc_suspend_count=%d, rnc.suspend_count=%d " | |
234 | "RNC: current state %s, current " | |
235 | "suspend_type %x dest state %d;\n" | |
236 | "ireq=%p, ireq->flags = %lx\n", | |
237 | __func__, idev, | |
238 | dev_state_name(idev->sm.current_state_id), | |
239 | idev->started_request_count, idev->flags, | |
240 | rnc_suspend_count, idev->rnc.suspend_count, | |
241 | rnc_state_name(idev->rnc.sm.current_state_id), | |
242 | idev->rnc.suspend_type, | |
243 | idev->rnc.destination_state, | |
244 | ireq, ireq->flags); | |
245 | } | |
3ef768c6 | 246 | spin_lock_irqsave(&ihost->scic_lock, flags); |
621120ca | 247 | clear_bit(IREQ_NO_AUTO_FREE_TAG, &ireq->flags); |
3ef768c6 JS |
248 | if (!test_bit(IREQ_ABORT_PATH_ACTIVE, &ireq->flags)) |
249 | isci_free_tag(ihost, ireq->io_tag); | |
250 | spin_unlock_irqrestore(&ihost->scic_lock, flags); | |
14aaa9f0 JS |
251 | } else { |
252 | /* Terminate all TCs. */ | |
253 | sci_remote_device_terminate_requests(idev); | |
254 | spin_unlock_irqrestore(&ihost->scic_lock, flags); | |
8c731888 JS |
255 | if (!wait_event_timeout(ihost->eventq, |
256 | isci_check_devempty(ihost, idev, | |
257 | rnc_suspend_count), | |
258 | msecs_to_jiffies(MAX_SUSPEND_MSECS))) { | |
259 | ||
260 | dev_warn(&ihost->pdev->dev, "%s host%d timeout all\n", | |
261 | __func__, ihost->id); | |
262 | dev_dbg(&ihost->pdev->dev, | |
263 | "%s: ******* Timeout waiting for " | |
264 | "suspend; idev=%p, current state %s; " | |
265 | "started_request_count=%d, flags=%lx\n\t" | |
266 | "rnc_suspend_count=%d, " | |
267 | "RNC: current state %s, " | |
268 | "rnc.suspend_count=%d, current " | |
269 | "suspend_type %x dest state %d\n", | |
270 | __func__, idev, | |
271 | dev_state_name(idev->sm.current_state_id), | |
272 | idev->started_request_count, idev->flags, | |
273 | rnc_suspend_count, | |
274 | rnc_state_name(idev->rnc.sm.current_state_id), | |
275 | idev->rnc.suspend_count, | |
276 | idev->rnc.suspend_type, | |
277 | idev->rnc.destination_state); | |
278 | } | |
14aaa9f0 JS |
279 | } |
280 | dev_dbg(&ihost->pdev->dev, "%s: idev=%p, wait done\n", | |
281 | __func__, idev); | |
726980d5 JS |
282 | isci_put_device(idev); |
283 | } | |
284 | return status; | |
285 | } | |
286 | ||
14aaa9f0 JS |
287 | /** |
288 | * isci_remote_device_not_ready() - This function is called by the ihost when | |
289 | * the remote device is not ready. We mark the isci device as ready (not | |
290 | * "ready_for_io") and signal the waiting proccess. | |
291 | * @isci_host: This parameter specifies the isci host object. | |
292 | * @isci_device: This parameter specifies the remote device | |
293 | * | |
294 | * sci_lock is held on entrance to this function. | |
295 | */ | |
296 | static void isci_remote_device_not_ready(struct isci_host *ihost, | |
297 | struct isci_remote_device *idev, | |
298 | u32 reason) | |
299 | { | |
300 | dev_dbg(&ihost->pdev->dev, | |
59e35396 | 301 | "%s: isci_device = %p; reason = %d\n", __func__, idev, reason); |
14aaa9f0 JS |
302 | |
303 | switch (reason) { | |
14aaa9f0 JS |
304 | case SCIC_REMOTE_DEVICE_NOT_READY_SATA_SDB_ERROR_FIS_RECEIVED: |
305 | set_bit(IDEV_IO_NCQERROR, &idev->flags); | |
306 | ||
307 | /* Suspend the remote device so the I/O can be terminated. */ | |
c94fc1ad | 308 | sci_remote_device_suspend(idev, SCI_SW_SUSPEND_NORMAL); |
14aaa9f0 JS |
309 | |
310 | /* Kill all outstanding requests for the device. */ | |
311 | sci_remote_device_terminate_requests(idev); | |
312 | ||
313 | /* Fall through into the default case... */ | |
314 | default: | |
315 | clear_bit(IDEV_IO_READY, &idev->flags); | |
316 | break; | |
317 | } | |
318 | } | |
319 | ||
ec575669 DW |
320 | /* called once the remote node context is ready to be freed. |
321 | * The remote device can now report that its stop operation is complete. none | |
322 | */ | |
323 | static void rnc_destruct_done(void *_dev) | |
324 | { | |
78a6f06e | 325 | struct isci_remote_device *idev = _dev; |
ab2e8f7d | 326 | |
78a6f06e DW |
327 | BUG_ON(idev->started_request_count != 0); |
328 | sci_change_state(&idev->sm, SCI_DEV_STOPPED); | |
ec575669 | 329 | } |
ab2e8f7d | 330 | |
726980d5 JS |
331 | enum sci_status sci_remote_device_terminate_requests( |
332 | struct isci_remote_device *idev) | |
333 | { | |
14aaa9f0 | 334 | return sci_remote_device_terminate_reqs_checkabort(idev, 0); |
726980d5 JS |
335 | } |
336 | ||
89a7301f | 337 | enum sci_status sci_remote_device_stop(struct isci_remote_device *idev, |
ec575669 | 338 | u32 timeout) |
88f3b62a | 339 | { |
78a6f06e | 340 | struct sci_base_state_machine *sm = &idev->sm; |
89a7301f | 341 | enum sci_remote_device_states state = sm->current_state_id; |
ec575669 DW |
342 | |
343 | switch (state) { | |
e301370a EN |
344 | case SCI_DEV_INITIAL: |
345 | case SCI_DEV_FAILED: | |
346 | case SCI_DEV_FINAL: | |
ec575669 | 347 | default: |
d7a0ccdd DW |
348 | dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %s\n", |
349 | __func__, dev_state_name(state)); | |
ec575669 | 350 | return SCI_FAILURE_INVALID_STATE; |
e301370a | 351 | case SCI_DEV_STOPPED: |
ec575669 | 352 | return SCI_SUCCESS; |
e301370a | 353 | case SCI_DEV_STARTING: |
ec575669 | 354 | /* device not started so there had better be no requests */ |
78a6f06e | 355 | BUG_ON(idev->started_request_count != 0); |
89a7301f | 356 | sci_remote_node_context_destruct(&idev->rnc, |
78a6f06e | 357 | rnc_destruct_done, idev); |
ec575669 DW |
358 | /* Transition to the stopping state and wait for the |
359 | * remote node to complete being posted and invalidated. | |
360 | */ | |
e301370a | 361 | sci_change_state(sm, SCI_DEV_STOPPING); |
ec575669 | 362 | return SCI_SUCCESS; |
e301370a EN |
363 | case SCI_DEV_READY: |
364 | case SCI_STP_DEV_IDLE: | |
365 | case SCI_STP_DEV_CMD: | |
366 | case SCI_STP_DEV_NCQ: | |
367 | case SCI_STP_DEV_NCQ_ERROR: | |
368 | case SCI_STP_DEV_AWAIT_RESET: | |
369 | case SCI_SMP_DEV_IDLE: | |
370 | case SCI_SMP_DEV_CMD: | |
371 | sci_change_state(sm, SCI_DEV_STOPPING); | |
83884014 | 372 | if (idev->started_request_count == 0) |
89a7301f | 373 | sci_remote_node_context_destruct(&idev->rnc, |
83884014 JS |
374 | rnc_destruct_done, |
375 | idev); | |
376 | else { | |
c94fc1ad JS |
377 | sci_remote_device_suspend( |
378 | idev, SCI_SW_SUSPEND_LINKHANG_DETECT); | |
83884014 JS |
379 | sci_remote_device_terminate_requests(idev); |
380 | } | |
381 | return SCI_SUCCESS; | |
e301370a | 382 | case SCI_DEV_STOPPING: |
ec575669 DW |
383 | /* All requests should have been terminated, but if there is an |
384 | * attempt to stop a device already in the stopping state, then | |
385 | * try again to terminate. | |
386 | */ | |
89a7301f | 387 | return sci_remote_device_terminate_requests(idev); |
e301370a EN |
388 | case SCI_DEV_RESETTING: |
389 | sci_change_state(sm, SCI_DEV_STOPPING); | |
ec575669 DW |
390 | return SCI_SUCCESS; |
391 | } | |
88f3b62a DW |
392 | } |
393 | ||
89a7301f | 394 | enum sci_status sci_remote_device_reset(struct isci_remote_device *idev) |
88f3b62a | 395 | { |
78a6f06e | 396 | struct sci_base_state_machine *sm = &idev->sm; |
89a7301f | 397 | enum sci_remote_device_states state = sm->current_state_id; |
4fd0d2e9 DW |
398 | |
399 | switch (state) { | |
e301370a EN |
400 | case SCI_DEV_INITIAL: |
401 | case SCI_DEV_STOPPED: | |
402 | case SCI_DEV_STARTING: | |
403 | case SCI_SMP_DEV_IDLE: | |
404 | case SCI_SMP_DEV_CMD: | |
405 | case SCI_DEV_STOPPING: | |
406 | case SCI_DEV_FAILED: | |
407 | case SCI_DEV_RESETTING: | |
408 | case SCI_DEV_FINAL: | |
4fd0d2e9 | 409 | default: |
d7a0ccdd DW |
410 | dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %s\n", |
411 | __func__, dev_state_name(state)); | |
4fd0d2e9 | 412 | return SCI_FAILURE_INVALID_STATE; |
e301370a EN |
413 | case SCI_DEV_READY: |
414 | case SCI_STP_DEV_IDLE: | |
415 | case SCI_STP_DEV_CMD: | |
416 | case SCI_STP_DEV_NCQ: | |
417 | case SCI_STP_DEV_NCQ_ERROR: | |
418 | case SCI_STP_DEV_AWAIT_RESET: | |
419 | sci_change_state(sm, SCI_DEV_RESETTING); | |
4fd0d2e9 DW |
420 | return SCI_SUCCESS; |
421 | } | |
88f3b62a DW |
422 | } |
423 | ||
89a7301f | 424 | enum sci_status sci_remote_device_reset_complete(struct isci_remote_device *idev) |
88f3b62a | 425 | { |
78a6f06e | 426 | struct sci_base_state_machine *sm = &idev->sm; |
89a7301f | 427 | enum sci_remote_device_states state = sm->current_state_id; |
81515182 | 428 | |
e301370a | 429 | if (state != SCI_DEV_RESETTING) { |
d7a0ccdd DW |
430 | dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %s\n", |
431 | __func__, dev_state_name(state)); | |
81515182 DW |
432 | return SCI_FAILURE_INVALID_STATE; |
433 | } | |
88f3b62a | 434 | |
e301370a | 435 | sci_change_state(sm, SCI_DEV_READY); |
81515182 DW |
436 | return SCI_SUCCESS; |
437 | } | |
88f3b62a | 438 | |
89a7301f | 439 | enum sci_status sci_remote_device_frame_handler(struct isci_remote_device *idev, |
01bec778 | 440 | u32 frame_index) |
88f3b62a | 441 | { |
78a6f06e | 442 | struct sci_base_state_machine *sm = &idev->sm; |
89a7301f | 443 | enum sci_remote_device_states state = sm->current_state_id; |
d9dcb4ba | 444 | struct isci_host *ihost = idev->owning_port->owning_controller; |
01bec778 DW |
445 | enum sci_status status; |
446 | ||
447 | switch (state) { | |
e301370a EN |
448 | case SCI_DEV_INITIAL: |
449 | case SCI_DEV_STOPPED: | |
450 | case SCI_DEV_STARTING: | |
451 | case SCI_STP_DEV_IDLE: | |
452 | case SCI_SMP_DEV_IDLE: | |
453 | case SCI_DEV_FINAL: | |
01bec778 | 454 | default: |
d7a0ccdd DW |
455 | dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %s\n", |
456 | __func__, dev_state_name(state)); | |
01bec778 | 457 | /* Return the frame back to the controller */ |
89a7301f | 458 | sci_controller_release_frame(ihost, frame_index); |
01bec778 | 459 | return SCI_FAILURE_INVALID_STATE; |
e301370a EN |
460 | case SCI_DEV_READY: |
461 | case SCI_STP_DEV_NCQ_ERROR: | |
462 | case SCI_STP_DEV_AWAIT_RESET: | |
463 | case SCI_DEV_STOPPING: | |
464 | case SCI_DEV_FAILED: | |
465 | case SCI_DEV_RESETTING: { | |
5076a1a9 | 466 | struct isci_request *ireq; |
2d9c2240 DJ |
467 | struct ssp_frame_hdr hdr; |
468 | void *frame_header; | |
469 | ssize_t word_cnt; | |
01bec778 | 470 | |
89a7301f | 471 | status = sci_unsolicited_frame_control_get_header(&ihost->uf_control, |
01bec778 | 472 | frame_index, |
2d9c2240 | 473 | &frame_header); |
01bec778 DW |
474 | if (status != SCI_SUCCESS) |
475 | return status; | |
476 | ||
2d9c2240 DJ |
477 | word_cnt = sizeof(hdr) / sizeof(u32); |
478 | sci_swab32_cpy(&hdr, frame_header, word_cnt); | |
479 | ||
89a7301f | 480 | ireq = sci_request_by_tag(ihost, be16_to_cpu(hdr.tag)); |
78a6f06e | 481 | if (ireq && ireq->target_device == idev) { |
01bec778 | 482 | /* The IO request is now in charge of releasing the frame */ |
89a7301f | 483 | status = sci_io_request_frame_handler(ireq, frame_index); |
01bec778 DW |
484 | } else { |
485 | /* We could not map this tag to a valid IO | |
486 | * request Just toss the frame and continue | |
487 | */ | |
89a7301f | 488 | sci_controller_release_frame(ihost, frame_index); |
01bec778 DW |
489 | } |
490 | break; | |
491 | } | |
e301370a | 492 | case SCI_STP_DEV_NCQ: { |
e76d6180 | 493 | struct dev_to_host_fis *hdr; |
01bec778 | 494 | |
89a7301f | 495 | status = sci_unsolicited_frame_control_get_header(&ihost->uf_control, |
01bec778 DW |
496 | frame_index, |
497 | (void **)&hdr); | |
498 | if (status != SCI_SUCCESS) | |
499 | return status; | |
500 | ||
e76d6180 DJ |
501 | if (hdr->fis_type == FIS_SETDEVBITS && |
502 | (hdr->status & ATA_ERR)) { | |
78a6f06e | 503 | idev->not_ready_reason = SCIC_REMOTE_DEVICE_NOT_READY_SATA_SDB_ERROR_FIS_RECEIVED; |
01bec778 DW |
504 | |
505 | /* TODO Check sactive and complete associated IO if any. */ | |
e301370a | 506 | sci_change_state(sm, SCI_STP_DEV_NCQ_ERROR); |
e76d6180 DJ |
507 | } else if (hdr->fis_type == FIS_REGD2H && |
508 | (hdr->status & ATA_ERR)) { | |
01bec778 DW |
509 | /* |
510 | * Some devices return D2H FIS when an NCQ error is detected. | |
511 | * Treat this like an SDB error FIS ready reason. | |
512 | */ | |
78a6f06e DW |
513 | idev->not_ready_reason = SCIC_REMOTE_DEVICE_NOT_READY_SATA_SDB_ERROR_FIS_RECEIVED; |
514 | sci_change_state(&idev->sm, SCI_STP_DEV_NCQ_ERROR); | |
01bec778 DW |
515 | } else |
516 | status = SCI_FAILURE; | |
517 | ||
89a7301f | 518 | sci_controller_release_frame(ihost, frame_index); |
01bec778 DW |
519 | break; |
520 | } | |
e301370a EN |
521 | case SCI_STP_DEV_CMD: |
522 | case SCI_SMP_DEV_CMD: | |
01bec778 DW |
523 | /* The device does not process any UF received from the hardware while |
524 | * in this state. All unsolicited frames are forwarded to the io request | |
525 | * object. | |
526 | */ | |
89a7301f | 527 | status = sci_io_request_frame_handler(idev->working_request, frame_index); |
01bec778 DW |
528 | break; |
529 | } | |
530 | ||
531 | return status; | |
88f3b62a DW |
532 | } |
533 | ||
78a6f06e | 534 | static bool is_remote_device_ready(struct isci_remote_device *idev) |
88f3b62a | 535 | { |
e622571f | 536 | |
78a6f06e | 537 | struct sci_base_state_machine *sm = &idev->sm; |
89a7301f | 538 | enum sci_remote_device_states state = sm->current_state_id; |
e622571f DW |
539 | |
540 | switch (state) { | |
e301370a EN |
541 | case SCI_DEV_READY: |
542 | case SCI_STP_DEV_IDLE: | |
543 | case SCI_STP_DEV_CMD: | |
544 | case SCI_STP_DEV_NCQ: | |
545 | case SCI_STP_DEV_NCQ_ERROR: | |
546 | case SCI_STP_DEV_AWAIT_RESET: | |
547 | case SCI_SMP_DEV_IDLE: | |
548 | case SCI_SMP_DEV_CMD: | |
e622571f DW |
549 | return true; |
550 | default: | |
551 | return false; | |
552 | } | |
553 | } | |
554 | ||
b50102d3 DW |
555 | /* |
556 | * called once the remote node context has transisitioned to a ready | |
557 | * state (after suspending RX and/or TX due to early D2H fis) | |
558 | */ | |
559 | static void atapi_remote_device_resume_done(void *_dev) | |
560 | { | |
561 | struct isci_remote_device *idev = _dev; | |
562 | struct isci_request *ireq = idev->working_request; | |
563 | ||
564 | sci_change_state(&ireq->sm, SCI_REQ_COMPLETED); | |
565 | } | |
566 | ||
89a7301f | 567 | enum sci_status sci_remote_device_event_handler(struct isci_remote_device *idev, |
e622571f DW |
568 | u32 event_code) |
569 | { | |
e622571f | 570 | enum sci_status status; |
87805162 JS |
571 | struct sci_base_state_machine *sm = &idev->sm; |
572 | enum sci_remote_device_states state = sm->current_state_id; | |
e622571f DW |
573 | |
574 | switch (scu_get_event_type(event_code)) { | |
575 | case SCU_EVENT_TYPE_RNC_OPS_MISC: | |
576 | case SCU_EVENT_TYPE_RNC_SUSPEND_TX: | |
577 | case SCU_EVENT_TYPE_RNC_SUSPEND_TX_RX: | |
89a7301f | 578 | status = sci_remote_node_context_event_handler(&idev->rnc, event_code); |
e622571f DW |
579 | break; |
580 | case SCU_EVENT_TYPE_PTX_SCHEDULE_EVENT: | |
581 | if (scu_get_event_code(event_code) == SCU_EVENT_IT_NEXUS_TIMEOUT) { | |
582 | status = SCI_SUCCESS; | |
583 | ||
584 | /* Suspend the associated RNC */ | |
c94fc1ad | 585 | sci_remote_device_suspend(idev, SCI_SW_SUSPEND_NORMAL); |
e622571f | 586 | |
78a6f06e | 587 | dev_dbg(scirdev_to_dev(idev), |
e622571f | 588 | "%s: device: %p event code: %x: %s\n", |
78a6f06e DW |
589 | __func__, idev, event_code, |
590 | is_remote_device_ready(idev) | |
e622571f DW |
591 | ? "I_T_Nexus_Timeout event" |
592 | : "I_T_Nexus_Timeout event in wrong state"); | |
593 | ||
594 | break; | |
595 | } | |
596 | /* Else, fall through and treat as unhandled... */ | |
597 | default: | |
78a6f06e | 598 | dev_dbg(scirdev_to_dev(idev), |
e622571f | 599 | "%s: device: %p event code: %x: %s\n", |
78a6f06e DW |
600 | __func__, idev, event_code, |
601 | is_remote_device_ready(idev) | |
e622571f DW |
602 | ? "unexpected event" |
603 | : "unexpected event in wrong state"); | |
604 | status = SCI_FAILURE_INVALID_STATE; | |
605 | break; | |
606 | } | |
607 | ||
608 | if (status != SCI_SUCCESS) | |
609 | return status; | |
610 | ||
87805162 JS |
611 | /* Decode device-specific states that may require an RNC resume during |
612 | * normal operation. When the abort path is active, these resumes are | |
613 | * managed when the abort path exits. | |
614 | */ | |
615 | if (state == SCI_STP_DEV_ATAPI_ERROR) { | |
616 | /* For ATAPI error state resume the RNC right away. */ | |
617 | if (scu_get_event_type(event_code) == SCU_EVENT_TYPE_RNC_SUSPEND_TX || | |
618 | scu_get_event_type(event_code) == SCU_EVENT_TYPE_RNC_SUSPEND_TX_RX) { | |
619 | return sci_remote_node_context_resume(&idev->rnc, | |
620 | atapi_remote_device_resume_done, | |
621 | idev); | |
622 | } | |
623 | } | |
624 | ||
625 | if (state == SCI_STP_DEV_IDLE) { | |
626 | ||
627 | /* We pick up suspension events to handle specifically to this | |
628 | * state. We resume the RNC right away. | |
629 | */ | |
630 | if (scu_get_event_type(event_code) == SCU_EVENT_TYPE_RNC_SUSPEND_TX || | |
631 | scu_get_event_type(event_code) == SCU_EVENT_TYPE_RNC_SUSPEND_TX_RX) | |
632 | status = sci_remote_node_context_resume(&idev->rnc, NULL, NULL); | |
633 | } | |
634 | ||
e622571f | 635 | return status; |
88f3b62a DW |
636 | } |
637 | ||
89a7301f | 638 | static void sci_remote_device_start_request(struct isci_remote_device *idev, |
5076a1a9 | 639 | struct isci_request *ireq, |
18606557 | 640 | enum sci_status status) |
88f3b62a | 641 | { |
78a6f06e | 642 | struct isci_port *iport = idev->owning_port; |
18606557 DW |
643 | |
644 | /* cleanup requests that failed after starting on the port */ | |
645 | if (status != SCI_SUCCESS) | |
89a7301f | 646 | sci_port_complete_io(iport, idev, ireq); |
209fae14 | 647 | else { |
78a6f06e | 648 | kref_get(&idev->kref); |
34a99158 | 649 | idev->started_request_count++; |
209fae14 | 650 | } |
18606557 DW |
651 | } |
652 | ||
89a7301f | 653 | enum sci_status sci_remote_device_start_io(struct isci_host *ihost, |
78a6f06e | 654 | struct isci_remote_device *idev, |
5076a1a9 | 655 | struct isci_request *ireq) |
18606557 | 656 | { |
78a6f06e | 657 | struct sci_base_state_machine *sm = &idev->sm; |
89a7301f | 658 | enum sci_remote_device_states state = sm->current_state_id; |
78a6f06e | 659 | struct isci_port *iport = idev->owning_port; |
18606557 DW |
660 | enum sci_status status; |
661 | ||
662 | switch (state) { | |
e301370a EN |
663 | case SCI_DEV_INITIAL: |
664 | case SCI_DEV_STOPPED: | |
665 | case SCI_DEV_STARTING: | |
666 | case SCI_STP_DEV_NCQ_ERROR: | |
667 | case SCI_DEV_STOPPING: | |
668 | case SCI_DEV_FAILED: | |
669 | case SCI_DEV_RESETTING: | |
670 | case SCI_DEV_FINAL: | |
18606557 | 671 | default: |
d7a0ccdd DW |
672 | dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %s\n", |
673 | __func__, dev_state_name(state)); | |
18606557 | 674 | return SCI_FAILURE_INVALID_STATE; |
e301370a | 675 | case SCI_DEV_READY: |
18606557 DW |
676 | /* attempt to start an io request for this device object. The remote |
677 | * device object will issue the start request for the io and if | |
678 | * successful it will start the request for the port object then | |
679 | * increment its own request count. | |
680 | */ | |
89a7301f | 681 | status = sci_port_start_io(iport, idev, ireq); |
18606557 DW |
682 | if (status != SCI_SUCCESS) |
683 | return status; | |
684 | ||
89a7301f | 685 | status = sci_remote_node_context_start_io(&idev->rnc, ireq); |
18606557 DW |
686 | if (status != SCI_SUCCESS) |
687 | break; | |
688 | ||
89a7301f | 689 | status = sci_request_start(ireq); |
18606557 | 690 | break; |
e301370a | 691 | case SCI_STP_DEV_IDLE: { |
18606557 DW |
692 | /* handle the start io operation for a sata device that is in |
693 | * the command idle state. - Evalute the type of IO request to | |
694 | * be started - If its an NCQ request change to NCQ substate - | |
695 | * If its any other command change to the CMD substate | |
696 | * | |
697 | * If this is a softreset we may want to have a different | |
698 | * substate. | |
699 | */ | |
89a7301f | 700 | enum sci_remote_device_states new_state; |
e76d6180 | 701 | struct sas_task *task = isci_request_access_task(ireq); |
18606557 | 702 | |
89a7301f | 703 | status = sci_port_start_io(iport, idev, ireq); |
18606557 DW |
704 | if (status != SCI_SUCCESS) |
705 | return status; | |
706 | ||
89a7301f | 707 | status = sci_remote_node_context_start_io(&idev->rnc, ireq); |
18606557 DW |
708 | if (status != SCI_SUCCESS) |
709 | break; | |
710 | ||
89a7301f | 711 | status = sci_request_start(ireq); |
18606557 DW |
712 | if (status != SCI_SUCCESS) |
713 | break; | |
714 | ||
e76d6180 | 715 | if (task->ata_task.use_ncq) |
e301370a | 716 | new_state = SCI_STP_DEV_NCQ; |
18606557 | 717 | else { |
78a6f06e | 718 | idev->working_request = ireq; |
e301370a | 719 | new_state = SCI_STP_DEV_CMD; |
18606557 | 720 | } |
e301370a | 721 | sci_change_state(sm, new_state); |
18606557 DW |
722 | break; |
723 | } | |
e301370a | 724 | case SCI_STP_DEV_NCQ: { |
e76d6180 DJ |
725 | struct sas_task *task = isci_request_access_task(ireq); |
726 | ||
727 | if (task->ata_task.use_ncq) { | |
89a7301f | 728 | status = sci_port_start_io(iport, idev, ireq); |
18606557 DW |
729 | if (status != SCI_SUCCESS) |
730 | return status; | |
731 | ||
89a7301f | 732 | status = sci_remote_node_context_start_io(&idev->rnc, ireq); |
18606557 DW |
733 | if (status != SCI_SUCCESS) |
734 | break; | |
735 | ||
89a7301f | 736 | status = sci_request_start(ireq); |
18606557 DW |
737 | } else |
738 | return SCI_FAILURE_INVALID_STATE; | |
739 | break; | |
e76d6180 | 740 | } |
e301370a | 741 | case SCI_STP_DEV_AWAIT_RESET: |
18606557 | 742 | return SCI_FAILURE_REMOTE_DEVICE_RESET_REQUIRED; |
e301370a | 743 | case SCI_SMP_DEV_IDLE: |
89a7301f | 744 | status = sci_port_start_io(iport, idev, ireq); |
18606557 DW |
745 | if (status != SCI_SUCCESS) |
746 | return status; | |
747 | ||
89a7301f | 748 | status = sci_remote_node_context_start_io(&idev->rnc, ireq); |
18606557 DW |
749 | if (status != SCI_SUCCESS) |
750 | break; | |
751 | ||
89a7301f | 752 | status = sci_request_start(ireq); |
18606557 DW |
753 | if (status != SCI_SUCCESS) |
754 | break; | |
755 | ||
78a6f06e DW |
756 | idev->working_request = ireq; |
757 | sci_change_state(&idev->sm, SCI_SMP_DEV_CMD); | |
18606557 | 758 | break; |
e301370a EN |
759 | case SCI_STP_DEV_CMD: |
760 | case SCI_SMP_DEV_CMD: | |
18606557 DW |
761 | /* device is already handling a command it can not accept new commands |
762 | * until this one is complete. | |
763 | */ | |
764 | return SCI_FAILURE_INVALID_STATE; | |
765 | } | |
766 | ||
89a7301f | 767 | sci_remote_device_start_request(idev, ireq, status); |
18606557 | 768 | return status; |
88f3b62a DW |
769 | } |
770 | ||
ffe191c9 | 771 | static enum sci_status common_complete_io(struct isci_port *iport, |
78a6f06e | 772 | struct isci_remote_device *idev, |
5076a1a9 | 773 | struct isci_request *ireq) |
88f3b62a | 774 | { |
10a09e64 DW |
775 | enum sci_status status; |
776 | ||
89a7301f | 777 | status = sci_request_complete(ireq); |
10a09e64 DW |
778 | if (status != SCI_SUCCESS) |
779 | return status; | |
780 | ||
89a7301f | 781 | status = sci_port_complete_io(iport, idev, ireq); |
10a09e64 DW |
782 | if (status != SCI_SUCCESS) |
783 | return status; | |
784 | ||
89a7301f | 785 | sci_remote_device_decrement_request_count(idev); |
10a09e64 DW |
786 | return status; |
787 | } | |
788 | ||
89a7301f | 789 | enum sci_status sci_remote_device_complete_io(struct isci_host *ihost, |
78a6f06e | 790 | struct isci_remote_device *idev, |
5076a1a9 | 791 | struct isci_request *ireq) |
10a09e64 | 792 | { |
78a6f06e | 793 | struct sci_base_state_machine *sm = &idev->sm; |
89a7301f | 794 | enum sci_remote_device_states state = sm->current_state_id; |
78a6f06e | 795 | struct isci_port *iport = idev->owning_port; |
10a09e64 DW |
796 | enum sci_status status; |
797 | ||
798 | switch (state) { | |
e301370a EN |
799 | case SCI_DEV_INITIAL: |
800 | case SCI_DEV_STOPPED: | |
801 | case SCI_DEV_STARTING: | |
802 | case SCI_STP_DEV_IDLE: | |
803 | case SCI_SMP_DEV_IDLE: | |
804 | case SCI_DEV_FAILED: | |
805 | case SCI_DEV_FINAL: | |
10a09e64 | 806 | default: |
d7a0ccdd DW |
807 | dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %s\n", |
808 | __func__, dev_state_name(state)); | |
10a09e64 | 809 | return SCI_FAILURE_INVALID_STATE; |
e301370a EN |
810 | case SCI_DEV_READY: |
811 | case SCI_STP_DEV_AWAIT_RESET: | |
812 | case SCI_DEV_RESETTING: | |
78a6f06e | 813 | status = common_complete_io(iport, idev, ireq); |
10a09e64 | 814 | break; |
e301370a EN |
815 | case SCI_STP_DEV_CMD: |
816 | case SCI_STP_DEV_NCQ: | |
817 | case SCI_STP_DEV_NCQ_ERROR: | |
b50102d3 | 818 | case SCI_STP_DEV_ATAPI_ERROR: |
78a6f06e | 819 | status = common_complete_io(iport, idev, ireq); |
10a09e64 DW |
820 | if (status != SCI_SUCCESS) |
821 | break; | |
822 | ||
5076a1a9 | 823 | if (ireq->sci_status == SCI_FAILURE_REMOTE_DEVICE_RESET_REQUIRED) { |
10a09e64 DW |
824 | /* This request causes hardware error, device needs to be Lun Reset. |
825 | * So here we force the state machine to IDLE state so the rest IOs | |
826 | * can reach RNC state handler, these IOs will be completed by RNC with | |
827 | * status of "DEVICE_RESET_REQUIRED", instead of "INVALID STATE". | |
828 | */ | |
e301370a | 829 | sci_change_state(sm, SCI_STP_DEV_AWAIT_RESET); |
34a99158 | 830 | } else if (idev->started_request_count == 0) |
e301370a | 831 | sci_change_state(sm, SCI_STP_DEV_IDLE); |
10a09e64 | 832 | break; |
e301370a | 833 | case SCI_SMP_DEV_CMD: |
78a6f06e | 834 | status = common_complete_io(iport, idev, ireq); |
10a09e64 DW |
835 | if (status != SCI_SUCCESS) |
836 | break; | |
e301370a | 837 | sci_change_state(sm, SCI_SMP_DEV_IDLE); |
10a09e64 | 838 | break; |
e301370a | 839 | case SCI_DEV_STOPPING: |
78a6f06e | 840 | status = common_complete_io(iport, idev, ireq); |
10a09e64 DW |
841 | if (status != SCI_SUCCESS) |
842 | break; | |
843 | ||
34a99158 | 844 | if (idev->started_request_count == 0) |
89a7301f | 845 | sci_remote_node_context_destruct(&idev->rnc, |
34a99158 DW |
846 | rnc_destruct_done, |
847 | idev); | |
10a09e64 DW |
848 | break; |
849 | } | |
850 | ||
851 | if (status != SCI_SUCCESS) | |
78a6f06e | 852 | dev_err(scirdev_to_dev(idev), |
10a09e64 | 853 | "%s: Port:0x%p Device:0x%p Request:0x%p Status:0x%x " |
ffe191c9 | 854 | "could not complete\n", __func__, iport, |
78a6f06e | 855 | idev, ireq, status); |
209fae14 | 856 | else |
78a6f06e | 857 | isci_put_device(idev); |
10a09e64 DW |
858 | |
859 | return status; | |
88f3b62a DW |
860 | } |
861 | ||
89a7301f | 862 | static void sci_remote_device_continue_request(void *dev) |
88f3b62a | 863 | { |
78a6f06e | 864 | struct isci_remote_device *idev = dev; |
84b9b029 DW |
865 | |
866 | /* we need to check if this request is still valid to continue. */ | |
78a6f06e | 867 | if (idev->working_request) |
89a7301f | 868 | sci_controller_continue_io(idev->working_request); |
84b9b029 DW |
869 | } |
870 | ||
89a7301f | 871 | enum sci_status sci_remote_device_start_task(struct isci_host *ihost, |
78a6f06e | 872 | struct isci_remote_device *idev, |
5076a1a9 | 873 | struct isci_request *ireq) |
84b9b029 | 874 | { |
78a6f06e | 875 | struct sci_base_state_machine *sm = &idev->sm; |
89a7301f | 876 | enum sci_remote_device_states state = sm->current_state_id; |
78a6f06e | 877 | struct isci_port *iport = idev->owning_port; |
84b9b029 DW |
878 | enum sci_status status; |
879 | ||
880 | switch (state) { | |
e301370a EN |
881 | case SCI_DEV_INITIAL: |
882 | case SCI_DEV_STOPPED: | |
883 | case SCI_DEV_STARTING: | |
884 | case SCI_SMP_DEV_IDLE: | |
885 | case SCI_SMP_DEV_CMD: | |
886 | case SCI_DEV_STOPPING: | |
887 | case SCI_DEV_FAILED: | |
888 | case SCI_DEV_RESETTING: | |
889 | case SCI_DEV_FINAL: | |
84b9b029 | 890 | default: |
d7a0ccdd DW |
891 | dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %s\n", |
892 | __func__, dev_state_name(state)); | |
84b9b029 | 893 | return SCI_FAILURE_INVALID_STATE; |
e301370a EN |
894 | case SCI_STP_DEV_IDLE: |
895 | case SCI_STP_DEV_CMD: | |
896 | case SCI_STP_DEV_NCQ: | |
897 | case SCI_STP_DEV_NCQ_ERROR: | |
898 | case SCI_STP_DEV_AWAIT_RESET: | |
89a7301f | 899 | status = sci_port_start_io(iport, idev, ireq); |
84b9b029 DW |
900 | if (status != SCI_SUCCESS) |
901 | return status; | |
902 | ||
89a7301f | 903 | status = sci_request_start(ireq); |
84b9b029 DW |
904 | if (status != SCI_SUCCESS) |
905 | goto out; | |
906 | ||
907 | /* Note: If the remote device state is not IDLE this will | |
908 | * replace the request that probably resulted in the task | |
909 | * management request. | |
910 | */ | |
78a6f06e | 911 | idev->working_request = ireq; |
e301370a | 912 | sci_change_state(sm, SCI_STP_DEV_CMD); |
84b9b029 DW |
913 | |
914 | /* The remote node context must cleanup the TCi to NCQ mapping | |
915 | * table. The only way to do this correctly is to either write | |
916 | * to the TLCR register or to invalidate and repost the RNC. In | |
917 | * either case the remote node context state machine will take | |
918 | * the correct action when the remote node context is suspended | |
919 | * and later resumed. | |
920 | */ | |
c94fc1ad JS |
921 | sci_remote_device_suspend(idev, |
922 | SCI_SW_SUSPEND_LINKHANG_DETECT); | |
14aaa9f0 JS |
923 | |
924 | status = sci_remote_node_context_start_task(&idev->rnc, ireq, | |
925 | sci_remote_device_continue_request, idev); | |
84b9b029 DW |
926 | |
927 | out: | |
89a7301f | 928 | sci_remote_device_start_request(idev, ireq, status); |
84b9b029 DW |
929 | /* We need to let the controller start request handler know that |
930 | * it can't post TC yet. We will provide a callback function to | |
931 | * post TC when RNC gets resumed. | |
932 | */ | |
933 | return SCI_FAILURE_RESET_DEVICE_PARTIAL_SUCCESS; | |
e301370a | 934 | case SCI_DEV_READY: |
89a7301f | 935 | status = sci_port_start_io(iport, idev, ireq); |
84b9b029 DW |
936 | if (status != SCI_SUCCESS) |
937 | return status; | |
938 | ||
14aaa9f0 JS |
939 | /* Resume the RNC as needed: */ |
940 | status = sci_remote_node_context_start_task(&idev->rnc, ireq, | |
941 | NULL, NULL); | |
84b9b029 DW |
942 | if (status != SCI_SUCCESS) |
943 | break; | |
944 | ||
89a7301f | 945 | status = sci_request_start(ireq); |
84b9b029 DW |
946 | break; |
947 | } | |
89a7301f | 948 | sci_remote_device_start_request(idev, ireq, status); |
84b9b029 DW |
949 | |
950 | return status; | |
88f3b62a DW |
951 | } |
952 | ||
34a99158 | 953 | void sci_remote_device_post_request(struct isci_remote_device *idev, u32 request) |
88f3b62a | 954 | { |
34a99158 | 955 | struct isci_port *iport = idev->owning_port; |
88f3b62a DW |
956 | u32 context; |
957 | ||
34a99158 DW |
958 | context = request | |
959 | (ISCI_PEG << SCU_CONTEXT_COMMAND_PROTOCOL_ENGINE_GROUP_SHIFT) | | |
960 | (iport->physical_port_index << SCU_CONTEXT_COMMAND_LOGICAL_PORT_SHIFT) | | |
961 | idev->rnc.remote_node_index; | |
88f3b62a | 962 | |
34a99158 | 963 | sci_controller_post_request(iport->owning_controller, context); |
88f3b62a DW |
964 | } |
965 | ||
ab2e8f7d | 966 | /* called once the remote node context has transisitioned to a |
88f3b62a | 967 | * ready state. This is the indication that the remote device object can also |
ab2e8f7d | 968 | * transition to ready. |
88f3b62a | 969 | */ |
eb229671 | 970 | static void remote_device_resume_done(void *_dev) |
ab2e8f7d | 971 | { |
78a6f06e | 972 | struct isci_remote_device *idev = _dev; |
ab2e8f7d | 973 | |
78a6f06e | 974 | if (is_remote_device_ready(idev)) |
e622571f | 975 | return; |
88f3b62a | 976 | |
e622571f | 977 | /* go 'ready' if we are not already in a ready state */ |
78a6f06e | 978 | sci_change_state(&idev->sm, SCI_DEV_READY); |
88f3b62a DW |
979 | } |
980 | ||
89a7301f | 981 | static void sci_stp_remote_device_ready_idle_substate_resume_complete_handler(void *_dev) |
ab2e8f7d | 982 | { |
78a6f06e | 983 | struct isci_remote_device *idev = _dev; |
d9dcb4ba | 984 | struct isci_host *ihost = idev->owning_port->owning_controller; |
ab2e8f7d DW |
985 | |
986 | /* For NCQ operation we do not issue a isci_remote_device_not_ready(). | |
987 | * As a result, avoid sending the ready notification. | |
988 | */ | |
78a6f06e | 989 | if (idev->sm.previous_state_id != SCI_STP_DEV_NCQ) |
d9dcb4ba | 990 | isci_remote_device_ready(ihost, idev); |
ab2e8f7d DW |
991 | } |
992 | ||
89a7301f | 993 | static void sci_remote_device_initial_state_enter(struct sci_base_state_machine *sm) |
88f3b62a | 994 | { |
78a6f06e | 995 | struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm); |
88f3b62a | 996 | |
ab2e8f7d | 997 | /* Initial state is a transitional state to the stopped state */ |
78a6f06e | 998 | sci_change_state(&idev->sm, SCI_DEV_STOPPED); |
88f3b62a | 999 | } |
6f231dda | 1000 | |
88f3b62a | 1001 | /** |
89a7301f | 1002 | * sci_remote_device_destruct() - free remote node context and destruct |
88f3b62a DW |
1003 | * @remote_device: This parameter specifies the remote device to be destructed. |
1004 | * | |
1005 | * Remote device objects are a limited resource. As such, they must be | |
1006 | * protected. Thus calls to construct and destruct are mutually exclusive and | |
1007 | * non-reentrant. The return value shall indicate if the device was | |
1008 | * successfully destructed or if some failure occurred. enum sci_status This value | |
1009 | * is returned if the device is successfully destructed. | |
1010 | * SCI_FAILURE_INVALID_REMOTE_DEVICE This value is returned if the supplied | |
1011 | * device isn't valid (e.g. it's already been destoryed, the handle isn't | |
1012 | * valid, etc.). | |
1013 | */ | |
89a7301f | 1014 | static enum sci_status sci_remote_device_destruct(struct isci_remote_device *idev) |
88f3b62a | 1015 | { |
78a6f06e | 1016 | struct sci_base_state_machine *sm = &idev->sm; |
89a7301f | 1017 | enum sci_remote_device_states state = sm->current_state_id; |
d9dcb4ba | 1018 | struct isci_host *ihost; |
b8d82f6c | 1019 | |
e301370a | 1020 | if (state != SCI_DEV_STOPPED) { |
d7a0ccdd DW |
1021 | dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %s\n", |
1022 | __func__, dev_state_name(state)); | |
b8d82f6c DW |
1023 | return SCI_FAILURE_INVALID_STATE; |
1024 | } | |
1025 | ||
d9dcb4ba | 1026 | ihost = idev->owning_port->owning_controller; |
89a7301f | 1027 | sci_controller_free_remote_node_context(ihost, idev, |
78a6f06e DW |
1028 | idev->rnc.remote_node_index); |
1029 | idev->rnc.remote_node_index = SCIC_SDS_REMOTE_NODE_CONTEXT_INVALID_INDEX; | |
e301370a | 1030 | sci_change_state(sm, SCI_DEV_FINAL); |
b8d82f6c DW |
1031 | |
1032 | return SCI_SUCCESS; | |
88f3b62a | 1033 | } |
6f231dda DW |
1034 | |
1035 | /** | |
1036 | * isci_remote_device_deconstruct() - This function frees an isci_remote_device. | |
d9c37390 DW |
1037 | * @ihost: This parameter specifies the isci host object. |
1038 | * @idev: This parameter specifies the remote device to be freed. | |
6f231dda DW |
1039 | * |
1040 | */ | |
d9c37390 | 1041 | static void isci_remote_device_deconstruct(struct isci_host *ihost, struct isci_remote_device *idev) |
6f231dda | 1042 | { |
d9c37390 DW |
1043 | dev_dbg(&ihost->pdev->dev, |
1044 | "%s: isci_device = %p\n", __func__, idev); | |
6f231dda DW |
1045 | |
1046 | /* There should not be any outstanding io's. All paths to | |
1047 | * here should go through isci_remote_device_nuke_requests. | |
1048 | * If we hit this condition, we will need a way to complete | |
1049 | * io requests in process */ | |
d6b2a0e4 | 1050 | BUG_ON(idev->started_request_count > 0); |
6f231dda | 1051 | |
89a7301f | 1052 | sci_remote_device_destruct(idev); |
d9c37390 | 1053 | list_del_init(&idev->node); |
209fae14 | 1054 | isci_put_device(idev); |
6f231dda DW |
1055 | } |
1056 | ||
89a7301f | 1057 | static void sci_remote_device_stopped_state_enter(struct sci_base_state_machine *sm) |
88f3b62a | 1058 | { |
78a6f06e | 1059 | struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm); |
d9dcb4ba | 1060 | struct isci_host *ihost = idev->owning_port->owning_controller; |
88f3b62a DW |
1061 | u32 prev_state; |
1062 | ||
88f3b62a DW |
1063 | /* If we are entering from the stopping state let the SCI User know that |
1064 | * the stop operation has completed. | |
1065 | */ | |
78a6f06e | 1066 | prev_state = idev->sm.previous_state_id; |
e301370a | 1067 | if (prev_state == SCI_DEV_STOPPING) |
d9dcb4ba | 1068 | isci_remote_device_deconstruct(ihost, idev); |
88f3b62a | 1069 | |
89a7301f | 1070 | sci_controller_remote_device_stopped(ihost, idev); |
88f3b62a DW |
1071 | } |
1072 | ||
89a7301f | 1073 | static void sci_remote_device_starting_state_enter(struct sci_base_state_machine *sm) |
88f3b62a | 1074 | { |
78a6f06e | 1075 | struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm); |
34a99158 | 1076 | struct isci_host *ihost = idev->owning_port->owning_controller; |
88f3b62a | 1077 | |
88f3b62a DW |
1078 | isci_remote_device_not_ready(ihost, idev, |
1079 | SCIC_REMOTE_DEVICE_NOT_READY_START_REQUESTED); | |
1080 | } | |
1081 | ||
89a7301f | 1082 | static void sci_remote_device_ready_state_enter(struct sci_base_state_machine *sm) |
88f3b62a | 1083 | { |
78a6f06e | 1084 | struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm); |
d9dcb4ba | 1085 | struct isci_host *ihost = idev->owning_port->owning_controller; |
cc3dbd0a | 1086 | struct domain_device *dev = idev->domain_dev; |
88f3b62a | 1087 | |
aa9f8328 | 1088 | if (dev->dev_type == SAS_SATA_DEV || (dev->tproto & SAS_PROTOCOL_SATA)) { |
78a6f06e | 1089 | sci_change_state(&idev->sm, SCI_STP_DEV_IDLE); |
ab2e8f7d | 1090 | } else if (dev_is_expander(dev)) { |
78a6f06e | 1091 | sci_change_state(&idev->sm, SCI_SMP_DEV_IDLE); |
ab2e8f7d | 1092 | } else |
d9dcb4ba | 1093 | isci_remote_device_ready(ihost, idev); |
88f3b62a DW |
1094 | } |
1095 | ||
89a7301f | 1096 | static void sci_remote_device_ready_state_exit(struct sci_base_state_machine *sm) |
88f3b62a | 1097 | { |
78a6f06e DW |
1098 | struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm); |
1099 | struct domain_device *dev = idev->domain_dev; | |
ab2e8f7d | 1100 | |
aa9f8328 | 1101 | if (dev->dev_type == SAS_END_DEVICE) { |
d9dcb4ba | 1102 | struct isci_host *ihost = idev->owning_port->owning_controller; |
88f3b62a | 1103 | |
d9dcb4ba | 1104 | isci_remote_device_not_ready(ihost, idev, |
88f3b62a DW |
1105 | SCIC_REMOTE_DEVICE_NOT_READY_STOP_REQUESTED); |
1106 | } | |
1107 | } | |
1108 | ||
89a7301f | 1109 | static void sci_remote_device_resetting_state_enter(struct sci_base_state_machine *sm) |
88f3b62a | 1110 | { |
78a6f06e | 1111 | struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm); |
ac78ed0f JS |
1112 | struct isci_host *ihost = idev->owning_port->owning_controller; |
1113 | ||
1114 | dev_dbg(&ihost->pdev->dev, | |
1115 | "%s: isci_device = %p\n", __func__, idev); | |
88f3b62a | 1116 | |
c94fc1ad | 1117 | sci_remote_device_suspend(idev, SCI_SW_SUSPEND_LINKHANG_DETECT); |
88f3b62a DW |
1118 | } |
1119 | ||
89a7301f | 1120 | static void sci_remote_device_resetting_state_exit(struct sci_base_state_machine *sm) |
88f3b62a | 1121 | { |
78a6f06e | 1122 | struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm); |
ac78ed0f JS |
1123 | struct isci_host *ihost = idev->owning_port->owning_controller; |
1124 | ||
1125 | dev_dbg(&ihost->pdev->dev, | |
1126 | "%s: isci_device = %p\n", __func__, idev); | |
88f3b62a | 1127 | |
89a7301f | 1128 | sci_remote_node_context_resume(&idev->rnc, NULL, NULL); |
88f3b62a DW |
1129 | } |
1130 | ||
89a7301f | 1131 | static void sci_stp_remote_device_ready_idle_substate_enter(struct sci_base_state_machine *sm) |
ab2e8f7d | 1132 | { |
78a6f06e | 1133 | struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm); |
ab2e8f7d | 1134 | |
78a6f06e | 1135 | idev->working_request = NULL; |
89a7301f | 1136 | if (sci_remote_node_context_is_ready(&idev->rnc)) { |
ab2e8f7d DW |
1137 | /* |
1138 | * Since the RNC is ready, it's alright to finish completion | |
1139 | * processing (e.g. signal the remote device is ready). */ | |
89a7301f | 1140 | sci_stp_remote_device_ready_idle_substate_resume_complete_handler(idev); |
ab2e8f7d | 1141 | } else { |
89a7301f DW |
1142 | sci_remote_node_context_resume(&idev->rnc, |
1143 | sci_stp_remote_device_ready_idle_substate_resume_complete_handler, | |
78a6f06e | 1144 | idev); |
ab2e8f7d DW |
1145 | } |
1146 | } | |
1147 | ||
89a7301f | 1148 | static void sci_stp_remote_device_ready_cmd_substate_enter(struct sci_base_state_machine *sm) |
ab2e8f7d | 1149 | { |
78a6f06e | 1150 | struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm); |
34a99158 | 1151 | struct isci_host *ihost = idev->owning_port->owning_controller; |
ab2e8f7d | 1152 | |
78a6f06e | 1153 | BUG_ON(idev->working_request == NULL); |
ab2e8f7d | 1154 | |
d9dcb4ba | 1155 | isci_remote_device_not_ready(ihost, idev, |
ab2e8f7d DW |
1156 | SCIC_REMOTE_DEVICE_NOT_READY_SATA_REQUEST_STARTED); |
1157 | } | |
1158 | ||
89a7301f | 1159 | static void sci_stp_remote_device_ready_ncq_error_substate_enter(struct sci_base_state_machine *sm) |
ab2e8f7d | 1160 | { |
78a6f06e | 1161 | struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm); |
34a99158 | 1162 | struct isci_host *ihost = idev->owning_port->owning_controller; |
ab2e8f7d | 1163 | |
78a6f06e | 1164 | if (idev->not_ready_reason == SCIC_REMOTE_DEVICE_NOT_READY_SATA_SDB_ERROR_FIS_RECEIVED) |
d9dcb4ba | 1165 | isci_remote_device_not_ready(ihost, idev, |
78a6f06e | 1166 | idev->not_ready_reason); |
ab2e8f7d DW |
1167 | } |
1168 | ||
89a7301f | 1169 | static void sci_smp_remote_device_ready_idle_substate_enter(struct sci_base_state_machine *sm) |
ab2e8f7d | 1170 | { |
78a6f06e | 1171 | struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm); |
34a99158 | 1172 | struct isci_host *ihost = idev->owning_port->owning_controller; |
ab2e8f7d | 1173 | |
d9dcb4ba | 1174 | isci_remote_device_ready(ihost, idev); |
ab2e8f7d DW |
1175 | } |
1176 | ||
89a7301f | 1177 | static void sci_smp_remote_device_ready_cmd_substate_enter(struct sci_base_state_machine *sm) |
ab2e8f7d | 1178 | { |
78a6f06e | 1179 | struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm); |
34a99158 | 1180 | struct isci_host *ihost = idev->owning_port->owning_controller; |
ab2e8f7d | 1181 | |
78a6f06e | 1182 | BUG_ON(idev->working_request == NULL); |
ab2e8f7d | 1183 | |
d9dcb4ba | 1184 | isci_remote_device_not_ready(ihost, idev, |
ab2e8f7d DW |
1185 | SCIC_REMOTE_DEVICE_NOT_READY_SMP_REQUEST_STARTED); |
1186 | } | |
1187 | ||
89a7301f | 1188 | static void sci_smp_remote_device_ready_cmd_substate_exit(struct sci_base_state_machine *sm) |
ab2e8f7d | 1189 | { |
78a6f06e | 1190 | struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm); |
ab2e8f7d | 1191 | |
78a6f06e | 1192 | idev->working_request = NULL; |
ab2e8f7d | 1193 | } |
88f3b62a | 1194 | |
89a7301f | 1195 | static const struct sci_base_state sci_remote_device_state_table[] = { |
e301370a | 1196 | [SCI_DEV_INITIAL] = { |
89a7301f | 1197 | .enter_state = sci_remote_device_initial_state_enter, |
88f3b62a | 1198 | }, |
e301370a | 1199 | [SCI_DEV_STOPPED] = { |
89a7301f | 1200 | .enter_state = sci_remote_device_stopped_state_enter, |
88f3b62a | 1201 | }, |
e301370a | 1202 | [SCI_DEV_STARTING] = { |
89a7301f | 1203 | .enter_state = sci_remote_device_starting_state_enter, |
88f3b62a | 1204 | }, |
e301370a | 1205 | [SCI_DEV_READY] = { |
89a7301f DW |
1206 | .enter_state = sci_remote_device_ready_state_enter, |
1207 | .exit_state = sci_remote_device_ready_state_exit | |
88f3b62a | 1208 | }, |
e301370a | 1209 | [SCI_STP_DEV_IDLE] = { |
89a7301f | 1210 | .enter_state = sci_stp_remote_device_ready_idle_substate_enter, |
ab2e8f7d | 1211 | }, |
e301370a | 1212 | [SCI_STP_DEV_CMD] = { |
89a7301f | 1213 | .enter_state = sci_stp_remote_device_ready_cmd_substate_enter, |
ab2e8f7d | 1214 | }, |
e301370a EN |
1215 | [SCI_STP_DEV_NCQ] = { }, |
1216 | [SCI_STP_DEV_NCQ_ERROR] = { | |
89a7301f | 1217 | .enter_state = sci_stp_remote_device_ready_ncq_error_substate_enter, |
ab2e8f7d | 1218 | }, |
87805162 | 1219 | [SCI_STP_DEV_ATAPI_ERROR] = { }, |
e301370a EN |
1220 | [SCI_STP_DEV_AWAIT_RESET] = { }, |
1221 | [SCI_SMP_DEV_IDLE] = { | |
89a7301f | 1222 | .enter_state = sci_smp_remote_device_ready_idle_substate_enter, |
ab2e8f7d | 1223 | }, |
e301370a | 1224 | [SCI_SMP_DEV_CMD] = { |
89a7301f DW |
1225 | .enter_state = sci_smp_remote_device_ready_cmd_substate_enter, |
1226 | .exit_state = sci_smp_remote_device_ready_cmd_substate_exit, | |
ab2e8f7d | 1227 | }, |
e301370a EN |
1228 | [SCI_DEV_STOPPING] = { }, |
1229 | [SCI_DEV_FAILED] = { }, | |
1230 | [SCI_DEV_RESETTING] = { | |
89a7301f DW |
1231 | .enter_state = sci_remote_device_resetting_state_enter, |
1232 | .exit_state = sci_remote_device_resetting_state_exit | |
88f3b62a | 1233 | }, |
e301370a | 1234 | [SCI_DEV_FINAL] = { }, |
88f3b62a DW |
1235 | }; |
1236 | ||
1237 | /** | |
89a7301f | 1238 | * sci_remote_device_construct() - common construction |
88f3b62a DW |
1239 | * @sci_port: SAS/SATA port through which this device is accessed. |
1240 | * @sci_dev: remote device to construct | |
1241 | * | |
b87ee307 DW |
1242 | * This routine just performs benign initialization and does not |
1243 | * allocate the remote_node_context which is left to | |
89a7301f | 1244 | * sci_remote_device_[de]a_construct(). sci_remote_device_destruct() |
b87ee307 | 1245 | * frees the remote_node_context(s) for the device. |
88f3b62a | 1246 | */ |
89a7301f | 1247 | static void sci_remote_device_construct(struct isci_port *iport, |
78a6f06e | 1248 | struct isci_remote_device *idev) |
88f3b62a | 1249 | { |
78a6f06e DW |
1250 | idev->owning_port = iport; |
1251 | idev->started_request_count = 0; | |
88f3b62a | 1252 | |
89a7301f | 1253 | sci_init_sm(&idev->sm, sci_remote_device_state_table, SCI_DEV_INITIAL); |
88f3b62a | 1254 | |
89a7301f | 1255 | sci_remote_node_context_construct(&idev->rnc, |
88f3b62a | 1256 | SCIC_SDS_REMOTE_NODE_CONTEXT_INVALID_INDEX); |
88f3b62a DW |
1257 | } |
1258 | ||
1259 | /** | |
89a7301f | 1260 | * sci_remote_device_da_construct() - construct direct attached device. |
b87ee307 DW |
1261 | * |
1262 | * The information (e.g. IAF, Signature FIS, etc.) necessary to build | |
1263 | * the device is known to the SCI Core since it is contained in the | |
89a7301f DW |
1264 | * sci_phy object. Remote node context(s) is/are a global resource |
1265 | * allocated by this routine, freed by sci_remote_device_destruct(). | |
b87ee307 DW |
1266 | * |
1267 | * Returns: | |
1268 | * SCI_FAILURE_DEVICE_EXISTS - device has already been constructed. | |
1269 | * SCI_FAILURE_UNSUPPORTED_PROTOCOL - e.g. sas device attached to | |
1270 | * sata-only controller instance. | |
1271 | * SCI_FAILURE_INSUFFICIENT_RESOURCES - remote node contexts exhausted. | |
88f3b62a | 1272 | */ |
89a7301f | 1273 | static enum sci_status sci_remote_device_da_construct(struct isci_port *iport, |
78a6f06e | 1274 | struct isci_remote_device *idev) |
88f3b62a DW |
1275 | { |
1276 | enum sci_status status; | |
7e629841 | 1277 | struct sci_port_properties properties; |
88f3b62a | 1278 | |
89a7301f | 1279 | sci_remote_device_construct(iport, idev); |
b87ee307 | 1280 | |
7e629841 BN |
1281 | sci_port_get_properties(iport, &properties); |
1282 | /* Get accurate port width from port's phy mask for a DA device. */ | |
1283 | idev->device_port_width = hweight32(properties.phy_mask); | |
1284 | ||
89a7301f | 1285 | status = sci_controller_allocate_remote_node_context(iport->owning_controller, |
11cc5183 DW |
1286 | idev, |
1287 | &idev->rnc.remote_node_index); | |
88f3b62a | 1288 | |
a1a113b0 DW |
1289 | if (status != SCI_SUCCESS) |
1290 | return status; | |
88f3b62a | 1291 | |
89a7301f | 1292 | idev->connection_rate = sci_port_get_max_allowed_speed(iport); |
88f3b62a | 1293 | |
a1a113b0 | 1294 | return SCI_SUCCESS; |
88f3b62a DW |
1295 | } |
1296 | ||
88f3b62a | 1297 | /** |
89a7301f | 1298 | * sci_remote_device_ea_construct() - construct expander attached device |
b87ee307 DW |
1299 | * |
1300 | * Remote node context(s) is/are a global resource allocated by this | |
89a7301f | 1301 | * routine, freed by sci_remote_device_destruct(). |
b87ee307 DW |
1302 | * |
1303 | * Returns: | |
1304 | * SCI_FAILURE_DEVICE_EXISTS - device has already been constructed. | |
1305 | * SCI_FAILURE_UNSUPPORTED_PROTOCOL - e.g. sas device attached to | |
1306 | * sata-only controller instance. | |
1307 | * SCI_FAILURE_INSUFFICIENT_RESOURCES - remote node contexts exhausted. | |
88f3b62a | 1308 | */ |
89a7301f | 1309 | static enum sci_status sci_remote_device_ea_construct(struct isci_port *iport, |
78a6f06e | 1310 | struct isci_remote_device *idev) |
88f3b62a | 1311 | { |
78a6f06e | 1312 | struct domain_device *dev = idev->domain_dev; |
88f3b62a | 1313 | enum sci_status status; |
88f3b62a | 1314 | |
89a7301f | 1315 | sci_remote_device_construct(iport, idev); |
88f3b62a | 1316 | |
89a7301f | 1317 | status = sci_controller_allocate_remote_node_context(iport->owning_controller, |
78a6f06e DW |
1318 | idev, |
1319 | &idev->rnc.remote_node_index); | |
a1a113b0 DW |
1320 | if (status != SCI_SUCCESS) |
1321 | return status; | |
88f3b62a | 1322 | |
11cc5183 | 1323 | /* For SAS-2 the physical link rate is actually a logical link |
a1a113b0 DW |
1324 | * rate that incorporates multiplexing. The SCU doesn't |
1325 | * incorporate multiplexing and for the purposes of the | |
1326 | * connection the logical link rate is that same as the | |
1327 | * physical. Furthermore, the SAS-2 and SAS-1.1 fields overlay | |
11cc5183 DW |
1328 | * one another, so this code works for both situations. |
1329 | */ | |
89a7301f | 1330 | idev->connection_rate = min_t(u16, sci_port_get_max_allowed_speed(iport), |
00d680ef | 1331 | dev->linkrate); |
88f3b62a | 1332 | |
a1a113b0 | 1333 | /* / @todo Should I assign the port width by reading all of the phys on the port? */ |
78a6f06e | 1334 | idev->device_port_width = 1; |
88f3b62a | 1335 | |
ab2e8f7d | 1336 | return SCI_SUCCESS; |
88f3b62a DW |
1337 | } |
1338 | ||
5b6bf225 JS |
1339 | enum sci_status sci_remote_device_resume( |
1340 | struct isci_remote_device *idev, | |
1341 | scics_sds_remote_node_context_callback cb_fn, | |
1342 | void *cb_p) | |
1343 | { | |
1344 | enum sci_status status; | |
1345 | ||
1346 | status = sci_remote_node_context_resume(&idev->rnc, cb_fn, cb_p); | |
1347 | if (status != SCI_SUCCESS) | |
1348 | dev_dbg(scirdev_to_dev(idev), "%s: failed to resume: %d\n", | |
1349 | __func__, status); | |
1350 | return status; | |
1351 | } | |
1352 | ||
0cce165e JS |
1353 | static void isci_remote_device_resume_from_abort_complete(void *cbparam) |
1354 | { | |
1355 | struct isci_remote_device *idev = cbparam; | |
1356 | struct isci_host *ihost = idev->owning_port->owning_controller; | |
1357 | scics_sds_remote_node_context_callback abort_resume_cb = | |
1358 | idev->abort_resume_cb; | |
1359 | ||
1360 | dev_dbg(scirdev_to_dev(idev), "%s: passing-along resume: %p\n", | |
1361 | __func__, abort_resume_cb); | |
1362 | ||
1363 | if (abort_resume_cb != NULL) { | |
1364 | idev->abort_resume_cb = NULL; | |
1365 | abort_resume_cb(idev->abort_resume_cbparam); | |
1366 | } | |
1367 | clear_bit(IDEV_ABORT_PATH_RESUME_PENDING, &idev->flags); | |
1368 | wake_up(&ihost->eventq); | |
1369 | } | |
1370 | ||
de2eb4d5 JS |
1371 | static bool isci_remote_device_test_resume_done( |
1372 | struct isci_host *ihost, | |
1373 | struct isci_remote_device *idev) | |
1374 | { | |
1375 | unsigned long flags; | |
1376 | bool done; | |
1377 | ||
1378 | spin_lock_irqsave(&ihost->scic_lock, flags); | |
1379 | done = !test_bit(IDEV_ABORT_PATH_RESUME_PENDING, &idev->flags) | |
1380 | || test_bit(IDEV_STOP_PENDING, &idev->flags) | |
1381 | || sci_remote_node_context_is_being_destroyed(&idev->rnc); | |
1382 | spin_unlock_irqrestore(&ihost->scic_lock, flags); | |
1383 | ||
1384 | return done; | |
1385 | } | |
0cce165e JS |
1386 | |
1387 | void isci_remote_device_wait_for_resume_from_abort( | |
1388 | struct isci_host *ihost, | |
1389 | struct isci_remote_device *idev) | |
1390 | { | |
de2eb4d5 | 1391 | dev_dbg(&ihost->pdev->dev, "%s: starting resume wait: %p\n", |
0cce165e JS |
1392 | __func__, idev); |
1393 | ||
8c731888 | 1394 | #define MAX_RESUME_MSECS 10000 |
0cce165e | 1395 | if (!wait_event_timeout(ihost->eventq, |
de2eb4d5 JS |
1396 | isci_remote_device_test_resume_done(ihost, idev), |
1397 | msecs_to_jiffies(MAX_RESUME_MSECS))) { | |
0cce165e | 1398 | |
de2eb4d5 | 1399 | dev_warn(&ihost->pdev->dev, "%s: #### Timeout waiting for " |
0cce165e JS |
1400 | "resume: %p\n", __func__, idev); |
1401 | } | |
1402 | clear_bit(IDEV_ABORT_PATH_RESUME_PENDING, &idev->flags); | |
1403 | ||
de2eb4d5 | 1404 | dev_dbg(&ihost->pdev->dev, "%s: resume wait done: %p\n", |
0cce165e JS |
1405 | __func__, idev); |
1406 | } | |
1407 | ||
31a38ef0 | 1408 | enum sci_status isci_remote_device_resume_from_abort( |
5b6bf225 | 1409 | struct isci_host *ihost, |
31a38ef0 | 1410 | struct isci_remote_device *idev) |
5b6bf225 JS |
1411 | { |
1412 | unsigned long flags; | |
1f053889 JS |
1413 | enum sci_status status = SCI_SUCCESS; |
1414 | int destroyed; | |
5b6bf225 JS |
1415 | |
1416 | spin_lock_irqsave(&ihost->scic_lock, flags); | |
31a38ef0 JS |
1417 | /* Preserve any current resume callbacks, for instance from other |
1418 | * resumptions. | |
1419 | */ | |
0cce165e JS |
1420 | idev->abort_resume_cb = idev->rnc.user_callback; |
1421 | idev->abort_resume_cbparam = idev->rnc.user_cookie; | |
1422 | set_bit(IDEV_ABORT_PATH_RESUME_PENDING, &idev->flags); | |
0c3ce38f | 1423 | clear_bit(IDEV_ABORT_PATH_ACTIVE, &idev->flags); |
1f053889 JS |
1424 | destroyed = sci_remote_node_context_is_being_destroyed(&idev->rnc); |
1425 | if (!destroyed) | |
1426 | status = sci_remote_device_resume( | |
0cce165e JS |
1427 | idev, isci_remote_device_resume_from_abort_complete, |
1428 | idev); | |
5b6bf225 | 1429 | spin_unlock_irqrestore(&ihost->scic_lock, flags); |
de2eb4d5 | 1430 | if (!destroyed && (status == SCI_SUCCESS)) |
1f053889 JS |
1431 | isci_remote_device_wait_for_resume_from_abort(ihost, idev); |
1432 | else | |
1433 | clear_bit(IDEV_ABORT_PATH_RESUME_PENDING, &idev->flags); | |
1434 | ||
5b6bf225 JS |
1435 | return status; |
1436 | } | |
0cce165e | 1437 | |
88f3b62a | 1438 | /** |
89a7301f | 1439 | * sci_remote_device_start() - This method will start the supplied remote |
88f3b62a DW |
1440 | * device. This method enables normal IO requests to flow through to the |
1441 | * remote device. | |
1442 | * @remote_device: This parameter specifies the device to be started. | |
1443 | * @timeout: This parameter specifies the number of milliseconds in which the | |
1444 | * start operation should complete. | |
1445 | * | |
1446 | * An indication of whether the device was successfully started. SCI_SUCCESS | |
1447 | * This value is returned if the device was successfully started. | |
1448 | * SCI_FAILURE_INVALID_PHY This value is returned if the user attempts to start | |
1449 | * the device when there have been no phys added to it. | |
1450 | */ | |
89a7301f | 1451 | static enum sci_status sci_remote_device_start(struct isci_remote_device *idev, |
726980d5 | 1452 | u32 timeout) |
88f3b62a | 1453 | { |
78a6f06e | 1454 | struct sci_base_state_machine *sm = &idev->sm; |
89a7301f | 1455 | enum sci_remote_device_states state = sm->current_state_id; |
eb229671 DW |
1456 | enum sci_status status; |
1457 | ||
e301370a | 1458 | if (state != SCI_DEV_STOPPED) { |
d7a0ccdd DW |
1459 | dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %s\n", |
1460 | __func__, dev_state_name(state)); | |
eb229671 DW |
1461 | return SCI_FAILURE_INVALID_STATE; |
1462 | } | |
1463 | ||
5b6bf225 JS |
1464 | status = sci_remote_device_resume(idev, remote_device_resume_done, |
1465 | idev); | |
eb229671 DW |
1466 | if (status != SCI_SUCCESS) |
1467 | return status; | |
1468 | ||
e301370a | 1469 | sci_change_state(sm, SCI_DEV_STARTING); |
eb229671 DW |
1470 | |
1471 | return SCI_SUCCESS; | |
88f3b62a | 1472 | } |
6f231dda | 1473 | |
00d680ef DW |
1474 | static enum sci_status isci_remote_device_construct(struct isci_port *iport, |
1475 | struct isci_remote_device *idev) | |
6f231dda | 1476 | { |
00d680ef DW |
1477 | struct isci_host *ihost = iport->isci_host; |
1478 | struct domain_device *dev = idev->domain_dev; | |
1479 | enum sci_status status; | |
6f231dda | 1480 | |
00d680ef | 1481 | if (dev->parent && dev_is_expander(dev->parent)) |
89a7301f | 1482 | status = sci_remote_device_ea_construct(iport, idev); |
00d680ef | 1483 | else |
89a7301f | 1484 | status = sci_remote_device_da_construct(iport, idev); |
6f231dda DW |
1485 | |
1486 | if (status != SCI_SUCCESS) { | |
00d680ef DW |
1487 | dev_dbg(&ihost->pdev->dev, "%s: construct failed: %d\n", |
1488 | __func__, status); | |
6f231dda DW |
1489 | |
1490 | return status; | |
1491 | } | |
1492 | ||
6f231dda | 1493 | /* start the device. */ |
89a7301f | 1494 | status = sci_remote_device_start(idev, ISCI_REMOTE_DEVICE_START_TIMEOUT); |
6f231dda | 1495 | |
00d680ef DW |
1496 | if (status != SCI_SUCCESS) |
1497 | dev_warn(&ihost->pdev->dev, "remote device start failed: %d\n", | |
1498 | status); | |
6f231dda DW |
1499 | |
1500 | return status; | |
1501 | } | |
1502 | ||
6f231dda DW |
1503 | /** |
1504 | * This function builds the isci_remote_device when a libsas dev_found message | |
1505 | * is received. | |
1506 | * @isci_host: This parameter specifies the isci host object. | |
1507 | * @port: This parameter specifies the isci_port conected to this device. | |
1508 | * | |
1509 | * pointer to new isci_remote_device. | |
1510 | */ | |
1511 | static struct isci_remote_device * | |
d9c37390 | 1512 | isci_remote_device_alloc(struct isci_host *ihost, struct isci_port *iport) |
6f231dda | 1513 | { |
d9c37390 DW |
1514 | struct isci_remote_device *idev; |
1515 | int i; | |
6f231dda | 1516 | |
d9c37390 | 1517 | for (i = 0; i < SCI_MAX_REMOTE_DEVICES; i++) { |
57f20f4e | 1518 | idev = &ihost->devices[i]; |
d9c37390 DW |
1519 | if (!test_and_set_bit(IDEV_ALLOCATED, &idev->flags)) |
1520 | break; | |
1521 | } | |
6f231dda | 1522 | |
d9c37390 DW |
1523 | if (i >= SCI_MAX_REMOTE_DEVICES) { |
1524 | dev_warn(&ihost->pdev->dev, "%s: failed\n", __func__); | |
6f231dda DW |
1525 | return NULL; |
1526 | } | |
6cb4d6b3 BB |
1527 | if (WARN_ONCE(!list_empty(&idev->node), "found non-idle remote device\n")) |
1528 | return NULL; | |
1529 | ||
d9c37390 | 1530 | return idev; |
6f231dda | 1531 | } |
6f231dda | 1532 | |
209fae14 DW |
1533 | void isci_remote_device_release(struct kref *kref) |
1534 | { | |
1535 | struct isci_remote_device *idev = container_of(kref, typeof(*idev), kref); | |
1536 | struct isci_host *ihost = idev->isci_port->isci_host; | |
1537 | ||
1538 | idev->domain_dev = NULL; | |
1539 | idev->isci_port = NULL; | |
1540 | clear_bit(IDEV_START_PENDING, &idev->flags); | |
1541 | clear_bit(IDEV_STOP_PENDING, &idev->flags); | |
f2088267 | 1542 | clear_bit(IDEV_IO_READY, &idev->flags); |
209fae14 | 1543 | clear_bit(IDEV_GONE, &idev->flags); |
4e857c58 | 1544 | smp_mb__before_atomic(); |
209fae14 DW |
1545 | clear_bit(IDEV_ALLOCATED, &idev->flags); |
1546 | wake_up(&ihost->eventq); | |
1547 | } | |
1548 | ||
6f231dda DW |
1549 | /** |
1550 | * isci_remote_device_stop() - This function is called internally to stop the | |
1551 | * remote device. | |
1552 | * @isci_host: This parameter specifies the isci host object. | |
1553 | * @isci_device: This parameter specifies the remote device. | |
1554 | * | |
d9dcb4ba | 1555 | * The status of the ihost request to stop. |
6f231dda | 1556 | */ |
6ad31fec | 1557 | enum sci_status isci_remote_device_stop(struct isci_host *ihost, struct isci_remote_device *idev) |
6f231dda DW |
1558 | { |
1559 | enum sci_status status; | |
1560 | unsigned long flags; | |
6f231dda | 1561 | |
6ad31fec DW |
1562 | dev_dbg(&ihost->pdev->dev, |
1563 | "%s: isci_device = %p\n", __func__, idev); | |
6f231dda | 1564 | |
209fae14 DW |
1565 | spin_lock_irqsave(&ihost->scic_lock, flags); |
1566 | idev->domain_dev->lldd_dev = NULL; /* disable new lookups */ | |
1567 | set_bit(IDEV_GONE, &idev->flags); | |
6e2802a7 | 1568 | |
6ad31fec | 1569 | set_bit(IDEV_STOP_PENDING, &idev->flags); |
89a7301f | 1570 | status = sci_remote_device_stop(idev, 50); |
6ad31fec | 1571 | spin_unlock_irqrestore(&ihost->scic_lock, flags); |
6f231dda DW |
1572 | |
1573 | /* Wait for the stop complete callback. */ | |
209fae14 DW |
1574 | if (WARN_ONCE(status != SCI_SUCCESS, "failed to stop device\n")) |
1575 | /* nothing to wait for */; | |
1576 | else | |
6ad31fec | 1577 | wait_for_device_stop(ihost, idev); |
6f231dda | 1578 | |
83884014 JS |
1579 | dev_dbg(&ihost->pdev->dev, |
1580 | "%s: isci_device = %p, waiting done.\n", __func__, idev); | |
1581 | ||
6f231dda DW |
1582 | return status; |
1583 | } | |
1584 | ||
1585 | /** | |
1586 | * isci_remote_device_gone() - This function is called by libsas when a domain | |
1587 | * device is removed. | |
1588 | * @domain_device: This parameter specifies the libsas domain device. | |
1589 | * | |
1590 | */ | |
6ad31fec | 1591 | void isci_remote_device_gone(struct domain_device *dev) |
6f231dda | 1592 | { |
4393aa4e | 1593 | struct isci_host *ihost = dev_to_ihost(dev); |
6ad31fec | 1594 | struct isci_remote_device *idev = dev->lldd_dev; |
6f231dda | 1595 | |
6ad31fec | 1596 | dev_dbg(&ihost->pdev->dev, |
6f231dda | 1597 | "%s: domain_device = %p, isci_device = %p, isci_port = %p\n", |
6ad31fec | 1598 | __func__, dev, idev, idev->isci_port); |
6f231dda | 1599 | |
6ad31fec | 1600 | isci_remote_device_stop(ihost, idev); |
6f231dda DW |
1601 | } |
1602 | ||
1603 | ||
1604 | /** | |
1605 | * isci_remote_device_found() - This function is called by libsas when a remote | |
1606 | * device is discovered. A remote device object is created and started. the | |
1607 | * function then sleeps until the sci core device started message is | |
1608 | * received. | |
1609 | * @domain_device: This parameter specifies the libsas domain device. | |
1610 | * | |
1611 | * status, zero indicates success. | |
1612 | */ | |
c132f692 | 1613 | int isci_remote_device_found(struct domain_device *dev) |
6f231dda | 1614 | { |
c132f692 DW |
1615 | struct isci_host *isci_host = dev_to_ihost(dev); |
1616 | struct isci_port *isci_port = dev->port->lldd_port; | |
6f231dda DW |
1617 | struct isci_remote_device *isci_device; |
1618 | enum sci_status status; | |
6f231dda | 1619 | |
6f231dda | 1620 | dev_dbg(&isci_host->pdev->dev, |
c132f692 | 1621 | "%s: domain_device = %p\n", __func__, dev); |
6f231dda | 1622 | |
c132f692 DW |
1623 | if (!isci_port) |
1624 | return -ENODEV; | |
6f231dda | 1625 | |
6f231dda | 1626 | isci_device = isci_remote_device_alloc(isci_host, isci_port); |
d9c37390 DW |
1627 | if (!isci_device) |
1628 | return -ENODEV; | |
6f231dda | 1629 | |
209fae14 | 1630 | kref_init(&isci_device->kref); |
6f231dda | 1631 | INIT_LIST_HEAD(&isci_device->node); |
209fae14 DW |
1632 | |
1633 | spin_lock_irq(&isci_host->scic_lock); | |
c132f692 | 1634 | isci_device->domain_dev = dev; |
6f231dda | 1635 | isci_device->isci_port = isci_port; |
6f231dda DW |
1636 | list_add_tail(&isci_device->node, &isci_port->remote_dev_list); |
1637 | ||
6ad31fec | 1638 | set_bit(IDEV_START_PENDING, &isci_device->flags); |
6f231dda | 1639 | status = isci_remote_device_construct(isci_port, isci_device); |
6f231dda | 1640 | |
6f231dda DW |
1641 | dev_dbg(&isci_host->pdev->dev, |
1642 | "%s: isci_device = %p\n", | |
1643 | __func__, isci_device); | |
1644 | ||
209fae14 DW |
1645 | if (status == SCI_SUCCESS) { |
1646 | /* device came up, advertise it to the world */ | |
c132f692 | 1647 | dev->lldd_dev = isci_device; |
209fae14 DW |
1648 | } else |
1649 | isci_put_device(isci_device); | |
1650 | spin_unlock_irq(&isci_host->scic_lock); | |
6f231dda | 1651 | |
6ad31fec DW |
1652 | /* wait for the device ready callback. */ |
1653 | wait_for_device_start(isci_host, isci_device); | |
1654 | ||
209fae14 | 1655 | return status == SCI_SUCCESS ? 0 : -ENODEV; |
6f231dda | 1656 | } |
726980d5 | 1657 | |
14aaa9f0 | 1658 | enum sci_status isci_remote_device_suspend_terminate( |
5b6bf225 | 1659 | struct isci_host *ihost, |
14aaa9f0 JS |
1660 | struct isci_remote_device *idev, |
1661 | struct isci_request *ireq) | |
726980d5 | 1662 | { |
726980d5 JS |
1663 | unsigned long flags; |
1664 | enum sci_status status; | |
1665 | ||
14aaa9f0 | 1666 | /* Put the device into suspension. */ |
5b6bf225 | 1667 | spin_lock_irqsave(&ihost->scic_lock, flags); |
0c3ce38f | 1668 | set_bit(IDEV_ABORT_PATH_ACTIVE, &idev->flags); |
c94fc1ad | 1669 | sci_remote_device_suspend(idev, SCI_SW_SUSPEND_LINKHANG_DETECT); |
5b6bf225 | 1670 | spin_unlock_irqrestore(&ihost->scic_lock, flags); |
14aaa9f0 JS |
1671 | |
1672 | /* Terminate and wait for the completions. */ | |
1673 | status = isci_remote_device_terminate_requests(ihost, idev, ireq); | |
1674 | if (status != SCI_SUCCESS) | |
726980d5 | 1675 | dev_dbg(&ihost->pdev->dev, |
14aaa9f0 JS |
1676 | "%s: isci_remote_device_terminate_requests(%p) " |
1677 | "returned %d!\n", | |
726980d5 | 1678 | __func__, idev, status); |
14aaa9f0 JS |
1679 | |
1680 | /* NOTE: RNC resumption is left to the caller! */ | |
726980d5 JS |
1681 | return status; |
1682 | } | |
1683 | ||
1684 | int isci_remote_device_is_safe_to_abort( | |
1685 | struct isci_remote_device *idev) | |
1686 | { | |
1687 | return sci_remote_node_context_is_safe_to_abort(&idev->rnc); | |
1688 | } | |
1689 | ||
1690 | enum sci_status sci_remote_device_abort_requests_pending_abort( | |
1691 | struct isci_remote_device *idev) | |
1692 | { | |
14aaa9f0 | 1693 | return sci_remote_device_terminate_reqs_checkabort(idev, 1); |
726980d5 | 1694 | } |
5b6bf225 JS |
1695 | |
1696 | enum sci_status isci_remote_device_reset_complete( | |
1697 | struct isci_host *ihost, | |
1698 | struct isci_remote_device *idev) | |
1699 | { | |
1700 | unsigned long flags; | |
1701 | enum sci_status status; | |
1702 | ||
1703 | spin_lock_irqsave(&ihost->scic_lock, flags); | |
1704 | status = sci_remote_device_reset_complete(idev); | |
5b6bf225 JS |
1705 | spin_unlock_irqrestore(&ihost->scic_lock, flags); |
1706 | ||
1707 | return status; | |
1708 | } | |
1709 | ||
9608b640 JS |
1710 | void isci_dev_set_hang_detection_timeout( |
1711 | struct isci_remote_device *idev, | |
1712 | u32 timeout) | |
1713 | { | |
1714 | if (dev_is_sata(idev->domain_dev)) { | |
1715 | if (timeout) { | |
1716 | if (test_and_set_bit(IDEV_RNC_LLHANG_ENABLED, | |
1717 | &idev->flags)) | |
1718 | return; /* Already enabled. */ | |
1719 | } else if (!test_and_clear_bit(IDEV_RNC_LLHANG_ENABLED, | |
1720 | &idev->flags)) | |
1721 | return; /* Not enabled. */ | |
1722 | ||
1723 | sci_port_set_hang_detection_timeout(idev->owning_port, | |
1724 | timeout); | |
1725 | } | |
1726 | } |