?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
isci: kill remote_device complete_task_handler
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / scsi / isci / remote_device.c
blob3344f38355cd9498cfec42e4b3bcde3c89a3d80b
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 #include "intel_sas.h"
56 #include "intel_ata.h"
57 #include "isci.h"
58 #include "port.h"
59 #include "remote_device.h"
60 #include "request.h"
61 #include "scic_controller.h"
62 #include "scic_io_request.h"
63 #include "scic_phy.h"
64 #include "scic_port.h"
65 #include "scic_sds_controller.h"
66 #include "scic_sds_phy.h"
67 #include "scic_sds_port.h"
68 #include "remote_node_context.h"
69 #include "scic_sds_request.h"
70 #include "sci_environment.h"
71 #include "sci_util.h"
72 #include "scu_event_codes.h"
73 #include "task.h"
74
75 /**
76 * isci_remote_device_change_state() - This function gets the status of the
77 * remote_device object.
78 * @isci_device: This parameter points to the isci_remote_device object
79 *
80 * status of the object as a isci_status enum.
81 */
82 void isci_remote_device_change_state(
83 struct isci_remote_device *isci_device,
84 enum isci_status status)
85 {
86 unsigned long flags;
87
88 spin_lock_irqsave(&isci_device->state_lock, flags);
89 isci_device->status = status;
90 spin_unlock_irqrestore(&isci_device->state_lock, flags);
91 }
92
93 /**
94 * isci_remote_device_not_ready() - This function is called by the scic when
95 * the remote device is not ready. We mark the isci device as ready (not
96 * "ready_for_io") and signal the waiting proccess.
97 * @isci_host: This parameter specifies the isci host object.
98 * @isci_device: This parameter specifies the remote device
99 *
100 */
101 static void isci_remote_device_not_ready(struct isci_host *ihost,
102 struct isci_remote_device *idev, u32 reason)
103 {
104 dev_dbg(&ihost->pdev->dev,
105 "%s: isci_device = %p\n", __func__, idev);
106
107 if (reason == SCIC_REMOTE_DEVICE_NOT_READY_STOP_REQUESTED)
108 isci_remote_device_change_state(idev, isci_stopping);
109 else
110 /* device ready is actually a "not ready for io" state. */
111 isci_remote_device_change_state(idev, isci_ready);
112 }
113
114 /**
115 * isci_remote_device_ready() - This function is called by the scic when the
116 * remote device is ready. We mark the isci device as ready and signal the
117 * waiting proccess.
118 * @ihost: our valid isci_host
119 * @idev: remote device
120 *
121 */
122 static void isci_remote_device_ready(struct isci_host *ihost, struct isci_remote_device *idev)
123 {
124 dev_dbg(&ihost->pdev->dev,
125 "%s: idev = %p\n", __func__, idev);
126
127 isci_remote_device_change_state(idev, isci_ready_for_io);
128 if (test_and_clear_bit(IDEV_START_PENDING, &idev->flags))
129 wake_up(&ihost->eventq);
130 }
131
132 /* called once the remote node context is ready to be freed.
133 * The remote device can now report that its stop operation is complete. none
134 */
135 static void rnc_destruct_done(void *_dev)
136 {
137 struct scic_sds_remote_device *sci_dev = _dev;
138
139 BUG_ON(sci_dev->started_request_count != 0);
140 sci_base_state_machine_change_state(&sci_dev->state_machine,
141 SCI_BASE_REMOTE_DEVICE_STATE_STOPPED);
142 }
143
144 static enum sci_status scic_sds_remote_device_terminate_requests(struct scic_sds_remote_device *sci_dev)
145 {
146 struct scic_sds_controller *scic = sci_dev->owning_port->owning_controller;
147 u32 i, request_count = sci_dev->started_request_count;
148 enum sci_status status = SCI_SUCCESS;
149
150 for (i = 0; i < SCI_MAX_IO_REQUESTS && i < request_count; i++) {
151 struct scic_sds_request *sci_req;
152 enum sci_status s;
153
154 sci_req = scic->io_request_table[i];
155 if (!sci_req || sci_req->target_device != sci_dev)
156 continue;
157 s = scic_controller_terminate_request(scic, sci_dev, sci_req);
158 if (s != SCI_SUCCESS)
159 status = s;
160 }
161
162 return status;
163 }
164
165 enum sci_status scic_remote_device_stop(struct scic_sds_remote_device *sci_dev,
166 u32 timeout)
167 {
168 struct sci_base_state_machine *sm = &sci_dev->state_machine;
169 enum scic_sds_remote_device_states state = sm->current_state_id;
170
171 switch (state) {
172 case SCI_BASE_REMOTE_DEVICE_STATE_INITIAL:
173 case SCI_BASE_REMOTE_DEVICE_STATE_FAILED:
174 case SCI_BASE_REMOTE_DEVICE_STATE_FINAL:
175 default:
176 dev_warn(scirdev_to_dev(sci_dev), "%s: in wrong state: %d\n",
177 __func__, state);
178 return SCI_FAILURE_INVALID_STATE;
179 case SCI_BASE_REMOTE_DEVICE_STATE_STOPPED:
180 return SCI_SUCCESS;
181 case SCI_BASE_REMOTE_DEVICE_STATE_STARTING:
182 /* device not started so there had better be no requests */
183 BUG_ON(sci_dev->started_request_count != 0);
184 scic_sds_remote_node_context_destruct(&sci_dev->rnc,
185 rnc_destruct_done, sci_dev);
186 /* Transition to the stopping state and wait for the
187 * remote node to complete being posted and invalidated.
188 */
189 sci_base_state_machine_change_state(sm, SCI_BASE_REMOTE_DEVICE_STATE_STOPPING);
190 return SCI_SUCCESS;
191 case SCI_BASE_REMOTE_DEVICE_STATE_READY:
192 case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_IDLE:
193 case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_CMD:
194 case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ:
195 case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ_ERROR:
196 case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_AWAIT_RESET:
197 case SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_IDLE:
198 case SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_CMD:
199 sci_base_state_machine_change_state(sm, SCI_BASE_REMOTE_DEVICE_STATE_STOPPING);
200 if (sci_dev->started_request_count == 0) {
201 scic_sds_remote_node_context_destruct(&sci_dev->rnc,
202 rnc_destruct_done, sci_dev);
203 return SCI_SUCCESS;
204 } else
205 return scic_sds_remote_device_terminate_requests(sci_dev);
206 break;
207 case SCI_BASE_REMOTE_DEVICE_STATE_STOPPING:
208 /* All requests should have been terminated, but if there is an
209 * attempt to stop a device already in the stopping state, then
210 * try again to terminate.
211 */
212 return scic_sds_remote_device_terminate_requests(sci_dev);
213 case SCI_BASE_REMOTE_DEVICE_STATE_RESETTING:
214 sci_base_state_machine_change_state(sm, SCI_BASE_REMOTE_DEVICE_STATE_STOPPING);
215 return SCI_SUCCESS;
216 }
217 }
218
219 enum sci_status scic_remote_device_reset(struct scic_sds_remote_device *sci_dev)
220 {
221 struct sci_base_state_machine *sm = &sci_dev->state_machine;
222 enum scic_sds_remote_device_states state = sm->current_state_id;
223
224 switch (state) {
225 case SCI_BASE_REMOTE_DEVICE_STATE_INITIAL:
226 case SCI_BASE_REMOTE_DEVICE_STATE_STOPPED:
227 case SCI_BASE_REMOTE_DEVICE_STATE_STARTING:
228 case SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_IDLE:
229 case SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_CMD:
230 case SCI_BASE_REMOTE_DEVICE_STATE_STOPPING:
231 case SCI_BASE_REMOTE_DEVICE_STATE_FAILED:
232 case SCI_BASE_REMOTE_DEVICE_STATE_RESETTING:
233 case SCI_BASE_REMOTE_DEVICE_STATE_FINAL:
234 default:
235 dev_warn(scirdev_to_dev(sci_dev), "%s: in wrong state: %d\n",
236 __func__, state);
237 return SCI_FAILURE_INVALID_STATE;
238 case SCI_BASE_REMOTE_DEVICE_STATE_READY:
239 case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_IDLE:
240 case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_CMD:
241 case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ:
242 case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ_ERROR:
243 case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_AWAIT_RESET:
244 sci_base_state_machine_change_state(sm, SCI_BASE_REMOTE_DEVICE_STATE_RESETTING);
245 return SCI_SUCCESS;
246 }
247 }
248
249 enum sci_status scic_remote_device_reset_complete(struct scic_sds_remote_device *sci_dev)
250 {
251 struct sci_base_state_machine *sm = &sci_dev->state_machine;
252 enum scic_sds_remote_device_states state = sm->current_state_id;
253
254 if (state != SCI_BASE_REMOTE_DEVICE_STATE_RESETTING) {
255 dev_warn(scirdev_to_dev(sci_dev), "%s: in wrong state: %d\n",
256 __func__, state);
257 return SCI_FAILURE_INVALID_STATE;
258 }
259
260 sci_base_state_machine_change_state(sm, SCI_BASE_REMOTE_DEVICE_STATE_READY);
261 return SCI_SUCCESS;
262 }
263
264 /**
265 *
266 * @sci_dev: The remote device for which the suspend is being requested.
267 *
268 * This method invokes the remote device suspend state handler. enum sci_status
269 */
270 enum sci_status scic_sds_remote_device_suspend(
271 struct scic_sds_remote_device *sci_dev,
272 u32 suspend_type)
273 {
274 return sci_dev->state_handlers->suspend_handler(sci_dev, suspend_type);
275 }
276
277 /**
278 *
279 * @sci_dev: The remote device for which the event handling is being
280 * requested.
281 * @frame_index: This is the frame index that is being processed.
282 *
283 * This method invokes the frame handler for the remote device state machine
284 * enum sci_status
285 */
286 enum sci_status scic_sds_remote_device_frame_handler(
287 struct scic_sds_remote_device *sci_dev,
288 u32 frame_index)
289 {
290 return sci_dev->state_handlers->frame_handler(sci_dev, frame_index);
291 }
292
293 /**
294 *
295 * @sci_dev: The remote device for which the event handling is being
296 * requested.
297 * @event_code: This is the event code that is to be processed.
298 *
299 * This method invokes the remote device event handler. enum sci_status
300 */
301 enum sci_status scic_sds_remote_device_event_handler(
302 struct scic_sds_remote_device *sci_dev,
303 u32 event_code)
304 {
305 return sci_dev->state_handlers->event_handler(sci_dev, event_code);
306 }
307
308 static void scic_sds_remote_device_start_request(struct scic_sds_remote_device *sci_dev,
309 struct scic_sds_request *sci_req,
310 enum sci_status status)
311 {
312 struct scic_sds_port *sci_port = sci_dev->owning_port;
313
314 /* cleanup requests that failed after starting on the port */
315 if (status != SCI_SUCCESS)
316 scic_sds_port_complete_io(sci_port, sci_dev, sci_req);
317 else
318 scic_sds_remote_device_increment_request_count(sci_dev);
319 }
320
321 enum sci_status scic_sds_remote_device_start_io(struct scic_sds_controller *scic,
322 struct scic_sds_remote_device *sci_dev,
323 struct scic_sds_request *sci_req)
324 {
325 struct sci_base_state_machine *sm = &sci_dev->state_machine;
326 enum scic_sds_remote_device_states state = sm->current_state_id;
327 struct scic_sds_port *sci_port = sci_dev->owning_port;
328 enum sci_status status;
329
330 switch (state) {
331 case SCI_BASE_REMOTE_DEVICE_STATE_INITIAL:
332 case SCI_BASE_REMOTE_DEVICE_STATE_STOPPED:
333 case SCI_BASE_REMOTE_DEVICE_STATE_STARTING:
334 case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ_ERROR:
335 case SCI_BASE_REMOTE_DEVICE_STATE_STOPPING:
336 case SCI_BASE_REMOTE_DEVICE_STATE_FAILED:
337 case SCI_BASE_REMOTE_DEVICE_STATE_RESETTING:
338 case SCI_BASE_REMOTE_DEVICE_STATE_FINAL:
339 default:
340 dev_warn(scirdev_to_dev(sci_dev), "%s: in wrong state: %d\n",
341 __func__, state);
342 return SCI_FAILURE_INVALID_STATE;
343 case SCI_BASE_REMOTE_DEVICE_STATE_READY:
344 /* attempt to start an io request for this device object. The remote
345 * device object will issue the start request for the io and if
346 * successful it will start the request for the port object then
347 * increment its own request count.
348 */
349 status = scic_sds_port_start_io(sci_port, sci_dev, sci_req);
350 if (status != SCI_SUCCESS)
351 return status;
352
353 status = scic_sds_remote_node_context_start_io(&sci_dev->rnc, sci_req);
354 if (status != SCI_SUCCESS)
355 break;
356
357 status = scic_sds_request_start(sci_req);
358 break;
359 case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_IDLE: {
360 /* handle the start io operation for a sata device that is in
361 * the command idle state. - Evalute the type of IO request to
362 * be started - If its an NCQ request change to NCQ substate -
363 * If its any other command change to the CMD substate
364 *
365 * If this is a softreset we may want to have a different
366 * substate.
367 */
368 enum scic_sds_remote_device_states new_state;
369
370 status = scic_sds_port_start_io(sci_port, sci_dev, sci_req);
371 if (status != SCI_SUCCESS)
372 return status;
373
374 status = scic_sds_remote_node_context_start_io(&sci_dev->rnc, sci_req);
375 if (status != SCI_SUCCESS)
376 break;
377
378 status = sci_req->state_handlers->start_handler(sci_req);
379 if (status != SCI_SUCCESS)
380 break;
381
382 if (isci_sata_get_sat_protocol(sci_req->ireq) == SAT_PROTOCOL_FPDMA)
383 new_state = SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ;
384 else {
385 sci_dev->working_request = sci_req;
386 new_state = SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_CMD;
387 }
388 sci_base_state_machine_change_state(sm, new_state);
389 break;
390 }
391 case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ:
392 if (isci_sata_get_sat_protocol(sci_req->ireq) == SAT_PROTOCOL_FPDMA) {
393 status = scic_sds_port_start_io(sci_port, sci_dev, sci_req);
394 if (status != SCI_SUCCESS)
395 return status;
396
397 status = scic_sds_remote_node_context_start_io(&sci_dev->rnc, sci_req);
398 if (status != SCI_SUCCESS)
399 break;
400
401 status = sci_req->state_handlers->start_handler(sci_req);
402 } else
403 return SCI_FAILURE_INVALID_STATE;
404 break;
405 case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_AWAIT_RESET:
406 return SCI_FAILURE_REMOTE_DEVICE_RESET_REQUIRED;
407 case SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_IDLE:
408 status = scic_sds_port_start_io(sci_port, sci_dev, sci_req);
409 if (status != SCI_SUCCESS)
410 return status;
411
412 status = scic_sds_remote_node_context_start_io(&sci_dev->rnc, sci_req);
413 if (status != SCI_SUCCESS)
414 break;
415
416 status = scic_sds_request_start(sci_req);
417 if (status != SCI_SUCCESS)
418 break;
419
420 sci_dev->working_request = sci_req;
421 sci_base_state_machine_change_state(&sci_dev->state_machine,
422 SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_CMD);
423 break;
424 case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_CMD:
425 case SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_CMD:
426 /* device is already handling a command it can not accept new commands
427 * until this one is complete.
428 */
429 return SCI_FAILURE_INVALID_STATE;
430 }
431
432 scic_sds_remote_device_start_request(sci_dev, sci_req, status);
433 return status;
434 }
435
436 static enum sci_status common_complete_io(struct scic_sds_port *sci_port,
437 struct scic_sds_remote_device *sci_dev,
438 struct scic_sds_request *sci_req)
439 {
440 enum sci_status status;
441
442 status = scic_sds_request_complete(sci_req);
443 if (status != SCI_SUCCESS)
444 return status;
445
446 status = scic_sds_port_complete_io(sci_port, sci_dev, sci_req);
447 if (status != SCI_SUCCESS)
448 return status;
449
450 scic_sds_remote_device_decrement_request_count(sci_dev);
451 return status;
452 }
453
454 enum sci_status scic_sds_remote_device_complete_io(struct scic_sds_controller *scic,
455 struct scic_sds_remote_device *sci_dev,
456 struct scic_sds_request *sci_req)
457 {
458 struct sci_base_state_machine *sm = &sci_dev->state_machine;
459 enum scic_sds_remote_device_states state = sm->current_state_id;
460 struct scic_sds_port *sci_port = sci_dev->owning_port;
461 enum sci_status status;
462
463 switch (state) {
464 case SCI_BASE_REMOTE_DEVICE_STATE_INITIAL:
465 case SCI_BASE_REMOTE_DEVICE_STATE_STOPPED:
466 case SCI_BASE_REMOTE_DEVICE_STATE_STARTING:
467 case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_IDLE:
468 case SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_IDLE:
469 case SCI_BASE_REMOTE_DEVICE_STATE_FAILED:
470 case SCI_BASE_REMOTE_DEVICE_STATE_FINAL:
471 default:
472 dev_warn(scirdev_to_dev(sci_dev), "%s: in wrong state: %d\n",
473 __func__, state);
474 return SCI_FAILURE_INVALID_STATE;
475 case SCI_BASE_REMOTE_DEVICE_STATE_READY:
476 case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_AWAIT_RESET:
477 case SCI_BASE_REMOTE_DEVICE_STATE_RESETTING:
478 status = common_complete_io(sci_port, sci_dev, sci_req);
479 break;
480 case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_CMD:
481 case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ:
482 case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ_ERROR:
483 status = common_complete_io(sci_port, sci_dev, sci_req);
484 if (status != SCI_SUCCESS)
485 break;
486
487 if (sci_req->sci_status == SCI_FAILURE_REMOTE_DEVICE_RESET_REQUIRED) {
488 /* This request causes hardware error, device needs to be Lun Reset.
489 * So here we force the state machine to IDLE state so the rest IOs
490 * can reach RNC state handler, these IOs will be completed by RNC with
491 * status of "DEVICE_RESET_REQUIRED", instead of "INVALID STATE".
492 */
493 sci_base_state_machine_change_state(sm, SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_AWAIT_RESET);
494 } else if (scic_sds_remote_device_get_request_count(sci_dev) == 0)
495 sci_base_state_machine_change_state(sm, SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_IDLE);
496 break;
497 case SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_CMD:
498 status = common_complete_io(sci_port, sci_dev, sci_req);
499 if (status != SCI_SUCCESS)
500 break;
501 sci_base_state_machine_change_state(sm, SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_IDLE);
502 break;
503 case SCI_BASE_REMOTE_DEVICE_STATE_STOPPING:
504 status = common_complete_io(sci_port, sci_dev, sci_req);
505 if (status != SCI_SUCCESS)
506 break;
507
508 if (scic_sds_remote_device_get_request_count(sci_dev) == 0)
509 scic_sds_remote_node_context_destruct(&sci_dev->rnc,
510 rnc_destruct_done,
511 sci_dev);
512 break;
513 }
514
515 if (status != SCI_SUCCESS)
516 dev_err(scirdev_to_dev(sci_dev),
517 "%s: Port:0x%p Device:0x%p Request:0x%p Status:0x%x "
518 "could not complete\n", __func__, sci_port,
519 sci_dev, sci_req, status);
520
521 return status;
522 }
523
524 static void scic_sds_remote_device_continue_request(void *dev)
525 {
526 struct scic_sds_remote_device *sci_dev = dev;
527
528 /* we need to check if this request is still valid to continue. */
529 if (sci_dev->working_request)
530 scic_controller_continue_io(sci_dev->working_request);
531 }
532
533 enum sci_status scic_sds_remote_device_start_task(struct scic_sds_controller *scic,
534 struct scic_sds_remote_device *sci_dev,
535 struct scic_sds_request *sci_req)
536 {
537 struct sci_base_state_machine *sm = &sci_dev->state_machine;
538 enum scic_sds_remote_device_states state = sm->current_state_id;
539 struct scic_sds_port *sci_port = sci_dev->owning_port;
540 enum sci_status status;
541
542 switch (state) {
543 case SCI_BASE_REMOTE_DEVICE_STATE_INITIAL:
544 case SCI_BASE_REMOTE_DEVICE_STATE_STOPPED:
545 case SCI_BASE_REMOTE_DEVICE_STATE_STARTING:
546 case SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_IDLE:
547 case SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_CMD:
548 case SCI_BASE_REMOTE_DEVICE_STATE_STOPPING:
549 case SCI_BASE_REMOTE_DEVICE_STATE_FAILED:
550 case SCI_BASE_REMOTE_DEVICE_STATE_RESETTING:
551 case SCI_BASE_REMOTE_DEVICE_STATE_FINAL:
552 default:
553 dev_warn(scirdev_to_dev(sci_dev), "%s: in wrong state: %d\n",
554 __func__, state);
555 return SCI_FAILURE_INVALID_STATE;
556 case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_IDLE:
557 case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_CMD:
558 case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ:
559 case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ_ERROR:
560 case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_AWAIT_RESET:
561 status = scic_sds_port_start_io(sci_port, sci_dev, sci_req);
562 if (status != SCI_SUCCESS)
563 return status;
564
565 status = scic_sds_remote_node_context_start_task(&sci_dev->rnc, sci_req);
566 if (status != SCI_SUCCESS)
567 goto out;
568
569 status = sci_req->state_handlers->start_handler(sci_req);
570 if (status != SCI_SUCCESS)
571 goto out;
572
573 /* Note: If the remote device state is not IDLE this will
574 * replace the request that probably resulted in the task
575 * management request.
576 */
577 sci_dev->working_request = sci_req;
578 sci_base_state_machine_change_state(sm, SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_CMD);
579
580 /* The remote node context must cleanup the TCi to NCQ mapping
581 * table. The only way to do this correctly is to either write
582 * to the TLCR register or to invalidate and repost the RNC. In
583 * either case the remote node context state machine will take
584 * the correct action when the remote node context is suspended
585 * and later resumed.
586 */
587 scic_sds_remote_node_context_suspend(&sci_dev->rnc,
588 SCI_SOFTWARE_SUSPENSION, NULL, NULL);
589 scic_sds_remote_node_context_resume(&sci_dev->rnc,
590 scic_sds_remote_device_continue_request,
591 sci_dev);
592
593 out:
594 scic_sds_remote_device_start_request(sci_dev, sci_req, status);
595 /* We need to let the controller start request handler know that
596 * it can't post TC yet. We will provide a callback function to
597 * post TC when RNC gets resumed.
598 */
599 return SCI_FAILURE_RESET_DEVICE_PARTIAL_SUCCESS;
600 case SCI_BASE_REMOTE_DEVICE_STATE_READY:
601 status = scic_sds_port_start_io(sci_port, sci_dev, sci_req);
602 if (status != SCI_SUCCESS)
603 return status;
604
605 status = scic_sds_remote_node_context_start_task(&sci_dev->rnc, sci_req);
606 if (status != SCI_SUCCESS)
607 break;
608
609 status = scic_sds_request_start(sci_req);
610 break;
611 }
612 scic_sds_remote_device_start_request(sci_dev, sci_req, status);
613
614 return status;
615 }
616
617 /**
618 *
619 * @sci_dev:
620 * @request:
621 *
622 * This method takes the request and bulids an appropriate SCU context for the
623 * request and then requests the controller to post the request. none
624 */
625 void scic_sds_remote_device_post_request(
626 struct scic_sds_remote_device *sci_dev,
627 u32 request)
628 {
629 u32 context;
630
631 context = scic_sds_remote_device_build_command_context(sci_dev, request);
632
633 scic_sds_controller_post_request(
634 scic_sds_remote_device_get_controller(sci_dev),
635 context
636 );
637 }
638
639 /* called once the remote node context has transisitioned to a
640 * ready state. This is the indication that the remote device object can also
641 * transition to ready.
642 */
643 static void remote_device_resume_done(void *_dev)
644 {
645 struct scic_sds_remote_device *sci_dev = _dev;
646 enum scic_sds_remote_device_states state;
647
648 state = sci_dev->state_machine.current_state_id;
649 switch (state) {
650 case SCI_BASE_REMOTE_DEVICE_STATE_READY:
651 case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_IDLE:
652 case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_CMD:
653 case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ:
654 case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ_ERROR:
655 case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_AWAIT_RESET:
656 case SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_IDLE:
657 case SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_CMD:
658 break;
659 default:
660 /* go 'ready' if we are not already in a ready state */
661 sci_base_state_machine_change_state(&sci_dev->state_machine,
662 SCI_BASE_REMOTE_DEVICE_STATE_READY);
663 break;
664 }
665 }
666
667 static enum sci_status
668 default_device_handler(struct scic_sds_remote_device *sci_dev,
669 const char *func)
670 {
671 dev_warn(scirdev_to_dev(sci_dev),
672 "%s: in wrong state: %d\n", func,
673 sci_base_state_machine_get_state(&sci_dev->state_machine));
674 return SCI_FAILURE_INVALID_STATE;
675 }
676
677 static enum sci_status scic_sds_remote_device_default_suspend_handler(
678 struct scic_sds_remote_device *sci_dev, u32 suspend_type)
679 {
680 return default_device_handler(sci_dev, __func__);
681 }
682
683 static enum sci_status scic_sds_remote_device_default_resume_handler(
684 struct scic_sds_remote_device *sci_dev)
685 {
686 return default_device_handler(sci_dev, __func__);
687 }
688
689 /**
690 *
691 * @device: The struct scic_sds_remote_device which is then cast into a
692 * struct scic_sds_remote_device.
693 * @event_code: The event code that the struct scic_sds_controller wants the device
694 * object to process.
695 *
696 * This method is the default event handler. It will call the RNC state
697 * machine handler for any RNC events otherwise it will log a warning and
698 * returns a failure. enum sci_status SCI_FAILURE_INVALID_STATE
699 */
700 static enum sci_status scic_sds_remote_device_core_event_handler(
701 struct scic_sds_remote_device *sci_dev,
702 u32 event_code,
703 bool is_ready_state)
704 {
705 enum sci_status status;
706
707 switch (scu_get_event_type(event_code)) {
708 case SCU_EVENT_TYPE_RNC_OPS_MISC:
709 case SCU_EVENT_TYPE_RNC_SUSPEND_TX:
710 case SCU_EVENT_TYPE_RNC_SUSPEND_TX_RX:
711 status = scic_sds_remote_node_context_event_handler(&sci_dev->rnc, event_code);
712 break;
713 case SCU_EVENT_TYPE_PTX_SCHEDULE_EVENT:
714
715 if (scu_get_event_code(event_code) == SCU_EVENT_IT_NEXUS_TIMEOUT) {
716 status = SCI_SUCCESS;
717
718 /* Suspend the associated RNC */
719 scic_sds_remote_node_context_suspend(&sci_dev->rnc,
720 SCI_SOFTWARE_SUSPENSION,
721 NULL, NULL);
722
723 dev_dbg(scirdev_to_dev(sci_dev),
724 "%s: device: %p event code: %x: %s\n",
725 __func__, sci_dev, event_code,
726 (is_ready_state)
727 ? "I_T_Nexus_Timeout event"
728 : "I_T_Nexus_Timeout event in wrong state");
729
730 break;
731 }
732 /* Else, fall through and treat as unhandled... */
733
734 default:
735 dev_dbg(scirdev_to_dev(sci_dev),
736 "%s: device: %p event code: %x: %s\n",
737 __func__, sci_dev, event_code,
738 (is_ready_state)
739 ? "unexpected event"
740 : "unexpected event in wrong state");
741 status = SCI_FAILURE_INVALID_STATE;
742 break;
743 }
744
745 return status;
746 }
747 /**
748 *
749 * @device: The struct scic_sds_remote_device which is then cast into a
750 * struct scic_sds_remote_device.
751 * @event_code: The event code that the struct scic_sds_controller wants the device
752 * object to process.
753 *
754 * This method is the default event handler. It will call the RNC state
755 * machine handler for any RNC events otherwise it will log a warning and
756 * returns a failure. enum sci_status SCI_FAILURE_INVALID_STATE
757 */
758 static enum sci_status scic_sds_remote_device_default_event_handler(
759 struct scic_sds_remote_device *sci_dev,
760 u32 event_code)
761 {
762 return scic_sds_remote_device_core_event_handler(sci_dev,
763 event_code,
764 false);
765 }
766
767 /**
768 *
769 * @device: The struct scic_sds_remote_device which is then cast into a
770 * struct scic_sds_remote_device.
771 * @frame_index: The frame index for which the struct scic_sds_controller wants this
772 * device object to process.
773 *
774 * This method is the default unsolicited frame handler. It logs a warning,
775 * releases the frame and returns a failure. enum sci_status
776 * SCI_FAILURE_INVALID_STATE
777 */
778 static enum sci_status scic_sds_remote_device_default_frame_handler(
779 struct scic_sds_remote_device *sci_dev,
780 u32 frame_index)
781 {
782 dev_warn(scirdev_to_dev(sci_dev),
783 "%s: SCIC Remote Device requested to handle frame %x "
784 "while in wrong state %d\n",
785 __func__,
786 frame_index,
787 sci_base_state_machine_get_state(
788 &sci_dev->state_machine));
789
790 /* Return the frame back to the controller */
791 scic_sds_controller_release_frame(
792 scic_sds_remote_device_get_controller(sci_dev), frame_index
793 );
794
795 return SCI_FAILURE_INVALID_STATE;
796 }
797
798 /**
799 *
800 * @device: The struct scic_sds_remote_device which is then cast into a
801 * struct scic_sds_remote_device.
802 * @frame_index: The frame index for which the struct scic_sds_controller wants this
803 * device object to process.
804 *
805 * This method is a general ssp frame handler. In most cases the device object
806 * needs to route the unsolicited frame processing to the io request object.
807 * This method decodes the tag for the io request object and routes the
808 * unsolicited frame to that object. enum sci_status SCI_FAILURE_INVALID_STATE
809 */
810 static enum sci_status scic_sds_remote_device_general_frame_handler(
811 struct scic_sds_remote_device *sci_dev,
812 u32 frame_index)
813 {
814 enum sci_status result;
815 struct sci_ssp_frame_header *frame_header;
816 struct scic_sds_request *io_request;
817
818 result = scic_sds_unsolicited_frame_control_get_header(
819 &(scic_sds_remote_device_get_controller(sci_dev)->uf_control),
820 frame_index,
821 (void **)&frame_header
822 );
823
824 if (SCI_SUCCESS == result) {
825 io_request = scic_sds_controller_get_io_request_from_tag(
826 scic_sds_remote_device_get_controller(sci_dev), frame_header->tag);
827
828 if ((io_request == NULL)
829 || (io_request->target_device != sci_dev)) {
830 /*
831 * We could not map this tag to a valid IO request
832 * Just toss the frame and continue */
833 scic_sds_controller_release_frame(
834 scic_sds_remote_device_get_controller(sci_dev), frame_index
835 );
836 } else {
837 /* The IO request is now in charge of releasing the frame */
838 result = io_request->state_handlers->frame_handler(
839 io_request, frame_index);
840 }
841 }
842
843 return result;
844 }
845
846 /**
847 *
848 * @[in]: sci_dev This is the device object that is receiving the event.
849 * @[in]: event_code The event code to process.
850 *
851 * This is a common method for handling events reported to the remote device
852 * from the controller object. enum sci_status
853 */
854 static enum sci_status scic_sds_remote_device_general_event_handler(
855 struct scic_sds_remote_device *sci_dev,
856 u32 event_code)
857 {
858 return scic_sds_remote_device_core_event_handler(sci_dev,
859 event_code,
860 true);
861 }
862
863 static enum sci_status scic_sds_stp_remote_device_ready_idle_substate_event_handler(
864 struct scic_sds_remote_device *sci_dev,
865 u32 event_code)
866 {
867 enum sci_status status;
868
869 status = scic_sds_remote_device_general_event_handler(sci_dev, event_code);
870 if (status != SCI_SUCCESS)
871 return status;
872
873 /* We pick up suspension events to handle specifically to this state. We
874 * resume the RNC right away. enum sci_status
875 */
876 if (scu_get_event_type(event_code) == SCU_EVENT_TYPE_RNC_SUSPEND_TX ||
877 scu_get_event_type(event_code) == SCU_EVENT_TYPE_RNC_SUSPEND_TX_RX)
878 status = scic_sds_remote_node_context_resume(&sci_dev->rnc, NULL, NULL);
879
880 return status;
881 }
882
883 static enum sci_status scic_sds_stp_remote_device_ready_ncq_substate_frame_handler(struct scic_sds_remote_device *sci_dev,
884 u32 frame_index)
885 {
886 enum sci_status status;
887 struct sata_fis_header *frame_header;
888 struct scic_sds_controller *scic = sci_dev->owning_port->owning_controller;
889
890 status = scic_sds_unsolicited_frame_control_get_header(&scic->uf_control,
891 frame_index,
892 (void **)&frame_header);
893 if (status != SCI_SUCCESS)
894 return status;
895
896 if (frame_header->fis_type == SATA_FIS_TYPE_SETDEVBITS &&
897 (frame_header->status & ATA_STATUS_REG_ERROR_BIT)) {
898 sci_dev->not_ready_reason = SCIC_REMOTE_DEVICE_NOT_READY_SATA_SDB_ERROR_FIS_RECEIVED;
899
900 /* TODO Check sactive and complete associated IO if any. */
901
902 sci_base_state_machine_change_state(&sci_dev->state_machine,
903 SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ_ERROR);
904 } else if (frame_header->fis_type == SATA_FIS_TYPE_REGD2H &&
905 (frame_header->status & ATA_STATUS_REG_ERROR_BIT)) {
906 /*
907 * Some devices return D2H FIS when an NCQ error is detected.
908 * Treat this like an SDB error FIS ready reason.
909 */
910 sci_dev->not_ready_reason = SCIC_REMOTE_DEVICE_NOT_READY_SATA_SDB_ERROR_FIS_RECEIVED;
911
912 sci_base_state_machine_change_state(&sci_dev->state_machine,
913 SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ_ERROR);
914 } else
915 status = SCI_FAILURE;
916
917 scic_sds_controller_release_frame(scic, frame_index);
918
919 return status;
920 }
921
922 static enum sci_status scic_sds_stp_remote_device_ready_cmd_substate_suspend_handler(
923 struct scic_sds_remote_device *sci_dev,
924 u32 suspend_type)
925 {
926 enum sci_status status;
927
928 status = scic_sds_remote_node_context_suspend(&sci_dev->rnc,
929 suspend_type, NULL, NULL);
930
931 return status;
932 }
933
934 static enum sci_status scic_sds_stp_remote_device_ready_cmd_substate_frame_handler(
935 struct scic_sds_remote_device *sci_dev,
936 u32 frame_index)
937 {
938 /* The device doe not process any UF received from the hardware while
939 * in this state. All unsolicited frames are forwarded to the io
940 * request object.
941 */
942 return scic_sds_io_request_frame_handler(sci_dev->working_request,
943 frame_index);
944 }
945
946 static void scic_sds_stp_remote_device_ready_idle_substate_resume_complete_handler(void *_dev)
947 {
948 struct scic_sds_remote_device *sci_dev = _dev;
949 struct isci_remote_device *idev = sci_dev_to_idev(sci_dev);
950 struct scic_sds_controller *scic = sci_dev->owning_port->owning_controller;
951
952 /* For NCQ operation we do not issue a isci_remote_device_not_ready().
953 * As a result, avoid sending the ready notification.
954 */
955 if (sci_dev->state_machine.previous_state_id != SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ)
956 isci_remote_device_ready(scic->ihost, idev);
957 }
958
959 static enum sci_status scic_sds_smp_remote_device_ready_cmd_substate_frame_handler(
960 struct scic_sds_remote_device *sci_dev,
961 u32 frame_index)
962 {
963 enum sci_status status;
964
965 /* The device does not process any UF received from the hardware while
966 * in this state. All unsolicited frames are forwarded to the io request
967 * object.
968 */
969 status = scic_sds_io_request_frame_handler(
970 sci_dev->working_request,
971 frame_index
972 );
973
974 return status;
975 }
976
977 static const struct scic_sds_remote_device_state_handler scic_sds_remote_device_state_handler_table[] = {
978 [SCI_BASE_REMOTE_DEVICE_STATE_INITIAL] = {
979 .suspend_handler = scic_sds_remote_device_default_suspend_handler,
980 .resume_handler = scic_sds_remote_device_default_resume_handler,
981 .event_handler = scic_sds_remote_device_default_event_handler,
982 .frame_handler = scic_sds_remote_device_default_frame_handler
983 },
984 [SCI_BASE_REMOTE_DEVICE_STATE_STOPPED] = {
985 .suspend_handler = scic_sds_remote_device_default_suspend_handler,
986 .resume_handler = scic_sds_remote_device_default_resume_handler,
987 .event_handler = scic_sds_remote_device_default_event_handler,
988 .frame_handler = scic_sds_remote_device_default_frame_handler
989 },
990 [SCI_BASE_REMOTE_DEVICE_STATE_STARTING] = {
991 .suspend_handler = scic_sds_remote_device_default_suspend_handler,
992 .resume_handler = scic_sds_remote_device_default_resume_handler,
993 .event_handler = scic_sds_remote_device_general_event_handler,
994 .frame_handler = scic_sds_remote_device_default_frame_handler
995 },
996 [SCI_BASE_REMOTE_DEVICE_STATE_READY] = {
997 .suspend_handler = scic_sds_remote_device_default_suspend_handler,
998 .resume_handler = scic_sds_remote_device_default_resume_handler,
999 .event_handler = scic_sds_remote_device_general_event_handler,
1000 .frame_handler = scic_sds_remote_device_general_frame_handler,
1001 },
1002 [SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_IDLE] = {
1003 .suspend_handler = scic_sds_remote_device_default_suspend_handler,
1004 .resume_handler = scic_sds_remote_device_default_resume_handler,
1005 .event_handler = scic_sds_stp_remote_device_ready_idle_substate_event_handler,
1006 .frame_handler = scic_sds_remote_device_default_frame_handler
1007 },
1008 [SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_CMD] = {
1009 .suspend_handler = scic_sds_stp_remote_device_ready_cmd_substate_suspend_handler,
1010 .resume_handler = scic_sds_remote_device_default_resume_handler,
1011 .event_handler = scic_sds_remote_device_general_event_handler,
1012 .frame_handler = scic_sds_stp_remote_device_ready_cmd_substate_frame_handler
1013 },
1014 [SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ] = {
1015 .suspend_handler = scic_sds_remote_device_default_suspend_handler,
1016 .resume_handler = scic_sds_remote_device_default_resume_handler,
1017 .event_handler = scic_sds_remote_device_general_event_handler,
1018 .frame_handler = scic_sds_stp_remote_device_ready_ncq_substate_frame_handler
1019 },
1020 [SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ_ERROR] = {
1021 .suspend_handler = scic_sds_remote_device_default_suspend_handler,
1022 .resume_handler = scic_sds_remote_device_default_resume_handler,
1023 .event_handler = scic_sds_remote_device_general_event_handler,
1024 .frame_handler = scic_sds_remote_device_general_frame_handler
1025 },
1026 [SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_AWAIT_RESET] = {
1027 .suspend_handler = scic_sds_remote_device_default_suspend_handler,
1028 .resume_handler = scic_sds_remote_device_default_resume_handler,
1029 .event_handler = scic_sds_remote_device_general_event_handler,
1030 .frame_handler = scic_sds_remote_device_general_frame_handler
1031 },
1032 [SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_IDLE] = {
1033 .suspend_handler = scic_sds_remote_device_default_suspend_handler,
1034 .resume_handler = scic_sds_remote_device_default_resume_handler,
1035 .event_handler = scic_sds_remote_device_general_event_handler,
1036 .frame_handler = scic_sds_remote_device_default_frame_handler
1037 },
1038 [SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_CMD] = {
1039 .suspend_handler = scic_sds_remote_device_default_suspend_handler,
1040 .resume_handler = scic_sds_remote_device_default_resume_handler,
1041 .event_handler = scic_sds_remote_device_general_event_handler,
1042 .frame_handler = scic_sds_smp_remote_device_ready_cmd_substate_frame_handler
1043 },
1044 [SCI_BASE_REMOTE_DEVICE_STATE_STOPPING] = {
1045 .suspend_handler = scic_sds_remote_device_default_suspend_handler,
1046 .resume_handler = scic_sds_remote_device_default_resume_handler,
1047 .event_handler = scic_sds_remote_device_general_event_handler,
1048 .frame_handler = scic_sds_remote_device_general_frame_handler
1049 },
1050 [SCI_BASE_REMOTE_DEVICE_STATE_FAILED] = {
1051 .suspend_handler = scic_sds_remote_device_default_suspend_handler,
1052 .resume_handler = scic_sds_remote_device_default_resume_handler,
1053 .event_handler = scic_sds_remote_device_default_event_handler,
1054 .frame_handler = scic_sds_remote_device_general_frame_handler
1055 },
1056 [SCI_BASE_REMOTE_DEVICE_STATE_RESETTING] = {
1057 .suspend_handler = scic_sds_remote_device_default_suspend_handler,
1058 .resume_handler = scic_sds_remote_device_default_resume_handler,
1059 .event_handler = scic_sds_remote_device_default_event_handler,
1060 .frame_handler = scic_sds_remote_device_general_frame_handler
1061 },
1062 [SCI_BASE_REMOTE_DEVICE_STATE_FINAL] = {
1063 .suspend_handler = scic_sds_remote_device_default_suspend_handler,
1064 .resume_handler = scic_sds_remote_device_default_resume_handler,
1065 .event_handler = scic_sds_remote_device_default_event_handler,
1066 .frame_handler = scic_sds_remote_device_default_frame_handler
1067 }
1068 };
1069
1070 static void scic_sds_remote_device_initial_state_enter(void *object)
1071 {
1072 struct scic_sds_remote_device *sci_dev = object;
1073
1074 SET_STATE_HANDLER(sci_dev, scic_sds_remote_device_state_handler_table,
1075 SCI_BASE_REMOTE_DEVICE_STATE_INITIAL);
1076
1077 /* Initial state is a transitional state to the stopped state */
1078 sci_base_state_machine_change_state(&sci_dev->state_machine,
1079 SCI_BASE_REMOTE_DEVICE_STATE_STOPPED);
1080 }
1081
1082 /**
1083 * scic_remote_device_destruct() - free remote node context and destruct
1084 * @remote_device: This parameter specifies the remote device to be destructed.
1085 *
1086 * Remote device objects are a limited resource. As such, they must be
1087 * protected. Thus calls to construct and destruct are mutually exclusive and
1088 * non-reentrant. The return value shall indicate if the device was
1089 * successfully destructed or if some failure occurred. enum sci_status This value
1090 * is returned if the device is successfully destructed.
1091 * SCI_FAILURE_INVALID_REMOTE_DEVICE This value is returned if the supplied
1092 * device isn't valid (e.g. it's already been destoryed, the handle isn't
1093 * valid, etc.).
1094 */
1095 static enum sci_status scic_remote_device_destruct(struct scic_sds_remote_device *sci_dev)
1096 {
1097 struct sci_base_state_machine *sm = &sci_dev->state_machine;
1098 enum scic_sds_remote_device_states state = sm->current_state_id;
1099 struct scic_sds_controller *scic;
1100
1101 if (state != SCI_BASE_REMOTE_DEVICE_STATE_STOPPED) {
1102 dev_warn(scirdev_to_dev(sci_dev), "%s: in wrong state: %d\n",
1103 __func__, state);
1104 return SCI_FAILURE_INVALID_STATE;
1105 }
1106
1107 scic = sci_dev->owning_port->owning_controller;
1108 scic_sds_controller_free_remote_node_context(scic, sci_dev,
1109 sci_dev->rnc.remote_node_index);
1110 sci_dev->rnc.remote_node_index = SCIC_SDS_REMOTE_NODE_CONTEXT_INVALID_INDEX;
1111 sci_base_state_machine_change_state(sm, SCI_BASE_REMOTE_DEVICE_STATE_FINAL);
1112
1113 return SCI_SUCCESS;
1114 }
1115
1116 /**
1117 * isci_remote_device_deconstruct() - This function frees an isci_remote_device.
1118 * @ihost: This parameter specifies the isci host object.
1119 * @idev: This parameter specifies the remote device to be freed.
1120 *
1121 */
1122 static void isci_remote_device_deconstruct(struct isci_host *ihost, struct isci_remote_device *idev)
1123 {
1124 dev_dbg(&ihost->pdev->dev,
1125 "%s: isci_device = %p\n", __func__, idev);
1126
1127 /* There should not be any outstanding io's. All paths to
1128 * here should go through isci_remote_device_nuke_requests.
1129 * If we hit this condition, we will need a way to complete
1130 * io requests in process */
1131 while (!list_empty(&idev->reqs_in_process)) {
1132
1133 dev_err(&ihost->pdev->dev,
1134 "%s: ** request list not empty! **\n", __func__);
1135 BUG();
1136 }
1137
1138 scic_remote_device_destruct(&idev->sci);
1139 idev->domain_dev->lldd_dev = NULL;
1140 idev->domain_dev = NULL;
1141 idev->isci_port = NULL;
1142 list_del_init(&idev->node);
1143
1144 clear_bit(IDEV_START_PENDING, &idev->flags);
1145 clear_bit(IDEV_STOP_PENDING, &idev->flags);
1146 wake_up(&ihost->eventq);
1147 }
1148
1149 /**
1150 * isci_remote_device_stop_complete() - This function is called by the scic
1151 * when the remote device stop has completed. We mark the isci device as not
1152 * ready and remove the isci remote device.
1153 * @ihost: This parameter specifies the isci host object.
1154 * @idev: This parameter specifies the remote device.
1155 * @status: This parameter specifies status of the completion.
1156 *
1157 */
1158 static void isci_remote_device_stop_complete(struct isci_host *ihost,
1159 struct isci_remote_device *idev)
1160 {
1161 dev_dbg(&ihost->pdev->dev, "%s: complete idev = %p\n", __func__, idev);
1162
1163 isci_remote_device_change_state(idev, isci_stopped);
1164
1165 /* after stop, we can tear down resources. */
1166 isci_remote_device_deconstruct(ihost, idev);
1167 }
1168
1169 static void scic_sds_remote_device_stopped_state_enter(void *object)
1170 {
1171 struct scic_sds_remote_device *sci_dev = object;
1172 struct scic_sds_controller *scic;
1173 struct isci_remote_device *idev;
1174 struct isci_host *ihost;
1175 u32 prev_state;
1176
1177 scic = scic_sds_remote_device_get_controller(sci_dev);
1178 ihost = scic->ihost;
1179 idev = sci_dev_to_idev(sci_dev);
1180
1181 SET_STATE_HANDLER(sci_dev, scic_sds_remote_device_state_handler_table,
1182 SCI_BASE_REMOTE_DEVICE_STATE_STOPPED);
1183
1184 /* If we are entering from the stopping state let the SCI User know that
1185 * the stop operation has completed.
1186 */
1187 prev_state = sci_dev->state_machine.previous_state_id;
1188 if (prev_state == SCI_BASE_REMOTE_DEVICE_STATE_STOPPING)
1189 isci_remote_device_stop_complete(ihost, idev);
1190
1191 scic_sds_controller_remote_device_stopped(scic, sci_dev);
1192 }
1193
1194 static void scic_sds_remote_device_starting_state_enter(void *object)
1195 {
1196 struct scic_sds_remote_device *sci_dev = object;
1197 struct scic_sds_controller *scic = scic_sds_remote_device_get_controller(sci_dev);
1198 struct isci_host *ihost = scic->ihost;
1199 struct isci_remote_device *idev = sci_dev_to_idev(sci_dev);
1200
1201 SET_STATE_HANDLER(sci_dev, scic_sds_remote_device_state_handler_table,
1202 SCI_BASE_REMOTE_DEVICE_STATE_STARTING);
1203
1204 isci_remote_device_not_ready(ihost, idev,
1205 SCIC_REMOTE_DEVICE_NOT_READY_START_REQUESTED);
1206 }
1207
1208 static void scic_sds_remote_device_ready_state_enter(void *object)
1209 {
1210 struct scic_sds_remote_device *sci_dev = object;
1211 struct scic_sds_controller *scic = sci_dev->owning_port->owning_controller;
1212 struct domain_device *dev = sci_dev_to_domain(sci_dev);
1213
1214 SET_STATE_HANDLER(sci_dev,
1215 scic_sds_remote_device_state_handler_table,
1216 SCI_BASE_REMOTE_DEVICE_STATE_READY);
1217
1218 scic->remote_device_sequence[sci_dev->rnc.remote_node_index]++;
1219
1220 if (dev->dev_type == SATA_DEV || (dev->tproto & SAS_PROTOCOL_SATA)) {
1221 sci_base_state_machine_change_state(&sci_dev->state_machine,
1222 SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_IDLE);
1223 } else if (dev_is_expander(dev)) {
1224 sci_base_state_machine_change_state(&sci_dev->state_machine,
1225 SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_IDLE);
1226 } else
1227 isci_remote_device_ready(scic->ihost, sci_dev_to_idev(sci_dev));
1228 }
1229
1230 static void scic_sds_remote_device_ready_state_exit(void *object)
1231 {
1232 struct scic_sds_remote_device *sci_dev = object;
1233 struct domain_device *dev = sci_dev_to_domain(sci_dev);
1234
1235 if (dev->dev_type == SAS_END_DEV) {
1236 struct scic_sds_controller *scic = sci_dev->owning_port->owning_controller;
1237 struct isci_remote_device *idev = sci_dev_to_idev(sci_dev);
1238
1239 isci_remote_device_not_ready(scic->ihost, idev,
1240 SCIC_REMOTE_DEVICE_NOT_READY_STOP_REQUESTED);
1241 }
1242 }
1243
1244 static void scic_sds_remote_device_stopping_state_enter(void *object)
1245 {
1246 struct scic_sds_remote_device *sci_dev = object;
1247
1248 SET_STATE_HANDLER(
1249 sci_dev,
1250 scic_sds_remote_device_state_handler_table,
1251 SCI_BASE_REMOTE_DEVICE_STATE_STOPPING
1252 );
1253 }
1254
1255 static void scic_sds_remote_device_failed_state_enter(void *object)
1256 {
1257 struct scic_sds_remote_device *sci_dev = object;
1258
1259 SET_STATE_HANDLER(
1260 sci_dev,
1261 scic_sds_remote_device_state_handler_table,
1262 SCI_BASE_REMOTE_DEVICE_STATE_FAILED
1263 );
1264 }
1265
1266 static void scic_sds_remote_device_resetting_state_enter(void *object)
1267 {
1268 struct scic_sds_remote_device *sci_dev = object;
1269
1270 SET_STATE_HANDLER(
1271 sci_dev,
1272 scic_sds_remote_device_state_handler_table,
1273 SCI_BASE_REMOTE_DEVICE_STATE_RESETTING
1274 );
1275
1276 scic_sds_remote_node_context_suspend(
1277 &sci_dev->rnc, SCI_SOFTWARE_SUSPENSION, NULL, NULL);
1278 }
1279
1280 static void scic_sds_remote_device_resetting_state_exit(void *object)
1281 {
1282 struct scic_sds_remote_device *sci_dev = object;
1283
1284 scic_sds_remote_node_context_resume(&sci_dev->rnc, NULL, NULL);
1285 }
1286
1287 static void scic_sds_remote_device_final_state_enter(void *object)
1288 {
1289 struct scic_sds_remote_device *sci_dev = object;
1290
1291 SET_STATE_HANDLER(
1292 sci_dev,
1293 scic_sds_remote_device_state_handler_table,
1294 SCI_BASE_REMOTE_DEVICE_STATE_FINAL
1295 );
1296 }
1297
1298 static void scic_sds_stp_remote_device_ready_idle_substate_enter(void *object)
1299 {
1300 struct scic_sds_remote_device *sci_dev = object;
1301
1302 SET_STATE_HANDLER(sci_dev, scic_sds_remote_device_state_handler_table,
1303 SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_IDLE);
1304
1305 sci_dev->working_request = NULL;
1306 if (scic_sds_remote_node_context_is_ready(&sci_dev->rnc)) {
1307 /*
1308 * Since the RNC is ready, it's alright to finish completion
1309 * processing (e.g. signal the remote device is ready). */
1310 scic_sds_stp_remote_device_ready_idle_substate_resume_complete_handler(sci_dev);
1311 } else {
1312 scic_sds_remote_node_context_resume(&sci_dev->rnc,
1313 scic_sds_stp_remote_device_ready_idle_substate_resume_complete_handler,
1314 sci_dev);
1315 }
1316 }
1317
1318 static void scic_sds_stp_remote_device_ready_cmd_substate_enter(void *object)
1319 {
1320 struct scic_sds_remote_device *sci_dev = object;
1321 struct scic_sds_controller *scic = scic_sds_remote_device_get_controller(sci_dev);
1322
1323 BUG_ON(sci_dev->working_request == NULL);
1324
1325 SET_STATE_HANDLER(sci_dev, scic_sds_remote_device_state_handler_table,
1326 SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_CMD);
1327
1328 isci_remote_device_not_ready(scic->ihost, sci_dev_to_idev(sci_dev),
1329 SCIC_REMOTE_DEVICE_NOT_READY_SATA_REQUEST_STARTED);
1330 }
1331
1332 static void scic_sds_stp_remote_device_ready_ncq_substate_enter(void *object)
1333 {
1334 struct scic_sds_remote_device *sci_dev = object;
1335
1336 SET_STATE_HANDLER(sci_dev, scic_sds_remote_device_state_handler_table,
1337 SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ);
1338 }
1339
1340 static void scic_sds_stp_remote_device_ready_ncq_error_substate_enter(void *object)
1341 {
1342 struct scic_sds_remote_device *sci_dev = object;
1343 struct scic_sds_controller *scic = scic_sds_remote_device_get_controller(sci_dev);
1344 struct isci_remote_device *idev = sci_dev_to_idev(sci_dev);
1345
1346 SET_STATE_HANDLER(sci_dev, scic_sds_remote_device_state_handler_table,
1347 SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ_ERROR);
1348
1349 if (sci_dev->not_ready_reason == SCIC_REMOTE_DEVICE_NOT_READY_SATA_SDB_ERROR_FIS_RECEIVED)
1350 isci_remote_device_not_ready(scic->ihost, idev,
1351 sci_dev->not_ready_reason);
1352 }
1353
1354 static void scic_sds_stp_remote_device_ready_await_reset_substate_enter(void *object)
1355 {
1356 struct scic_sds_remote_device *sci_dev = object;
1357
1358 SET_STATE_HANDLER(sci_dev, scic_sds_remote_device_state_handler_table,
1359 SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_AWAIT_RESET);
1360 }
1361
1362 static void scic_sds_smp_remote_device_ready_idle_substate_enter(void *object)
1363 {
1364 struct scic_sds_remote_device *sci_dev = object;
1365 struct scic_sds_controller *scic = scic_sds_remote_device_get_controller(sci_dev);
1366
1367 SET_STATE_HANDLER(sci_dev, scic_sds_remote_device_state_handler_table,
1368 SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_IDLE);
1369
1370 isci_remote_device_ready(scic->ihost, sci_dev_to_idev(sci_dev));
1371 }
1372
1373 static void scic_sds_smp_remote_device_ready_cmd_substate_enter(void *object)
1374 {
1375 struct scic_sds_remote_device *sci_dev = object;
1376 struct scic_sds_controller *scic = scic_sds_remote_device_get_controller(sci_dev);
1377
1378 BUG_ON(sci_dev->working_request == NULL);
1379
1380 SET_STATE_HANDLER(sci_dev, scic_sds_remote_device_state_handler_table,
1381 SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_CMD);
1382
1383 isci_remote_device_not_ready(scic->ihost, sci_dev_to_idev(sci_dev),
1384 SCIC_REMOTE_DEVICE_NOT_READY_SMP_REQUEST_STARTED);
1385 }
1386
1387 static void scic_sds_smp_remote_device_ready_cmd_substate_exit(void *object)
1388 {
1389 struct scic_sds_remote_device *sci_dev = object;
1390
1391 sci_dev->working_request = NULL;
1392 }
1393
1394 static const struct sci_base_state scic_sds_remote_device_state_table[] = {
1395 [SCI_BASE_REMOTE_DEVICE_STATE_INITIAL] = {
1396 .enter_state = scic_sds_remote_device_initial_state_enter,
1397 },
1398 [SCI_BASE_REMOTE_DEVICE_STATE_STOPPED] = {
1399 .enter_state = scic_sds_remote_device_stopped_state_enter,
1400 },
1401 [SCI_BASE_REMOTE_DEVICE_STATE_STARTING] = {
1402 .enter_state = scic_sds_remote_device_starting_state_enter,
1403 },
1404 [SCI_BASE_REMOTE_DEVICE_STATE_READY] = {
1405 .enter_state = scic_sds_remote_device_ready_state_enter,
1406 .exit_state = scic_sds_remote_device_ready_state_exit
1407 },
1408 [SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_IDLE] = {
1409 .enter_state = scic_sds_stp_remote_device_ready_idle_substate_enter,
1410 },
1411 [SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_CMD] = {
1412 .enter_state = scic_sds_stp_remote_device_ready_cmd_substate_enter,
1413 },
1414 [SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ] = {
1415 .enter_state = scic_sds_stp_remote_device_ready_ncq_substate_enter,
1416 },
1417 [SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ_ERROR] = {
1418 .enter_state = scic_sds_stp_remote_device_ready_ncq_error_substate_enter,
1419 },
1420 [SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_AWAIT_RESET] = {
1421 .enter_state = scic_sds_stp_remote_device_ready_await_reset_substate_enter,
1422 },
1423 [SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_IDLE] = {
1424 .enter_state = scic_sds_smp_remote_device_ready_idle_substate_enter,
1425 },
1426 [SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_CMD] = {
1427 .enter_state = scic_sds_smp_remote_device_ready_cmd_substate_enter,
1428 .exit_state = scic_sds_smp_remote_device_ready_cmd_substate_exit,
1429 },
1430 [SCI_BASE_REMOTE_DEVICE_STATE_STOPPING] = {
1431 .enter_state = scic_sds_remote_device_stopping_state_enter,
1432 },
1433 [SCI_BASE_REMOTE_DEVICE_STATE_FAILED] = {
1434 .enter_state = scic_sds_remote_device_failed_state_enter,
1435 },
1436 [SCI_BASE_REMOTE_DEVICE_STATE_RESETTING] = {
1437 .enter_state = scic_sds_remote_device_resetting_state_enter,
1438 .exit_state = scic_sds_remote_device_resetting_state_exit
1439 },
1440 [SCI_BASE_REMOTE_DEVICE_STATE_FINAL] = {
1441 .enter_state = scic_sds_remote_device_final_state_enter,
1442 },
1443 };
1444
1445 /**
1446 * scic_remote_device_construct() - common construction
1447 * @sci_port: SAS/SATA port through which this device is accessed.
1448 * @sci_dev: remote device to construct
1449 *
1450 * This routine just performs benign initialization and does not
1451 * allocate the remote_node_context which is left to
1452 * scic_remote_device_[de]a_construct(). scic_remote_device_destruct()
1453 * frees the remote_node_context(s) for the device.
1454 */
1455 static void scic_remote_device_construct(struct scic_sds_port *sci_port,
1456 struct scic_sds_remote_device *sci_dev)
1457 {
1458 sci_dev->owning_port = sci_port;
1459 sci_dev->started_request_count = 0;
1460
1461 sci_base_state_machine_construct(
1462 &sci_dev->state_machine,
1463 sci_dev,
1464 scic_sds_remote_device_state_table,
1465 SCI_BASE_REMOTE_DEVICE_STATE_INITIAL
1466 );
1467
1468 sci_base_state_machine_start(
1469 &sci_dev->state_machine
1470 );
1471
1472 scic_sds_remote_node_context_construct(&sci_dev->rnc,
1473 SCIC_SDS_REMOTE_NODE_CONTEXT_INVALID_INDEX);
1474 }
1475
1476 /**
1477 * scic_remote_device_da_construct() - construct direct attached device.
1478 *
1479 * The information (e.g. IAF, Signature FIS, etc.) necessary to build
1480 * the device is known to the SCI Core since it is contained in the
1481 * scic_phy object. Remote node context(s) is/are a global resource
1482 * allocated by this routine, freed by scic_remote_device_destruct().
1483 *
1484 * Returns:
1485 * SCI_FAILURE_DEVICE_EXISTS - device has already been constructed.
1486 * SCI_FAILURE_UNSUPPORTED_PROTOCOL - e.g. sas device attached to
1487 * sata-only controller instance.
1488 * SCI_FAILURE_INSUFFICIENT_RESOURCES - remote node contexts exhausted.
1489 */
1490 static enum sci_status scic_remote_device_da_construct(struct scic_sds_port *sci_port,
1491 struct scic_sds_remote_device *sci_dev)
1492 {
1493 enum sci_status status;
1494 struct domain_device *dev = sci_dev_to_domain(sci_dev);
1495
1496 scic_remote_device_construct(sci_port, sci_dev);
1497
1498 /*
1499 * This information is request to determine how many remote node context
1500 * entries will be needed to store the remote node.
1501 */
1502 sci_dev->is_direct_attached = true;
1503 status = scic_sds_controller_allocate_remote_node_context(sci_port->owning_controller,
1504 sci_dev,
1505 &sci_dev->rnc.remote_node_index);
1506
1507 if (status != SCI_SUCCESS)
1508 return status;
1509
1510 if (dev->dev_type == SAS_END_DEV || dev->dev_type == SATA_DEV ||
1511 (dev->tproto & SAS_PROTOCOL_STP) || dev_is_expander(dev))
1512 /* pass */;
1513 else
1514 return SCI_FAILURE_UNSUPPORTED_PROTOCOL;
1515
1516 sci_dev->connection_rate = scic_sds_port_get_max_allowed_speed(sci_port);
1517
1518 /* / @todo Should I assign the port width by reading all of the phys on the port? */
1519 sci_dev->device_port_width = 1;
1520
1521 return SCI_SUCCESS;
1522 }
1523
1524 /**
1525 * scic_remote_device_ea_construct() - construct expander attached device
1526 *
1527 * Remote node context(s) is/are a global resource allocated by this
1528 * routine, freed by scic_remote_device_destruct().
1529 *
1530 * Returns:
1531 * SCI_FAILURE_DEVICE_EXISTS - device has already been constructed.
1532 * SCI_FAILURE_UNSUPPORTED_PROTOCOL - e.g. sas device attached to
1533 * sata-only controller instance.
1534 * SCI_FAILURE_INSUFFICIENT_RESOURCES - remote node contexts exhausted.
1535 */
1536 static enum sci_status scic_remote_device_ea_construct(struct scic_sds_port *sci_port,
1537 struct scic_sds_remote_device *sci_dev)
1538 {
1539 struct domain_device *dev = sci_dev_to_domain(sci_dev);
1540 enum sci_status status;
1541
1542 scic_remote_device_construct(sci_port, sci_dev);
1543
1544 status = scic_sds_controller_allocate_remote_node_context(sci_port->owning_controller,
1545 sci_dev,
1546 &sci_dev->rnc.remote_node_index);
1547 if (status != SCI_SUCCESS)
1548 return status;
1549
1550 if (dev->dev_type == SAS_END_DEV || dev->dev_type == SATA_DEV ||
1551 (dev->tproto & SAS_PROTOCOL_STP) || dev_is_expander(dev))
1552 /* pass */;
1553 else
1554 return SCI_FAILURE_UNSUPPORTED_PROTOCOL;
1555
1556 /*
1557 * For SAS-2 the physical link rate is actually a logical link
1558 * rate that incorporates multiplexing. The SCU doesn't
1559 * incorporate multiplexing and for the purposes of the
1560 * connection the logical link rate is that same as the
1561 * physical. Furthermore, the SAS-2 and SAS-1.1 fields overlay
1562 * one another, so this code works for both situations. */
1563 sci_dev->connection_rate = min_t(u16, scic_sds_port_get_max_allowed_speed(sci_port),
1564 dev->linkrate);
1565
1566 /* / @todo Should I assign the port width by reading all of the phys on the port? */
1567 sci_dev->device_port_width = 1;
1568
1569 return SCI_SUCCESS;
1570 }
1571
1572 /**
1573 * scic_remote_device_start() - This method will start the supplied remote
1574 * device. This method enables normal IO requests to flow through to the
1575 * remote device.
1576 * @remote_device: This parameter specifies the device to be started.
1577 * @timeout: This parameter specifies the number of milliseconds in which the
1578 * start operation should complete.
1579 *
1580 * An indication of whether the device was successfully started. SCI_SUCCESS
1581 * This value is returned if the device was successfully started.
1582 * SCI_FAILURE_INVALID_PHY This value is returned if the user attempts to start
1583 * the device when there have been no phys added to it.
1584 */
1585 static enum sci_status scic_remote_device_start(struct scic_sds_remote_device *sci_dev,
1586 u32 timeout)
1587 {
1588 struct sci_base_state_machine *sm = &sci_dev->state_machine;
1589 enum scic_sds_remote_device_states state = sm->current_state_id;
1590 enum sci_status status;
1591
1592 if (state != SCI_BASE_REMOTE_DEVICE_STATE_STOPPED) {
1593 dev_warn(scirdev_to_dev(sci_dev), "%s: in wrong state: %d\n",
1594 __func__, state);
1595 return SCI_FAILURE_INVALID_STATE;
1596 }
1597
1598 status = scic_sds_remote_node_context_resume(&sci_dev->rnc,
1599 remote_device_resume_done,
1600 sci_dev);
1601 if (status != SCI_SUCCESS)
1602 return status;
1603
1604 sci_base_state_machine_change_state(sm, SCI_BASE_REMOTE_DEVICE_STATE_STARTING);
1605
1606 return SCI_SUCCESS;
1607 }
1608
1609 static enum sci_status isci_remote_device_construct(struct isci_port *iport,
1610 struct isci_remote_device *idev)
1611 {
1612 struct scic_sds_port *sci_port = iport->sci_port_handle;
1613 struct isci_host *ihost = iport->isci_host;
1614 struct domain_device *dev = idev->domain_dev;
1615 enum sci_status status;
1616
1617 if (dev->parent && dev_is_expander(dev->parent))
1618 status = scic_remote_device_ea_construct(sci_port, &idev->sci);
1619 else
1620 status = scic_remote_device_da_construct(sci_port, &idev->sci);
1621
1622 if (status != SCI_SUCCESS) {
1623 dev_dbg(&ihost->pdev->dev, "%s: construct failed: %d\n",
1624 __func__, status);
1625
1626 return status;
1627 }
1628
1629 /* start the device. */
1630 status = scic_remote_device_start(&idev->sci, ISCI_REMOTE_DEVICE_START_TIMEOUT);
1631
1632 if (status != SCI_SUCCESS)
1633 dev_warn(&ihost->pdev->dev, "remote device start failed: %d\n",
1634 status);
1635
1636 return status;
1637 }
1638
1639 void isci_remote_device_nuke_requests(struct isci_host *ihost, struct isci_remote_device *idev)
1640 {
1641 DECLARE_COMPLETION_ONSTACK(aborted_task_completion);
1642
1643 dev_dbg(&ihost->pdev->dev,
1644 "%s: idev = %p\n", __func__, idev);
1645
1646 /* Cleanup all requests pending for this device. */
1647 isci_terminate_pending_requests(ihost, idev, terminating);
1648
1649 dev_dbg(&ihost->pdev->dev,
1650 "%s: idev = %p, done\n", __func__, idev);
1651 }
1652
1653 /**
1654 * This function builds the isci_remote_device when a libsas dev_found message
1655 * is received.
1656 * @isci_host: This parameter specifies the isci host object.
1657 * @port: This parameter specifies the isci_port conected to this device.
1658 *
1659 * pointer to new isci_remote_device.
1660 */
1661 static struct isci_remote_device *
1662 isci_remote_device_alloc(struct isci_host *ihost, struct isci_port *iport)
1663 {
1664 struct isci_remote_device *idev;
1665 int i;
1666
1667 for (i = 0; i < SCI_MAX_REMOTE_DEVICES; i++) {
1668 idev = &ihost->devices[i];
1669 if (!test_and_set_bit(IDEV_ALLOCATED, &idev->flags))
1670 break;
1671 }
1672
1673 if (i >= SCI_MAX_REMOTE_DEVICES) {
1674 dev_warn(&ihost->pdev->dev, "%s: failed\n", __func__);
1675 return NULL;
1676 }
1677
1678 if (WARN_ONCE(!list_empty(&idev->reqs_in_process), "found requests in process\n"))
1679 return NULL;
1680
1681 if (WARN_ONCE(!list_empty(&idev->node), "found non-idle remote device\n"))
1682 return NULL;
1683
1684 isci_remote_device_change_state(idev, isci_freed);
1685
1686 return idev;
1687 }
1688
1689 /**
1690 * isci_remote_device_stop() - This function is called internally to stop the
1691 * remote device.
1692 * @isci_host: This parameter specifies the isci host object.
1693 * @isci_device: This parameter specifies the remote device.
1694 *
1695 * The status of the scic request to stop.
1696 */
1697 enum sci_status isci_remote_device_stop(struct isci_host *ihost, struct isci_remote_device *idev)
1698 {
1699 enum sci_status status;
1700 unsigned long flags;
1701
1702 dev_dbg(&ihost->pdev->dev,
1703 "%s: isci_device = %p\n", __func__, idev);
1704
1705 isci_remote_device_change_state(idev, isci_stopping);
1706
1707 /* Kill all outstanding requests. */
1708 isci_remote_device_nuke_requests(ihost, idev);
1709
1710 set_bit(IDEV_STOP_PENDING, &idev->flags);
1711
1712 spin_lock_irqsave(&ihost->scic_lock, flags);
1713 status = scic_remote_device_stop(&idev->sci, 50);
1714 spin_unlock_irqrestore(&ihost->scic_lock, flags);
1715
1716 /* Wait for the stop complete callback. */
1717 if (status == SCI_SUCCESS) {
1718 wait_for_device_stop(ihost, idev);
1719 clear_bit(IDEV_ALLOCATED, &idev->flags);
1720 }
1721
1722 dev_dbg(&ihost->pdev->dev,
1723 "%s: idev = %p - after completion wait\n",
1724 __func__, idev);
1725
1726 return status;
1727 }
1728
1729 /**
1730 * isci_remote_device_gone() - This function is called by libsas when a domain
1731 * device is removed.
1732 * @domain_device: This parameter specifies the libsas domain device.
1733 *
1734 */
1735 void isci_remote_device_gone(struct domain_device *dev)
1736 {
1737 struct isci_host *ihost = dev_to_ihost(dev);
1738 struct isci_remote_device *idev = dev->lldd_dev;
1739
1740 dev_dbg(&ihost->pdev->dev,
1741 "%s: domain_device = %p, isci_device = %p, isci_port = %p\n",
1742 __func__, dev, idev, idev->isci_port);
1743
1744 isci_remote_device_stop(ihost, idev);
1745 }
1746
1747
1748 /**
1749 * isci_remote_device_found() - This function is called by libsas when a remote
1750 * device is discovered. A remote device object is created and started. the
1751 * function then sleeps until the sci core device started message is
1752 * received.
1753 * @domain_device: This parameter specifies the libsas domain device.
1754 *
1755 * status, zero indicates success.
1756 */
1757 int isci_remote_device_found(struct domain_device *domain_dev)
1758 {
1759 struct isci_host *isci_host = dev_to_ihost(domain_dev);
1760 struct isci_port *isci_port;
1761 struct isci_phy *isci_phy;
1762 struct asd_sas_port *sas_port;
1763 struct asd_sas_phy *sas_phy;
1764 struct isci_remote_device *isci_device;
1765 enum sci_status status;
1766
1767 dev_dbg(&isci_host->pdev->dev,
1768 "%s: domain_device = %p\n", __func__, domain_dev);
1769
1770 wait_for_start(isci_host);
1771
1772 sas_port = domain_dev->port;
1773 sas_phy = list_first_entry(&sas_port->phy_list, struct asd_sas_phy,
1774 port_phy_el);
1775 isci_phy = to_isci_phy(sas_phy);
1776 isci_port = isci_phy->isci_port;
1777
1778 /* we are being called for a device on this port,
1779 * so it has to come up eventually
1780 */
1781 wait_for_completion(&isci_port->start_complete);
1782
1783 if ((isci_stopping == isci_port_get_state(isci_port)) ||
1784 (isci_stopped == isci_port_get_state(isci_port)))
1785 return -ENODEV;
1786
1787 isci_device = isci_remote_device_alloc(isci_host, isci_port);
1788 if (!isci_device)
1789 return -ENODEV;
1790
1791 INIT_LIST_HEAD(&isci_device->node);
1792 domain_dev->lldd_dev = isci_device;
1793 isci_device->domain_dev = domain_dev;
1794 isci_device->isci_port = isci_port;
1795 isci_remote_device_change_state(isci_device, isci_starting);
1796
1797
1798 spin_lock_irq(&isci_host->scic_lock);
1799 list_add_tail(&isci_device->node, &isci_port->remote_dev_list);
1800
1801 set_bit(IDEV_START_PENDING, &isci_device->flags);
1802 status = isci_remote_device_construct(isci_port, isci_device);
1803 spin_unlock_irq(&isci_host->scic_lock);
1804
1805 dev_dbg(&isci_host->pdev->dev,
1806 "%s: isci_device = %p\n",
1807 __func__, isci_device);
1808
1809 if (status != SCI_SUCCESS) {
1810
1811 spin_lock_irq(&isci_host->scic_lock);
1812 isci_remote_device_deconstruct(
1813 isci_host,
1814 isci_device
1815 );
1816 spin_unlock_irq(&isci_host->scic_lock);
1817 return -ENODEV;
1818 }
1819
1820 /* wait for the device ready callback. */
1821 wait_for_device_start(isci_host, isci_device);
1822
1823 return 0;
1824 }
1825 /**
1826 * isci_device_is_reset_pending() - This function will check if there is any
1827 * pending reset condition on the device.
1828 * @request: This parameter is the isci_device object.
1829 *
1830 * true if there is a reset pending for the device.
1831 */
1832 bool isci_device_is_reset_pending(
1833 struct isci_host *isci_host,
1834 struct isci_remote_device *isci_device)
1835 {
1836 struct isci_request *isci_request;
1837 struct isci_request *tmp_req;
1838 bool reset_is_pending = false;
1839 unsigned long flags;
1840
1841 dev_dbg(&isci_host->pdev->dev,
1842 "%s: isci_device = %p\n", __func__, isci_device);
1843
1844 spin_lock_irqsave(&isci_host->scic_lock, flags);
1845
1846 /* Check for reset on all pending requests. */
1847 list_for_each_entry_safe(isci_request, tmp_req,
1848 &isci_device->reqs_in_process, dev_node) {
1849 dev_dbg(&isci_host->pdev->dev,
1850 "%s: isci_device = %p request = %p\n",
1851 __func__, isci_device, isci_request);
1852
1853 if (isci_request->ttype == io_task) {
1854 struct sas_task *task = isci_request_access_task(
1855 isci_request);
1856
1857 spin_lock(&task->task_state_lock);
1858 if (task->task_state_flags & SAS_TASK_NEED_DEV_RESET)
1859 reset_is_pending = true;
1860 spin_unlock(&task->task_state_lock);
1861 }
1862 }
1863
1864 spin_unlock_irqrestore(&isci_host->scic_lock, flags);
1865
1866 dev_dbg(&isci_host->pdev->dev,
1867 "%s: isci_device = %p reset_is_pending = %d\n",
1868 __func__, isci_device, reset_is_pending);
1869
1870 return reset_is_pending;
1871 }
1872
1873 /**
1874 * isci_device_clear_reset_pending() - This function will clear if any pending
1875 * reset condition flags on the device.
1876 * @request: This parameter is the isci_device object.
1877 *
1878 * true if there is a reset pending for the device.
1879 */
1880 void isci_device_clear_reset_pending(struct isci_host *ihost, struct isci_remote_device *idev)
1881 {
1882 struct isci_request *isci_request;
1883 struct isci_request *tmp_req;
1884 unsigned long flags = 0;
1885
1886 dev_dbg(&ihost->pdev->dev, "%s: idev=%p, ihost=%p\n",
1887 __func__, idev, ihost);
1888
1889 spin_lock_irqsave(&ihost->scic_lock, flags);
1890
1891 /* Clear reset pending on all pending requests. */
1892 list_for_each_entry_safe(isci_request, tmp_req,
1893 &idev->reqs_in_process, dev_node) {
1894 dev_dbg(&ihost->pdev->dev, "%s: idev = %p request = %p\n",
1895 __func__, idev, isci_request);
1896
1897 if (isci_request->ttype == io_task) {
1898
1899 unsigned long flags2;
1900 struct sas_task *task = isci_request_access_task(
1901 isci_request);
1902
1903 spin_lock_irqsave(&task->task_state_lock, flags2);
1904 task->task_state_flags &= ~SAS_TASK_NEED_DEV_RESET;
1905 spin_unlock_irqrestore(&task->task_state_lock, flags2);
1906 }
1907 }
1908 spin_unlock_irqrestore(&ihost->scic_lock, flags);
1909 }
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree