isci: additional state machine cleanup
[linux-2.6.git] / drivers / scsi / isci / remote_device.c
1 /*
2  * This file is provided under a dual BSD/GPLv2 license.  When using or
3  * redistributing this file, you may do so under either license.
4  *
5  * GPL LICENSE SUMMARY
6  *
7  * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of version 2 of the GNU General Public License as
11  * published by the Free Software Foundation.
12  *
13  * This program is distributed in the hope that it will be useful, but
14  * WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
21  * The full GNU General Public License is included in this distribution
22  * in the file called LICENSE.GPL.
23  *
24  * BSD LICENSE
25  *
26  * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
27  * All rights reserved.
28  *
29  * Redistribution and use in source and binary forms, with or without
30  * modification, are permitted provided that the following conditions
31  * are met:
32  *
33  *   * Redistributions of source code must retain the above copyright
34  *     notice, this list of conditions and the following disclaimer.
35  *   * Redistributions in binary form must reproduce the above copyright
36  *     notice, this list of conditions and the following disclaimer in
37  *     the documentation and/or other materials provided with the
38  *     distribution.
39  *   * Neither the name of Intel Corporation nor the names of its
40  *     contributors may be used to endorse or promote products derived
41  *     from this software without specific prior written permission.
42  *
43  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
44  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
45  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
46  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
47  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
48  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
49  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
50  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
51  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
52  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
53  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
54  */
55 #include <scsi/sas.h>
56 #include "isci.h"
57 #include "port.h"
58 #include "remote_device.h"
59 #include "request.h"
60 #include "remote_node_context.h"
61 #include "scu_event_codes.h"
62 #include "task.h"
63
64 /**
65  * isci_remote_device_change_state() - This function gets the status of the
66  *    remote_device object.
67  * @isci_device: This parameter points to the isci_remote_device object
68  *
69  * status of the object as a isci_status enum.
70  */
71 void isci_remote_device_change_state(
72         struct isci_remote_device *isci_device,
73         enum isci_status status)
74 {
75         unsigned long flags;
76
77         spin_lock_irqsave(&isci_device->state_lock, flags);
78         isci_device->status = status;
79         spin_unlock_irqrestore(&isci_device->state_lock, flags);
80 }
81
82 /**
83  * isci_remote_device_not_ready() - This function is called by the scic when
84  *    the remote device is not ready. We mark the isci device as ready (not
85  *    "ready_for_io") and signal the waiting proccess.
86  * @isci_host: This parameter specifies the isci host object.
87  * @isci_device: This parameter specifies the remote device
88  *
89  */
90 static void isci_remote_device_not_ready(struct isci_host *ihost,
91                                   struct isci_remote_device *idev, u32 reason)
92 {
93         dev_dbg(&ihost->pdev->dev,
94                 "%s: isci_device = %p\n", __func__, idev);
95
96         if (reason == SCIC_REMOTE_DEVICE_NOT_READY_STOP_REQUESTED)
97                 isci_remote_device_change_state(idev, isci_stopping);
98         else
99                 /* device ready is actually a "not ready for io" state. */
100                 isci_remote_device_change_state(idev, isci_ready);
101 }
102
103 /**
104  * isci_remote_device_ready() - This function is called by the scic when the
105  *    remote device is ready. We mark the isci device as ready and signal the
106  *    waiting proccess.
107  * @ihost: our valid isci_host
108  * @idev: remote device
109  *
110  */
111 static void isci_remote_device_ready(struct isci_host *ihost, struct isci_remote_device *idev)
112 {
113         dev_dbg(&ihost->pdev->dev,
114                 "%s: idev = %p\n", __func__, idev);
115
116         isci_remote_device_change_state(idev, isci_ready_for_io);
117         if (test_and_clear_bit(IDEV_START_PENDING, &idev->flags))
118                 wake_up(&ihost->eventq);
119 }
120
121 /* called once the remote node context is ready to be freed.
122  * The remote device can now report that its stop operation is complete. none
123  */
124 static void rnc_destruct_done(void *_dev)
125 {
126         struct scic_sds_remote_device *sci_dev = _dev;
127
128         BUG_ON(sci_dev->started_request_count != 0);
129         sci_change_state(&sci_dev->sm, SCI_DEV_STOPPED);
130 }
131
132 static enum sci_status scic_sds_remote_device_terminate_requests(struct scic_sds_remote_device *sci_dev)
133 {
134         struct scic_sds_controller *scic = sci_dev->owning_port->owning_controller;
135         u32 i, request_count = sci_dev->started_request_count;
136         enum sci_status status  = SCI_SUCCESS;
137
138         for (i = 0; i < SCI_MAX_IO_REQUESTS && i < request_count; i++) {
139                 struct scic_sds_request *sci_req;
140                 enum sci_status s;
141
142                 sci_req = scic->io_request_table[i];
143                 if (!sci_req || sci_req->target_device != sci_dev)
144                         continue;
145                 s = scic_controller_terminate_request(scic, sci_dev, sci_req);
146                 if (s != SCI_SUCCESS)
147                         status = s;
148         }
149
150         return status;
151 }
152
153 enum sci_status scic_remote_device_stop(struct scic_sds_remote_device *sci_dev,
154                                         u32 timeout)
155 {
156         struct sci_base_state_machine *sm = &sci_dev->sm;
157         enum scic_sds_remote_device_states state = sm->current_state_id;
158
159         switch (state) {
160         case SCI_DEV_INITIAL:
161         case SCI_DEV_FAILED:
162         case SCI_DEV_FINAL:
163         default:
164                 dev_warn(scirdev_to_dev(sci_dev), "%s: in wrong state: %d\n",
165                          __func__, state);
166                 return SCI_FAILURE_INVALID_STATE;
167         case SCI_DEV_STOPPED:
168                 return SCI_SUCCESS;
169         case SCI_DEV_STARTING:
170                 /* device not started so there had better be no requests */
171                 BUG_ON(sci_dev->started_request_count != 0);
172                 scic_sds_remote_node_context_destruct(&sci_dev->rnc,
173                                                       rnc_destruct_done, sci_dev);
174                 /* Transition to the stopping state and wait for the
175                  * remote node to complete being posted and invalidated.
176                  */
177                 sci_change_state(sm, SCI_DEV_STOPPING);
178                 return SCI_SUCCESS;
179         case SCI_DEV_READY:
180         case SCI_STP_DEV_IDLE:
181         case SCI_STP_DEV_CMD:
182         case SCI_STP_DEV_NCQ:
183         case SCI_STP_DEV_NCQ_ERROR:
184         case SCI_STP_DEV_AWAIT_RESET:
185         case SCI_SMP_DEV_IDLE:
186         case SCI_SMP_DEV_CMD:
187                 sci_change_state(sm, SCI_DEV_STOPPING);
188                 if (sci_dev->started_request_count == 0) {
189                         scic_sds_remote_node_context_destruct(&sci_dev->rnc,
190                                                               rnc_destruct_done, sci_dev);
191                         return SCI_SUCCESS;
192                 } else
193                         return scic_sds_remote_device_terminate_requests(sci_dev);
194                 break;
195         case SCI_DEV_STOPPING:
196                 /* All requests should have been terminated, but if there is an
197                  * attempt to stop a device already in the stopping state, then
198                  * try again to terminate.
199                  */
200                 return scic_sds_remote_device_terminate_requests(sci_dev);
201         case SCI_DEV_RESETTING:
202                 sci_change_state(sm, SCI_DEV_STOPPING);
203                 return SCI_SUCCESS;
204         }
205 }
206
207 enum sci_status scic_remote_device_reset(struct scic_sds_remote_device *sci_dev)
208 {
209         struct sci_base_state_machine *sm = &sci_dev->sm;
210         enum scic_sds_remote_device_states state = sm->current_state_id;
211
212         switch (state) {
213         case SCI_DEV_INITIAL:
214         case SCI_DEV_STOPPED:
215         case SCI_DEV_STARTING:
216         case SCI_SMP_DEV_IDLE:
217         case SCI_SMP_DEV_CMD:
218         case SCI_DEV_STOPPING:
219         case SCI_DEV_FAILED:
220         case SCI_DEV_RESETTING:
221         case SCI_DEV_FINAL:
222         default:
223                 dev_warn(scirdev_to_dev(sci_dev), "%s: in wrong state: %d\n",
224                          __func__, state);
225                 return SCI_FAILURE_INVALID_STATE;
226         case SCI_DEV_READY:
227         case SCI_STP_DEV_IDLE:
228         case SCI_STP_DEV_CMD:
229         case SCI_STP_DEV_NCQ:
230         case SCI_STP_DEV_NCQ_ERROR:
231         case SCI_STP_DEV_AWAIT_RESET:
232                 sci_change_state(sm, SCI_DEV_RESETTING);
233                 return SCI_SUCCESS;
234         }
235 }
236
237 enum sci_status scic_remote_device_reset_complete(struct scic_sds_remote_device *sci_dev)
238 {
239         struct sci_base_state_machine *sm = &sci_dev->sm;
240         enum scic_sds_remote_device_states state = sm->current_state_id;
241
242         if (state != SCI_DEV_RESETTING) {
243                 dev_warn(scirdev_to_dev(sci_dev), "%s: in wrong state: %d\n",
244                          __func__, state);
245                 return SCI_FAILURE_INVALID_STATE;
246         }
247
248         sci_change_state(sm, SCI_DEV_READY);
249         return SCI_SUCCESS;
250 }
251
252 enum sci_status scic_sds_remote_device_suspend(struct scic_sds_remote_device *sci_dev,
253                                                u32 suspend_type)
254 {
255         struct sci_base_state_machine *sm = &sci_dev->sm;
256         enum scic_sds_remote_device_states state = sm->current_state_id;
257
258         if (state != SCI_STP_DEV_CMD) {
259                 dev_warn(scirdev_to_dev(sci_dev), "%s: in wrong state: %d\n",
260                          __func__, state);
261                 return SCI_FAILURE_INVALID_STATE;
262         }
263
264         return scic_sds_remote_node_context_suspend(&sci_dev->rnc,
265                                                     suspend_type, NULL, NULL);
266 }
267
268 enum sci_status scic_sds_remote_device_frame_handler(struct scic_sds_remote_device *sci_dev,
269                                                      u32 frame_index)
270 {
271         struct sci_base_state_machine *sm = &sci_dev->sm;
272         enum scic_sds_remote_device_states state = sm->current_state_id;
273         struct scic_sds_controller *scic = sci_dev->owning_port->owning_controller;
274         enum sci_status status;
275
276         switch (state) {
277         case SCI_DEV_INITIAL:
278         case SCI_DEV_STOPPED:
279         case SCI_DEV_STARTING:
280         case SCI_STP_DEV_IDLE:
281         case SCI_SMP_DEV_IDLE:
282         case SCI_DEV_FINAL:
283         default:
284                 dev_warn(scirdev_to_dev(sci_dev), "%s: in wrong state: %d\n",
285                          __func__, state);
286                 /* Return the frame back to the controller */
287                 scic_sds_controller_release_frame(scic, frame_index);
288                 return SCI_FAILURE_INVALID_STATE;
289         case SCI_DEV_READY:
290         case SCI_STP_DEV_NCQ_ERROR:
291         case SCI_STP_DEV_AWAIT_RESET:
292         case SCI_DEV_STOPPING:
293         case SCI_DEV_FAILED:
294         case SCI_DEV_RESETTING: {
295                 struct scic_sds_request *sci_req;
296                 struct ssp_frame_hdr hdr;
297                 void *frame_header;
298                 ssize_t word_cnt;
299
300                 status = scic_sds_unsolicited_frame_control_get_header(&scic->uf_control,
301                                                                        frame_index,
302                                                                        &frame_header);
303                 if (status != SCI_SUCCESS)
304                         return status;
305
306                 word_cnt = sizeof(hdr) / sizeof(u32);
307                 sci_swab32_cpy(&hdr, frame_header, word_cnt);
308
309                 sci_req = scic_request_by_tag(scic, be16_to_cpu(hdr.tag));
310                 if (sci_req && sci_req->target_device == sci_dev) {
311                         /* The IO request is now in charge of releasing the frame */
312                         status = scic_sds_io_request_frame_handler(sci_req, frame_index);
313                 } else {
314                         /* We could not map this tag to a valid IO
315                          * request Just toss the frame and continue
316                          */
317                         scic_sds_controller_release_frame(scic, frame_index);
318                 }
319                 break;
320         }
321         case SCI_STP_DEV_NCQ: {
322                 struct dev_to_host_fis *hdr;
323
324                 status = scic_sds_unsolicited_frame_control_get_header(&scic->uf_control,
325                                                                        frame_index,
326                                                                        (void **)&hdr);
327                 if (status != SCI_SUCCESS)
328                         return status;
329
330                 if (hdr->fis_type == FIS_SETDEVBITS &&
331                     (hdr->status & ATA_ERR)) {
332                         sci_dev->not_ready_reason = SCIC_REMOTE_DEVICE_NOT_READY_SATA_SDB_ERROR_FIS_RECEIVED;
333
334                         /* TODO Check sactive and complete associated IO if any. */
335                         sci_change_state(sm, SCI_STP_DEV_NCQ_ERROR);
336                 } else if (hdr->fis_type == FIS_REGD2H &&
337                            (hdr->status & ATA_ERR)) {
338                         /*
339                          * Some devices return D2H FIS when an NCQ error is detected.
340                          * Treat this like an SDB error FIS ready reason.
341                          */
342                         sci_dev->not_ready_reason = SCIC_REMOTE_DEVICE_NOT_READY_SATA_SDB_ERROR_FIS_RECEIVED;
343                         sci_change_state(&sci_dev->sm, SCI_STP_DEV_NCQ_ERROR);
344                 } else
345                         status = SCI_FAILURE;
346
347                 scic_sds_controller_release_frame(scic, frame_index);
348                 break;
349         }
350         case SCI_STP_DEV_CMD:
351         case SCI_SMP_DEV_CMD:
352                 /* The device does not process any UF received from the hardware while
353                  * in this state.  All unsolicited frames are forwarded to the io request
354                  * object.
355                  */
356                 status = scic_sds_io_request_frame_handler(sci_dev->working_request, frame_index);
357                 break;
358         }
359
360         return status;
361 }
362
363 static bool is_remote_device_ready(struct scic_sds_remote_device *sci_dev)
364 {
365
366         struct sci_base_state_machine *sm = &sci_dev->sm;
367         enum scic_sds_remote_device_states state = sm->current_state_id;
368
369         switch (state) {
370         case SCI_DEV_READY:
371         case SCI_STP_DEV_IDLE:
372         case SCI_STP_DEV_CMD:
373         case SCI_STP_DEV_NCQ:
374         case SCI_STP_DEV_NCQ_ERROR:
375         case SCI_STP_DEV_AWAIT_RESET:
376         case SCI_SMP_DEV_IDLE:
377         case SCI_SMP_DEV_CMD:
378                 return true;
379         default:
380                 return false;
381         }
382 }
383
384 enum sci_status scic_sds_remote_device_event_handler(struct scic_sds_remote_device *sci_dev,
385                                                      u32 event_code)
386 {
387         struct sci_base_state_machine *sm = &sci_dev->sm;
388         enum scic_sds_remote_device_states state = sm->current_state_id;
389         enum sci_status status;
390
391         switch (scu_get_event_type(event_code)) {
392         case SCU_EVENT_TYPE_RNC_OPS_MISC:
393         case SCU_EVENT_TYPE_RNC_SUSPEND_TX:
394         case SCU_EVENT_TYPE_RNC_SUSPEND_TX_RX:
395                 status = scic_sds_remote_node_context_event_handler(&sci_dev->rnc, event_code);
396                 break;
397         case SCU_EVENT_TYPE_PTX_SCHEDULE_EVENT:
398                 if (scu_get_event_code(event_code) == SCU_EVENT_IT_NEXUS_TIMEOUT) {
399                         status = SCI_SUCCESS;
400
401                         /* Suspend the associated RNC */
402                         scic_sds_remote_node_context_suspend(&sci_dev->rnc,
403                                                               SCI_SOFTWARE_SUSPENSION,
404                                                               NULL, NULL);
405
406                         dev_dbg(scirdev_to_dev(sci_dev),
407                                 "%s: device: %p event code: %x: %s\n",
408                                 __func__, sci_dev, event_code,
409                                 is_remote_device_ready(sci_dev)
410                                 ? "I_T_Nexus_Timeout event"
411                                 : "I_T_Nexus_Timeout event in wrong state");
412
413                         break;
414                 }
415         /* Else, fall through and treat as unhandled... */
416         default:
417                 dev_dbg(scirdev_to_dev(sci_dev),
418                         "%s: device: %p event code: %x: %s\n",
419                         __func__, sci_dev, event_code,
420                         is_remote_device_ready(sci_dev)
421                         ? "unexpected event"
422                         : "unexpected event in wrong state");
423                 status = SCI_FAILURE_INVALID_STATE;
424                 break;
425         }
426
427         if (status != SCI_SUCCESS)
428                 return status;
429
430         if (state == SCI_STP_DEV_IDLE) {
431
432                 /* We pick up suspension events to handle specifically to this
433                  * state. We resume the RNC right away.
434                  */
435                 if (scu_get_event_type(event_code) == SCU_EVENT_TYPE_RNC_SUSPEND_TX ||
436                     scu_get_event_type(event_code) == SCU_EVENT_TYPE_RNC_SUSPEND_TX_RX)
437                         status = scic_sds_remote_node_context_resume(&sci_dev->rnc, NULL, NULL);
438         }
439
440         return status;
441 }
442
443 static void scic_sds_remote_device_start_request(struct scic_sds_remote_device *sci_dev,
444                                                  struct scic_sds_request *sci_req,
445                                                  enum sci_status status)
446 {
447         struct scic_sds_port *sci_port = sci_dev->owning_port;
448
449         /* cleanup requests that failed after starting on the port */
450         if (status != SCI_SUCCESS)
451                 scic_sds_port_complete_io(sci_port, sci_dev, sci_req);
452         else
453                 scic_sds_remote_device_increment_request_count(sci_dev);
454 }
455
456 enum sci_status scic_sds_remote_device_start_io(struct scic_sds_controller *scic,
457                                                 struct scic_sds_remote_device *sci_dev,
458                                                 struct scic_sds_request *sci_req)
459 {
460         struct sci_base_state_machine *sm = &sci_dev->sm;
461         enum scic_sds_remote_device_states state = sm->current_state_id;
462         struct scic_sds_port *sci_port = sci_dev->owning_port;
463         struct isci_request *ireq = sci_req_to_ireq(sci_req);
464         enum sci_status status;
465
466         switch (state) {
467         case SCI_DEV_INITIAL:
468         case SCI_DEV_STOPPED:
469         case SCI_DEV_STARTING:
470         case SCI_STP_DEV_NCQ_ERROR:
471         case SCI_DEV_STOPPING:
472         case SCI_DEV_FAILED:
473         case SCI_DEV_RESETTING:
474         case SCI_DEV_FINAL:
475         default:
476                 dev_warn(scirdev_to_dev(sci_dev), "%s: in wrong state: %d\n",
477                          __func__, state);
478                 return SCI_FAILURE_INVALID_STATE;
479         case SCI_DEV_READY:
480                 /* attempt to start an io request for this device object. The remote
481                  * device object will issue the start request for the io and if
482                  * successful it will start the request for the port object then
483                  * increment its own request count.
484                  */
485                 status = scic_sds_port_start_io(sci_port, sci_dev, sci_req);
486                 if (status != SCI_SUCCESS)
487                         return status;
488
489                 status = scic_sds_remote_node_context_start_io(&sci_dev->rnc, sci_req);
490                 if (status != SCI_SUCCESS)
491                         break;
492
493                 status = scic_sds_request_start(sci_req);
494                 break;
495         case SCI_STP_DEV_IDLE: {
496                 /* handle the start io operation for a sata device that is in
497                  * the command idle state. - Evalute the type of IO request to
498                  * be started - If its an NCQ request change to NCQ substate -
499                  * If its any other command change to the CMD substate
500                  *
501                  * If this is a softreset we may want to have a different
502                  * substate.
503                  */
504                 enum scic_sds_remote_device_states new_state;
505                 struct sas_task *task = isci_request_access_task(ireq);
506
507                 status = scic_sds_port_start_io(sci_port, sci_dev, sci_req);
508                 if (status != SCI_SUCCESS)
509                         return status;
510
511                 status = scic_sds_remote_node_context_start_io(&sci_dev->rnc, sci_req);
512                 if (status != SCI_SUCCESS)
513                         break;
514
515                 status = scic_sds_request_start(sci_req);
516                 if (status != SCI_SUCCESS)
517                         break;
518
519                 if (task->ata_task.use_ncq)
520                         new_state = SCI_STP_DEV_NCQ;
521                 else {
522                         sci_dev->working_request = sci_req;
523                         new_state = SCI_STP_DEV_CMD;
524                 }
525                 sci_change_state(sm, new_state);
526                 break;
527         }
528         case SCI_STP_DEV_NCQ: {
529                 struct sas_task *task = isci_request_access_task(ireq);
530
531                 if (task->ata_task.use_ncq) {
532                         status = scic_sds_port_start_io(sci_port, sci_dev, sci_req);
533                         if (status != SCI_SUCCESS)
534                                 return status;
535
536                         status = scic_sds_remote_node_context_start_io(&sci_dev->rnc, sci_req);
537                         if (status != SCI_SUCCESS)
538                                 break;
539
540                         status = scic_sds_request_start(sci_req);
541                 } else
542                         return SCI_FAILURE_INVALID_STATE;
543                 break;
544         }
545         case SCI_STP_DEV_AWAIT_RESET:
546                 return SCI_FAILURE_REMOTE_DEVICE_RESET_REQUIRED;
547         case SCI_SMP_DEV_IDLE:
548                 status = scic_sds_port_start_io(sci_port, sci_dev, sci_req);
549                 if (status != SCI_SUCCESS)
550                         return status;
551
552                 status = scic_sds_remote_node_context_start_io(&sci_dev->rnc, sci_req);
553                 if (status != SCI_SUCCESS)
554                         break;
555
556                 status = scic_sds_request_start(sci_req);
557                 if (status != SCI_SUCCESS)
558                         break;
559
560                 sci_dev->working_request = sci_req;
561                 sci_change_state(&sci_dev->sm, SCI_SMP_DEV_CMD);
562                 break;
563         case SCI_STP_DEV_CMD:
564         case SCI_SMP_DEV_CMD:
565                 /* device is already handling a command it can not accept new commands
566                  * until this one is complete.
567                  */
568                 return SCI_FAILURE_INVALID_STATE;
569         }
570
571         scic_sds_remote_device_start_request(sci_dev, sci_req, status);
572         return status;
573 }
574
575 static enum sci_status common_complete_io(struct scic_sds_port *sci_port,
576                                           struct scic_sds_remote_device *sci_dev,
577                                           struct scic_sds_request *sci_req)
578 {
579         enum sci_status status;
580
581         status = scic_sds_request_complete(sci_req);
582         if (status != SCI_SUCCESS)
583                 return status;
584
585         status = scic_sds_port_complete_io(sci_port, sci_dev, sci_req);
586         if (status != SCI_SUCCESS)
587                 return status;
588
589         scic_sds_remote_device_decrement_request_count(sci_dev);
590         return status;
591 }
592
593 enum sci_status scic_sds_remote_device_complete_io(struct scic_sds_controller *scic,
594                                                    struct scic_sds_remote_device *sci_dev,
595                                                    struct scic_sds_request *sci_req)
596 {
597         struct sci_base_state_machine *sm = &sci_dev->sm;
598         enum scic_sds_remote_device_states state = sm->current_state_id;
599         struct scic_sds_port *sci_port = sci_dev->owning_port;
600         enum sci_status status;
601
602         switch (state) {
603         case SCI_DEV_INITIAL:
604         case SCI_DEV_STOPPED:
605         case SCI_DEV_STARTING:
606         case SCI_STP_DEV_IDLE:
607         case SCI_SMP_DEV_IDLE:
608         case SCI_DEV_FAILED:
609         case SCI_DEV_FINAL:
610         default:
611                 dev_warn(scirdev_to_dev(sci_dev), "%s: in wrong state: %d\n",
612                          __func__, state);
613                 return SCI_FAILURE_INVALID_STATE;
614         case SCI_DEV_READY:
615         case SCI_STP_DEV_AWAIT_RESET:
616         case SCI_DEV_RESETTING:
617                 status = common_complete_io(sci_port, sci_dev, sci_req);
618                 break;
619         case SCI_STP_DEV_CMD:
620         case SCI_STP_DEV_NCQ:
621         case SCI_STP_DEV_NCQ_ERROR:
622                 status = common_complete_io(sci_port, sci_dev, sci_req);
623                 if (status != SCI_SUCCESS)
624                         break;
625
626                 if (sci_req->sci_status == SCI_FAILURE_REMOTE_DEVICE_RESET_REQUIRED) {
627                         /* This request causes hardware error, device needs to be Lun Reset.
628                          * So here we force the state machine to IDLE state so the rest IOs
629                          * can reach RNC state handler, these IOs will be completed by RNC with
630                          * status of "DEVICE_RESET_REQUIRED", instead of "INVALID STATE".
631                          */
632                         sci_change_state(sm, SCI_STP_DEV_AWAIT_RESET);
633                 } else if (scic_sds_remote_device_get_request_count(sci_dev) == 0)
634                         sci_change_state(sm, SCI_STP_DEV_IDLE);
635                 break;
636         case SCI_SMP_DEV_CMD:
637                 status = common_complete_io(sci_port, sci_dev, sci_req);
638                 if (status != SCI_SUCCESS)
639                         break;
640                 sci_change_state(sm, SCI_SMP_DEV_IDLE);
641                 break;
642         case SCI_DEV_STOPPING:
643                 status = common_complete_io(sci_port, sci_dev, sci_req);
644                 if (status != SCI_SUCCESS)
645                         break;
646
647                 if (scic_sds_remote_device_get_request_count(sci_dev) == 0)
648                         scic_sds_remote_node_context_destruct(&sci_dev->rnc,
649                                                               rnc_destruct_done,
650                                                               sci_dev);
651                 break;
652         }
653
654         if (status != SCI_SUCCESS)
655                 dev_err(scirdev_to_dev(sci_dev),
656                         "%s: Port:0x%p Device:0x%p Request:0x%p Status:0x%x "
657                         "could not complete\n", __func__, sci_port,
658                         sci_dev, sci_req, status);
659
660         return status;
661 }
662
663 static void scic_sds_remote_device_continue_request(void *dev)
664 {
665         struct scic_sds_remote_device *sci_dev = dev;
666
667         /* we need to check if this request is still valid to continue. */
668         if (sci_dev->working_request)
669                 scic_controller_continue_io(sci_dev->working_request);
670 }
671
672 enum sci_status scic_sds_remote_device_start_task(struct scic_sds_controller *scic,
673                                                   struct scic_sds_remote_device *sci_dev,
674                                                   struct scic_sds_request *sci_req)
675 {
676         struct sci_base_state_machine *sm = &sci_dev->sm;
677         enum scic_sds_remote_device_states state = sm->current_state_id;
678         struct scic_sds_port *sci_port = sci_dev->owning_port;
679         enum sci_status status;
680
681         switch (state) {
682         case SCI_DEV_INITIAL:
683         case SCI_DEV_STOPPED:
684         case SCI_DEV_STARTING:
685         case SCI_SMP_DEV_IDLE:
686         case SCI_SMP_DEV_CMD:
687         case SCI_DEV_STOPPING:
688         case SCI_DEV_FAILED:
689         case SCI_DEV_RESETTING:
690         case SCI_DEV_FINAL:
691         default:
692                 dev_warn(scirdev_to_dev(sci_dev), "%s: in wrong state: %d\n",
693                          __func__, state);
694                 return SCI_FAILURE_INVALID_STATE;
695         case SCI_STP_DEV_IDLE:
696         case SCI_STP_DEV_CMD:
697         case SCI_STP_DEV_NCQ:
698         case SCI_STP_DEV_NCQ_ERROR:
699         case SCI_STP_DEV_AWAIT_RESET:
700                 status = scic_sds_port_start_io(sci_port, sci_dev, sci_req);
701                 if (status != SCI_SUCCESS)
702                         return status;
703
704                 status = scic_sds_remote_node_context_start_task(&sci_dev->rnc, sci_req);
705                 if (status != SCI_SUCCESS)
706                         goto out;
707
708                 status = scic_sds_request_start(sci_req);
709                 if (status != SCI_SUCCESS)
710                         goto out;
711
712                 /* Note: If the remote device state is not IDLE this will
713                  * replace the request that probably resulted in the task
714                  * management request.
715                  */
716                 sci_dev->working_request = sci_req;
717                 sci_change_state(sm, SCI_STP_DEV_CMD);
718
719                 /* The remote node context must cleanup the TCi to NCQ mapping
720                  * table.  The only way to do this correctly is to either write
721                  * to the TLCR register or to invalidate and repost the RNC. In
722                  * either case the remote node context state machine will take
723                  * the correct action when the remote node context is suspended
724                  * and later resumed.
725                  */
726                 scic_sds_remote_node_context_suspend(&sci_dev->rnc,
727                                 SCI_SOFTWARE_SUSPENSION, NULL, NULL);
728                 scic_sds_remote_node_context_resume(&sci_dev->rnc,
729                                 scic_sds_remote_device_continue_request,
730                                                     sci_dev);
731
732         out:
733                 scic_sds_remote_device_start_request(sci_dev, sci_req, status);
734                 /* We need to let the controller start request handler know that
735                  * it can't post TC yet. We will provide a callback function to
736                  * post TC when RNC gets resumed.
737                  */
738                 return SCI_FAILURE_RESET_DEVICE_PARTIAL_SUCCESS;
739         case SCI_DEV_READY:
740                 status = scic_sds_port_start_io(sci_port, sci_dev, sci_req);
741                 if (status != SCI_SUCCESS)
742                         return status;
743
744                 status = scic_sds_remote_node_context_start_task(&sci_dev->rnc, sci_req);
745                 if (status != SCI_SUCCESS)
746                         break;
747
748                 status = scic_sds_request_start(sci_req);
749                 break;
750         }
751         scic_sds_remote_device_start_request(sci_dev, sci_req, status);
752
753         return status;
754 }
755
756 /**
757  *
758  * @sci_dev:
759  * @request:
760  *
761  * This method takes the request and bulids an appropriate SCU context for the
762  * request and then requests the controller to post the request. none
763  */
764 void scic_sds_remote_device_post_request(
765         struct scic_sds_remote_device *sci_dev,
766         u32 request)
767 {
768         u32 context;
769
770         context = scic_sds_remote_device_build_command_context(sci_dev, request);
771
772         scic_sds_controller_post_request(
773                 scic_sds_remote_device_get_controller(sci_dev),
774                 context
775                 );
776 }
777
778 /* called once the remote node context has transisitioned to a
779  * ready state.  This is the indication that the remote device object can also
780  * transition to ready.
781  */
782 static void remote_device_resume_done(void *_dev)
783 {
784         struct scic_sds_remote_device *sci_dev = _dev;
785
786         if (is_remote_device_ready(sci_dev))
787                 return;
788
789         /* go 'ready' if we are not already in a ready state */
790         sci_change_state(&sci_dev->sm, SCI_DEV_READY);
791 }
792
793 static void scic_sds_stp_remote_device_ready_idle_substate_resume_complete_handler(void *_dev)
794 {
795         struct scic_sds_remote_device *sci_dev = _dev;
796         struct isci_remote_device *idev = sci_dev_to_idev(sci_dev);
797         struct scic_sds_controller *scic = sci_dev->owning_port->owning_controller;
798
799         /* For NCQ operation we do not issue a isci_remote_device_not_ready().
800          * As a result, avoid sending the ready notification.
801          */
802         if (sci_dev->sm.previous_state_id != SCI_STP_DEV_NCQ)
803                 isci_remote_device_ready(scic_to_ihost(scic), idev);
804 }
805
806 static void scic_sds_remote_device_initial_state_enter(struct sci_base_state_machine *sm)
807 {
808         struct scic_sds_remote_device *sci_dev = container_of(sm, typeof(*sci_dev), sm);
809
810         /* Initial state is a transitional state to the stopped state */
811         sci_change_state(&sci_dev->sm, SCI_DEV_STOPPED);
812 }
813
814 /**
815  * scic_remote_device_destruct() - free remote node context and destruct
816  * @remote_device: This parameter specifies the remote device to be destructed.
817  *
818  * Remote device objects are a limited resource.  As such, they must be
819  * protected.  Thus calls to construct and destruct are mutually exclusive and
820  * non-reentrant. The return value shall indicate if the device was
821  * successfully destructed or if some failure occurred. enum sci_status This value
822  * is returned if the device is successfully destructed.
823  * SCI_FAILURE_INVALID_REMOTE_DEVICE This value is returned if the supplied
824  * device isn't valid (e.g. it's already been destoryed, the handle isn't
825  * valid, etc.).
826  */
827 static enum sci_status scic_remote_device_destruct(struct scic_sds_remote_device *sci_dev)
828 {
829         struct sci_base_state_machine *sm = &sci_dev->sm;
830         enum scic_sds_remote_device_states state = sm->current_state_id;
831         struct scic_sds_controller *scic;
832
833         if (state != SCI_DEV_STOPPED) {
834                 dev_warn(scirdev_to_dev(sci_dev), "%s: in wrong state: %d\n",
835                          __func__, state);
836                 return SCI_FAILURE_INVALID_STATE;
837         }
838
839         scic = sci_dev->owning_port->owning_controller;
840         scic_sds_controller_free_remote_node_context(scic, sci_dev,
841                                                      sci_dev->rnc.remote_node_index);
842         sci_dev->rnc.remote_node_index = SCIC_SDS_REMOTE_NODE_CONTEXT_INVALID_INDEX;
843         sci_change_state(sm, SCI_DEV_FINAL);
844
845         return SCI_SUCCESS;
846 }
847
848 /**
849  * isci_remote_device_deconstruct() - This function frees an isci_remote_device.
850  * @ihost: This parameter specifies the isci host object.
851  * @idev: This parameter specifies the remote device to be freed.
852  *
853  */
854 static void isci_remote_device_deconstruct(struct isci_host *ihost, struct isci_remote_device *idev)
855 {
856         dev_dbg(&ihost->pdev->dev,
857                 "%s: isci_device = %p\n", __func__, idev);
858
859         /* There should not be any outstanding io's. All paths to
860          * here should go through isci_remote_device_nuke_requests.
861          * If we hit this condition, we will need a way to complete
862          * io requests in process */
863         while (!list_empty(&idev->reqs_in_process)) {
864
865                 dev_err(&ihost->pdev->dev,
866                         "%s: ** request list not empty! **\n", __func__);
867                 BUG();
868         }
869
870         scic_remote_device_destruct(&idev->sci);
871         idev->domain_dev->lldd_dev = NULL;
872         idev->domain_dev = NULL;
873         idev->isci_port = NULL;
874         list_del_init(&idev->node);
875
876         clear_bit(IDEV_START_PENDING, &idev->flags);
877         clear_bit(IDEV_STOP_PENDING, &idev->flags);
878         clear_bit(IDEV_EH, &idev->flags);
879         wake_up(&ihost->eventq);
880 }
881
882 /**
883  * isci_remote_device_stop_complete() - This function is called by the scic
884  *    when the remote device stop has completed. We mark the isci device as not
885  *    ready and remove the isci remote device.
886  * @ihost: This parameter specifies the isci host object.
887  * @idev: This parameter specifies the remote device.
888  * @status: This parameter specifies status of the completion.
889  *
890  */
891 static void isci_remote_device_stop_complete(struct isci_host *ihost,
892                                              struct isci_remote_device *idev)
893 {
894         dev_dbg(&ihost->pdev->dev, "%s: complete idev = %p\n", __func__, idev);
895
896         isci_remote_device_change_state(idev, isci_stopped);
897
898         /* after stop, we can tear down resources. */
899         isci_remote_device_deconstruct(ihost, idev);
900 }
901
902 static void scic_sds_remote_device_stopped_state_enter(struct sci_base_state_machine *sm)
903 {
904         struct scic_sds_remote_device *sci_dev = container_of(sm, typeof(*sci_dev), sm);
905         struct scic_sds_controller *scic = sci_dev->owning_port->owning_controller;
906         struct isci_remote_device *idev = sci_dev_to_idev(sci_dev);
907         u32 prev_state;
908
909         /* If we are entering from the stopping state let the SCI User know that
910          * the stop operation has completed.
911          */
912         prev_state = sci_dev->sm.previous_state_id;
913         if (prev_state == SCI_DEV_STOPPING)
914                 isci_remote_device_stop_complete(scic_to_ihost(scic), idev);
915
916         scic_sds_controller_remote_device_stopped(scic, sci_dev);
917 }
918
919 static void scic_sds_remote_device_starting_state_enter(struct sci_base_state_machine *sm)
920 {
921         struct scic_sds_remote_device *sci_dev = container_of(sm, typeof(*sci_dev), sm);
922         struct scic_sds_controller *scic = scic_sds_remote_device_get_controller(sci_dev);
923         struct isci_host *ihost = scic_to_ihost(scic);
924         struct isci_remote_device *idev = sci_dev_to_idev(sci_dev);
925
926         isci_remote_device_not_ready(ihost, idev,
927                                      SCIC_REMOTE_DEVICE_NOT_READY_START_REQUESTED);
928 }
929
930 static void scic_sds_remote_device_ready_state_enter(struct sci_base_state_machine *sm)
931 {
932         struct scic_sds_remote_device *sci_dev = container_of(sm, typeof(*sci_dev), sm);
933         struct scic_sds_controller *scic = sci_dev->owning_port->owning_controller;
934         struct isci_remote_device *idev = sci_dev_to_idev(sci_dev);
935         struct domain_device *dev = idev->domain_dev;
936
937         scic->remote_device_sequence[sci_dev->rnc.remote_node_index]++;
938
939         if (dev->dev_type == SATA_DEV || (dev->tproto & SAS_PROTOCOL_SATA)) {
940                 sci_change_state(&sci_dev->sm, SCI_STP_DEV_IDLE);
941         } else if (dev_is_expander(dev)) {
942                 sci_change_state(&sci_dev->sm, SCI_SMP_DEV_IDLE);
943         } else
944                 isci_remote_device_ready(scic_to_ihost(scic), idev);
945 }
946
947 static void scic_sds_remote_device_ready_state_exit(struct sci_base_state_machine *sm)
948 {
949         struct scic_sds_remote_device *sci_dev = container_of(sm, typeof(*sci_dev), sm);
950         struct domain_device *dev = sci_dev_to_domain(sci_dev);
951
952         if (dev->dev_type == SAS_END_DEV) {
953                 struct scic_sds_controller *scic = sci_dev->owning_port->owning_controller;
954                 struct isci_remote_device *idev = sci_dev_to_idev(sci_dev);
955
956                 isci_remote_device_not_ready(scic_to_ihost(scic), idev,
957                                              SCIC_REMOTE_DEVICE_NOT_READY_STOP_REQUESTED);
958         }
959 }
960
961 static void scic_sds_remote_device_resetting_state_enter(struct sci_base_state_machine *sm)
962 {
963         struct scic_sds_remote_device *sci_dev = container_of(sm, typeof(*sci_dev), sm);
964
965         scic_sds_remote_node_context_suspend(
966                 &sci_dev->rnc, SCI_SOFTWARE_SUSPENSION, NULL, NULL);
967 }
968
969 static void scic_sds_remote_device_resetting_state_exit(struct sci_base_state_machine *sm)
970 {
971         struct scic_sds_remote_device *sci_dev = container_of(sm, typeof(*sci_dev), sm);
972
973         scic_sds_remote_node_context_resume(&sci_dev->rnc, NULL, NULL);
974 }
975
976 static void scic_sds_stp_remote_device_ready_idle_substate_enter(struct sci_base_state_machine *sm)
977 {
978         struct scic_sds_remote_device *sci_dev = container_of(sm, typeof(*sci_dev), sm);
979
980         sci_dev->working_request = NULL;
981         if (scic_sds_remote_node_context_is_ready(&sci_dev->rnc)) {
982                 /*
983                  * Since the RNC is ready, it's alright to finish completion
984                  * processing (e.g. signal the remote device is ready). */
985                 scic_sds_stp_remote_device_ready_idle_substate_resume_complete_handler(sci_dev);
986         } else {
987                 scic_sds_remote_node_context_resume(&sci_dev->rnc,
988                         scic_sds_stp_remote_device_ready_idle_substate_resume_complete_handler,
989                         sci_dev);
990         }
991 }
992
993 static void scic_sds_stp_remote_device_ready_cmd_substate_enter(struct sci_base_state_machine *sm)
994 {
995         struct scic_sds_remote_device *sci_dev = container_of(sm, typeof(*sci_dev), sm);
996         struct scic_sds_controller *scic = scic_sds_remote_device_get_controller(sci_dev);
997
998         BUG_ON(sci_dev->working_request == NULL);
999
1000         isci_remote_device_not_ready(scic_to_ihost(scic), sci_dev_to_idev(sci_dev),
1001                                      SCIC_REMOTE_DEVICE_NOT_READY_SATA_REQUEST_STARTED);
1002 }
1003
1004 static void scic_sds_stp_remote_device_ready_ncq_error_substate_enter(struct sci_base_state_machine *sm)
1005 {
1006         struct scic_sds_remote_device *sci_dev = container_of(sm, typeof(*sci_dev), sm);
1007         struct scic_sds_controller *scic = scic_sds_remote_device_get_controller(sci_dev);
1008         struct isci_remote_device *idev = sci_dev_to_idev(sci_dev);
1009
1010         if (sci_dev->not_ready_reason == SCIC_REMOTE_DEVICE_NOT_READY_SATA_SDB_ERROR_FIS_RECEIVED)
1011                 isci_remote_device_not_ready(scic_to_ihost(scic), idev,
1012                                              sci_dev->not_ready_reason);
1013 }
1014
1015 static void scic_sds_smp_remote_device_ready_idle_substate_enter(struct sci_base_state_machine *sm)
1016 {
1017         struct scic_sds_remote_device *sci_dev = container_of(sm, typeof(*sci_dev), sm);
1018         struct scic_sds_controller *scic = scic_sds_remote_device_get_controller(sci_dev);
1019
1020         isci_remote_device_ready(scic_to_ihost(scic), sci_dev_to_idev(sci_dev));
1021 }
1022
1023 static void scic_sds_smp_remote_device_ready_cmd_substate_enter(struct sci_base_state_machine *sm)
1024 {
1025         struct scic_sds_remote_device *sci_dev = container_of(sm, typeof(*sci_dev), sm);
1026         struct scic_sds_controller *scic = scic_sds_remote_device_get_controller(sci_dev);
1027
1028         BUG_ON(sci_dev->working_request == NULL);
1029
1030         isci_remote_device_not_ready(scic_to_ihost(scic), sci_dev_to_idev(sci_dev),
1031                                      SCIC_REMOTE_DEVICE_NOT_READY_SMP_REQUEST_STARTED);
1032 }
1033
1034 static void scic_sds_smp_remote_device_ready_cmd_substate_exit(struct sci_base_state_machine *sm)
1035 {
1036         struct scic_sds_remote_device *sci_dev = container_of(sm, typeof(*sci_dev), sm);
1037
1038         sci_dev->working_request = NULL;
1039 }
1040
1041 static const struct sci_base_state scic_sds_remote_device_state_table[] = {
1042         [SCI_DEV_INITIAL] = {
1043                 .enter_state = scic_sds_remote_device_initial_state_enter,
1044         },
1045         [SCI_DEV_STOPPED] = {
1046                 .enter_state = scic_sds_remote_device_stopped_state_enter,
1047         },
1048         [SCI_DEV_STARTING] = {
1049                 .enter_state = scic_sds_remote_device_starting_state_enter,
1050         },
1051         [SCI_DEV_READY] = {
1052                 .enter_state = scic_sds_remote_device_ready_state_enter,
1053                 .exit_state  = scic_sds_remote_device_ready_state_exit
1054         },
1055         [SCI_STP_DEV_IDLE] = {
1056                 .enter_state = scic_sds_stp_remote_device_ready_idle_substate_enter,
1057         },
1058         [SCI_STP_DEV_CMD] = {
1059                 .enter_state = scic_sds_stp_remote_device_ready_cmd_substate_enter,
1060         },
1061         [SCI_STP_DEV_NCQ] = { },
1062         [SCI_STP_DEV_NCQ_ERROR] = {
1063                 .enter_state = scic_sds_stp_remote_device_ready_ncq_error_substate_enter,
1064         },
1065         [SCI_STP_DEV_AWAIT_RESET] = { },
1066         [SCI_SMP_DEV_IDLE] = {
1067                 .enter_state = scic_sds_smp_remote_device_ready_idle_substate_enter,
1068         },
1069         [SCI_SMP_DEV_CMD] = {
1070                 .enter_state = scic_sds_smp_remote_device_ready_cmd_substate_enter,
1071                 .exit_state  = scic_sds_smp_remote_device_ready_cmd_substate_exit,
1072         },
1073         [SCI_DEV_STOPPING] = { },
1074         [SCI_DEV_FAILED] = { },
1075         [SCI_DEV_RESETTING] = {
1076                 .enter_state = scic_sds_remote_device_resetting_state_enter,
1077                 .exit_state  = scic_sds_remote_device_resetting_state_exit
1078         },
1079         [SCI_DEV_FINAL] = { },
1080 };
1081
1082 /**
1083  * scic_remote_device_construct() - common construction
1084  * @sci_port: SAS/SATA port through which this device is accessed.
1085  * @sci_dev: remote device to construct
1086  *
1087  * This routine just performs benign initialization and does not
1088  * allocate the remote_node_context which is left to
1089  * scic_remote_device_[de]a_construct().  scic_remote_device_destruct()
1090  * frees the remote_node_context(s) for the device.
1091  */
1092 static void scic_remote_device_construct(struct scic_sds_port *sci_port,
1093                                   struct scic_sds_remote_device *sci_dev)
1094 {
1095         sci_dev->owning_port = sci_port;
1096         sci_dev->started_request_count = 0;
1097
1098         sci_init_sm(&sci_dev->sm, scic_sds_remote_device_state_table, SCI_DEV_INITIAL);
1099
1100         scic_sds_remote_node_context_construct(&sci_dev->rnc,
1101                                                SCIC_SDS_REMOTE_NODE_CONTEXT_INVALID_INDEX);
1102 }
1103
1104 /**
1105  * scic_remote_device_da_construct() - construct direct attached device.
1106  *
1107  * The information (e.g. IAF, Signature FIS, etc.) necessary to build
1108  * the device is known to the SCI Core since it is contained in the
1109  * scic_phy object.  Remote node context(s) is/are a global resource
1110  * allocated by this routine, freed by scic_remote_device_destruct().
1111  *
1112  * Returns:
1113  * SCI_FAILURE_DEVICE_EXISTS - device has already been constructed.
1114  * SCI_FAILURE_UNSUPPORTED_PROTOCOL - e.g. sas device attached to
1115  * sata-only controller instance.
1116  * SCI_FAILURE_INSUFFICIENT_RESOURCES - remote node contexts exhausted.
1117  */
1118 static enum sci_status scic_remote_device_da_construct(struct scic_sds_port *sci_port,
1119                                                        struct scic_sds_remote_device *sci_dev)
1120 {
1121         enum sci_status status;
1122         struct domain_device *dev = sci_dev_to_domain(sci_dev);
1123
1124         scic_remote_device_construct(sci_port, sci_dev);
1125
1126         /*
1127          * This information is request to determine how many remote node context
1128          * entries will be needed to store the remote node.
1129          */
1130         sci_dev->is_direct_attached = true;
1131         status = scic_sds_controller_allocate_remote_node_context(sci_port->owning_controller,
1132                                                                   sci_dev,
1133                                                                   &sci_dev->rnc.remote_node_index);
1134
1135         if (status != SCI_SUCCESS)
1136                 return status;
1137
1138         if (dev->dev_type == SAS_END_DEV || dev->dev_type == SATA_DEV ||
1139             (dev->tproto & SAS_PROTOCOL_STP) || dev_is_expander(dev))
1140                 /* pass */;
1141         else
1142                 return SCI_FAILURE_UNSUPPORTED_PROTOCOL;
1143
1144         sci_dev->connection_rate = scic_sds_port_get_max_allowed_speed(sci_port);
1145
1146         /* / @todo Should I assign the port width by reading all of the phys on the port? */
1147         sci_dev->device_port_width = 1;
1148
1149         return SCI_SUCCESS;
1150 }
1151
1152 /**
1153  * scic_remote_device_ea_construct() - construct expander attached device
1154  *
1155  * Remote node context(s) is/are a global resource allocated by this
1156  * routine, freed by scic_remote_device_destruct().
1157  *
1158  * Returns:
1159  * SCI_FAILURE_DEVICE_EXISTS - device has already been constructed.
1160  * SCI_FAILURE_UNSUPPORTED_PROTOCOL - e.g. sas device attached to
1161  * sata-only controller instance.
1162  * SCI_FAILURE_INSUFFICIENT_RESOURCES - remote node contexts exhausted.
1163  */
1164 static enum sci_status scic_remote_device_ea_construct(struct scic_sds_port *sci_port,
1165                                                        struct scic_sds_remote_device *sci_dev)
1166 {
1167         struct domain_device *dev = sci_dev_to_domain(sci_dev);
1168         enum sci_status status;
1169
1170         scic_remote_device_construct(sci_port, sci_dev);
1171
1172         status = scic_sds_controller_allocate_remote_node_context(sci_port->owning_controller,
1173                                                                   sci_dev,
1174                                                                   &sci_dev->rnc.remote_node_index);
1175         if (status != SCI_SUCCESS)
1176                 return status;
1177
1178         if (dev->dev_type == SAS_END_DEV || dev->dev_type == SATA_DEV ||
1179             (dev->tproto & SAS_PROTOCOL_STP) || dev_is_expander(dev))
1180                 /* pass */;
1181         else
1182                 return SCI_FAILURE_UNSUPPORTED_PROTOCOL;
1183
1184         /*
1185          * For SAS-2 the physical link rate is actually a logical link
1186          * rate that incorporates multiplexing.  The SCU doesn't
1187          * incorporate multiplexing and for the purposes of the
1188          * connection the logical link rate is that same as the
1189          * physical.  Furthermore, the SAS-2 and SAS-1.1 fields overlay
1190          * one another, so this code works for both situations. */
1191         sci_dev->connection_rate = min_t(u16, scic_sds_port_get_max_allowed_speed(sci_port),
1192                                          dev->linkrate);
1193
1194         /* / @todo Should I assign the port width by reading all of the phys on the port? */
1195         sci_dev->device_port_width = 1;
1196
1197         return SCI_SUCCESS;
1198 }
1199
1200 /**
1201  * scic_remote_device_start() - This method will start the supplied remote
1202  *    device.  This method enables normal IO requests to flow through to the
1203  *    remote device.
1204  * @remote_device: This parameter specifies the device to be started.
1205  * @timeout: This parameter specifies the number of milliseconds in which the
1206  *    start operation should complete.
1207  *
1208  * An indication of whether the device was successfully started. SCI_SUCCESS
1209  * This value is returned if the device was successfully started.
1210  * SCI_FAILURE_INVALID_PHY This value is returned if the user attempts to start
1211  * the device when there have been no phys added to it.
1212  */
1213 static enum sci_status scic_remote_device_start(struct scic_sds_remote_device *sci_dev,
1214                                                 u32 timeout)
1215 {
1216         struct sci_base_state_machine *sm = &sci_dev->sm;
1217         enum scic_sds_remote_device_states state = sm->current_state_id;
1218         enum sci_status status;
1219
1220         if (state != SCI_DEV_STOPPED) {
1221                 dev_warn(scirdev_to_dev(sci_dev), "%s: in wrong state: %d\n",
1222                          __func__, state);
1223                 return SCI_FAILURE_INVALID_STATE;
1224         }
1225
1226         status = scic_sds_remote_node_context_resume(&sci_dev->rnc,
1227                                                      remote_device_resume_done,
1228                                                      sci_dev);
1229         if (status != SCI_SUCCESS)
1230                 return status;
1231
1232         sci_change_state(sm, SCI_DEV_STARTING);
1233
1234         return SCI_SUCCESS;
1235 }
1236
1237 static enum sci_status isci_remote_device_construct(struct isci_port *iport,
1238                                                     struct isci_remote_device *idev)
1239 {
1240         struct scic_sds_port *sci_port = &iport->sci;
1241         struct isci_host *ihost = iport->isci_host;
1242         struct domain_device *dev = idev->domain_dev;
1243         enum sci_status status;
1244
1245         if (dev->parent && dev_is_expander(dev->parent))
1246                 status = scic_remote_device_ea_construct(sci_port, &idev->sci);
1247         else
1248                 status = scic_remote_device_da_construct(sci_port, &idev->sci);
1249
1250         if (status != SCI_SUCCESS) {
1251                 dev_dbg(&ihost->pdev->dev, "%s: construct failed: %d\n",
1252                         __func__, status);
1253
1254                 return status;
1255         }
1256
1257         /* start the device. */
1258         status = scic_remote_device_start(&idev->sci, ISCI_REMOTE_DEVICE_START_TIMEOUT);
1259
1260         if (status != SCI_SUCCESS)
1261                 dev_warn(&ihost->pdev->dev, "remote device start failed: %d\n",
1262                          status);
1263
1264         return status;
1265 }
1266
1267 void isci_remote_device_nuke_requests(struct isci_host *ihost, struct isci_remote_device *idev)
1268 {
1269         DECLARE_COMPLETION_ONSTACK(aborted_task_completion);
1270
1271         dev_dbg(&ihost->pdev->dev,
1272                 "%s: idev = %p\n", __func__, idev);
1273
1274         /* Cleanup all requests pending for this device. */
1275         isci_terminate_pending_requests(ihost, idev, terminating);
1276
1277         dev_dbg(&ihost->pdev->dev,
1278                 "%s: idev = %p, done\n", __func__, idev);
1279 }
1280
1281 /**
1282  * This function builds the isci_remote_device when a libsas dev_found message
1283  *    is received.
1284  * @isci_host: This parameter specifies the isci host object.
1285  * @port: This parameter specifies the isci_port conected to this device.
1286  *
1287  * pointer to new isci_remote_device.
1288  */
1289 static struct isci_remote_device *
1290 isci_remote_device_alloc(struct isci_host *ihost, struct isci_port *iport)
1291 {
1292         struct isci_remote_device *idev;
1293         int i;
1294
1295         for (i = 0; i < SCI_MAX_REMOTE_DEVICES; i++) {
1296                 idev = &ihost->devices[i];
1297                 if (!test_and_set_bit(IDEV_ALLOCATED, &idev->flags))
1298                         break;
1299         }
1300
1301         if (i >= SCI_MAX_REMOTE_DEVICES) {
1302                 dev_warn(&ihost->pdev->dev, "%s: failed\n", __func__);
1303                 return NULL;
1304         }
1305
1306         if (WARN_ONCE(!list_empty(&idev->reqs_in_process), "found requests in process\n"))
1307                 return NULL;
1308
1309         if (WARN_ONCE(!list_empty(&idev->node), "found non-idle remote device\n"))
1310                 return NULL;
1311
1312         isci_remote_device_change_state(idev, isci_freed);
1313
1314         return idev;
1315 }
1316
1317 /**
1318  * isci_remote_device_stop() - This function is called internally to stop the
1319  *    remote device.
1320  * @isci_host: This parameter specifies the isci host object.
1321  * @isci_device: This parameter specifies the remote device.
1322  *
1323  * The status of the scic request to stop.
1324  */
1325 enum sci_status isci_remote_device_stop(struct isci_host *ihost, struct isci_remote_device *idev)
1326 {
1327         enum sci_status status;
1328         unsigned long flags;
1329
1330         dev_dbg(&ihost->pdev->dev,
1331                 "%s: isci_device = %p\n", __func__, idev);
1332
1333         isci_remote_device_change_state(idev, isci_stopping);
1334
1335         /* Kill all outstanding requests. */
1336         isci_remote_device_nuke_requests(ihost, idev);
1337
1338         set_bit(IDEV_STOP_PENDING, &idev->flags);
1339
1340         spin_lock_irqsave(&ihost->scic_lock, flags);
1341         status = scic_remote_device_stop(&idev->sci, 50);
1342         spin_unlock_irqrestore(&ihost->scic_lock, flags);
1343
1344         /* Wait for the stop complete callback. */
1345         if (status == SCI_SUCCESS) {
1346                 wait_for_device_stop(ihost, idev);
1347                 clear_bit(IDEV_ALLOCATED, &idev->flags);
1348         }
1349
1350         dev_dbg(&ihost->pdev->dev,
1351                 "%s: idev = %p - after completion wait\n",
1352                 __func__, idev);
1353
1354         return status;
1355 }
1356
1357 /**
1358  * isci_remote_device_gone() - This function is called by libsas when a domain
1359  *    device is removed.
1360  * @domain_device: This parameter specifies the libsas domain device.
1361  *
1362  */
1363 void isci_remote_device_gone(struct domain_device *dev)
1364 {
1365         struct isci_host *ihost = dev_to_ihost(dev);
1366         struct isci_remote_device *idev = dev->lldd_dev;
1367
1368         dev_dbg(&ihost->pdev->dev,
1369                 "%s: domain_device = %p, isci_device = %p, isci_port = %p\n",
1370                 __func__, dev, idev, idev->isci_port);
1371
1372         isci_remote_device_stop(ihost, idev);
1373 }
1374
1375
1376 /**
1377  * isci_remote_device_found() - This function is called by libsas when a remote
1378  *    device is discovered. A remote device object is created and started. the
1379  *    function then sleeps until the sci core device started message is
1380  *    received.
1381  * @domain_device: This parameter specifies the libsas domain device.
1382  *
1383  * status, zero indicates success.
1384  */
1385 int isci_remote_device_found(struct domain_device *domain_dev)
1386 {
1387         struct isci_host *isci_host = dev_to_ihost(domain_dev);
1388         struct isci_port *isci_port;
1389         struct isci_phy *isci_phy;
1390         struct asd_sas_port *sas_port;
1391         struct asd_sas_phy *sas_phy;
1392         struct isci_remote_device *isci_device;
1393         enum sci_status status;
1394
1395         dev_dbg(&isci_host->pdev->dev,
1396                 "%s: domain_device = %p\n", __func__, domain_dev);
1397
1398         wait_for_start(isci_host);
1399
1400         sas_port = domain_dev->port;
1401         sas_phy = list_first_entry(&sas_port->phy_list, struct asd_sas_phy,
1402                                    port_phy_el);
1403         isci_phy = to_isci_phy(sas_phy);
1404         isci_port = isci_phy->isci_port;
1405
1406         /* we are being called for a device on this port,
1407          * so it has to come up eventually
1408          */
1409         wait_for_completion(&isci_port->start_complete);
1410
1411         if ((isci_stopping == isci_port_get_state(isci_port)) ||
1412             (isci_stopped == isci_port_get_state(isci_port)))
1413                 return -ENODEV;
1414
1415         isci_device = isci_remote_device_alloc(isci_host, isci_port);
1416         if (!isci_device)
1417                 return -ENODEV;
1418
1419         INIT_LIST_HEAD(&isci_device->node);
1420         domain_dev->lldd_dev = isci_device;
1421         isci_device->domain_dev = domain_dev;
1422         isci_device->isci_port = isci_port;
1423         isci_remote_device_change_state(isci_device, isci_starting);
1424
1425
1426         spin_lock_irq(&isci_host->scic_lock);
1427         list_add_tail(&isci_device->node, &isci_port->remote_dev_list);
1428
1429         set_bit(IDEV_START_PENDING, &isci_device->flags);
1430         status = isci_remote_device_construct(isci_port, isci_device);
1431         spin_unlock_irq(&isci_host->scic_lock);
1432
1433         dev_dbg(&isci_host->pdev->dev,
1434                 "%s: isci_device = %p\n",
1435                 __func__, isci_device);
1436
1437         if (status != SCI_SUCCESS) {
1438
1439                 spin_lock_irq(&isci_host->scic_lock);
1440                 isci_remote_device_deconstruct(
1441                         isci_host,
1442                         isci_device
1443                         );
1444                 spin_unlock_irq(&isci_host->scic_lock);
1445                 return -ENODEV;
1446         }
1447
1448         /* wait for the device ready callback. */
1449         wait_for_device_start(isci_host, isci_device);
1450
1451         return 0;
1452 }
1453 /**
1454  * isci_device_is_reset_pending() - This function will check if there is any
1455  *    pending reset condition on the device.
1456  * @request: This parameter is the isci_device object.
1457  *
1458  * true if there is a reset pending for the device.
1459  */
1460 bool isci_device_is_reset_pending(
1461         struct isci_host *isci_host,
1462         struct isci_remote_device *isci_device)
1463 {
1464         struct isci_request *isci_request;
1465         struct isci_request *tmp_req;
1466         bool reset_is_pending = false;
1467         unsigned long flags;
1468
1469         dev_dbg(&isci_host->pdev->dev,
1470                 "%s: isci_device = %p\n", __func__, isci_device);
1471
1472         spin_lock_irqsave(&isci_host->scic_lock, flags);
1473
1474         /* Check for reset on all pending requests. */
1475         list_for_each_entry_safe(isci_request, tmp_req,
1476                                  &isci_device->reqs_in_process, dev_node) {
1477                 dev_dbg(&isci_host->pdev->dev,
1478                         "%s: isci_device = %p request = %p\n",
1479                         __func__, isci_device, isci_request);
1480
1481                 if (isci_request->ttype == io_task) {
1482                         struct sas_task *task = isci_request_access_task(
1483                                 isci_request);
1484
1485                         spin_lock(&task->task_state_lock);
1486                         if (task->task_state_flags & SAS_TASK_NEED_DEV_RESET)
1487                                 reset_is_pending = true;
1488                         spin_unlock(&task->task_state_lock);
1489                 }
1490         }
1491
1492         spin_unlock_irqrestore(&isci_host->scic_lock, flags);
1493
1494         dev_dbg(&isci_host->pdev->dev,
1495                 "%s: isci_device = %p reset_is_pending = %d\n",
1496                 __func__, isci_device, reset_is_pending);
1497
1498         return reset_is_pending;
1499 }
1500
1501 /**
1502  * isci_device_clear_reset_pending() - This function will clear if any pending
1503  *    reset condition flags on the device.
1504  * @request: This parameter is the isci_device object.
1505  *
1506  * true if there is a reset pending for the device.
1507  */
1508 void isci_device_clear_reset_pending(struct isci_host *ihost, struct isci_remote_device *idev)
1509 {
1510         struct isci_request *isci_request;
1511         struct isci_request *tmp_req;
1512         unsigned long flags = 0;
1513
1514         dev_dbg(&ihost->pdev->dev, "%s: idev=%p, ihost=%p\n",
1515                  __func__, idev, ihost);
1516
1517         spin_lock_irqsave(&ihost->scic_lock, flags);
1518
1519         /* Clear reset pending on all pending requests. */
1520         list_for_each_entry_safe(isci_request, tmp_req,
1521                                  &idev->reqs_in_process, dev_node) {
1522                 dev_dbg(&ihost->pdev->dev, "%s: idev = %p request = %p\n",
1523                          __func__, idev, isci_request);
1524
1525                 if (isci_request->ttype == io_task) {
1526
1527                         unsigned long flags2;
1528                         struct sas_task *task = isci_request_access_task(
1529                                 isci_request);
1530
1531                         spin_lock_irqsave(&task->task_state_lock, flags2);
1532                         task->task_state_flags &= ~SAS_TASK_NEED_DEV_RESET;
1533                         spin_unlock_irqrestore(&task->task_state_lock, flags2);
1534                 }
1535         }
1536         spin_unlock_irqrestore(&ihost->scic_lock, flags);
1537 }