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 #ifndef _ISCI_TASK_H_ 56 #define _ISCI_TASK_H_ 57 58 #include <scsi/sas_ata.h> 59 #include "host.h" 60 61 #define ISCI_TERMINATION_TIMEOUT_MSEC 500 62 63 struct isci_request; 64 65 /** 66 * enum isci_tmf_cb_state - This enum defines the possible states in which the 67 * TMF callback function is invoked during the TMF execution process. 68 * 69 * 70 */ 71 enum isci_tmf_cb_state { 72 73 isci_tmf_init_state = 0, 74 isci_tmf_started, 75 isci_tmf_timed_out 76 }; 77 78 /** 79 * enum isci_tmf_function_codes - This enum defines the possible preparations 80 * of task management requests. 81 * 82 * 83 */ 84 enum isci_tmf_function_codes { 85 86 isci_tmf_func_none = 0, 87 isci_tmf_ssp_task_abort = TMF_ABORT_TASK, 88 isci_tmf_ssp_lun_reset = TMF_LU_RESET, 89 isci_tmf_sata_srst_high = TMF_LU_RESET + 0x100, /* Non SCSI */ 90 isci_tmf_sata_srst_low = TMF_LU_RESET + 0x101 /* Non SCSI */ 91 }; 92 /** 93 * struct isci_tmf - This class represents the task management object which 94 * acts as an interface to libsas for processing task management requests 95 * 96 * 97 */ 98 struct isci_tmf { 99 100 struct completion *complete; 101 enum sas_protocol proto; 102 union { 103 struct ssp_response_iu resp_iu; 104 struct dev_to_host_fis d2h_fis; 105 u8 rsp_buf[SSP_RESP_IU_MAX_SIZE]; 106 } resp; 107 unsigned char lun[8]; 108 u16 io_tag; 109 enum isci_tmf_function_codes tmf_code; 110 int status; 111 112 /* The optional callback function allows the user process to 113 * track the TMF transmit / timeout conditions. 114 */ 115 void (*cb_state_func)( 116 enum isci_tmf_cb_state, 117 struct isci_tmf *, void *); 118 void *cb_data; 119 120 }; 121 122 static inline void isci_print_tmf(struct isci_host *ihost, struct isci_tmf *tmf) 123 { 124 if (SAS_PROTOCOL_SATA == tmf->proto) 125 dev_dbg(&ihost->pdev->dev, 126 "%s: status = %x\n" 127 "tmf->resp.d2h_fis.status = %x\n" 128 "tmf->resp.d2h_fis.error = %x\n", 129 __func__, 130 tmf->status, 131 tmf->resp.d2h_fis.status, 132 tmf->resp.d2h_fis.error); 133 else 134 dev_dbg(&ihost->pdev->dev, 135 "%s: status = %x\n" 136 "tmf->resp.resp_iu.data_present = %x\n" 137 "tmf->resp.resp_iu.status = %x\n" 138 "tmf->resp.resp_iu.data_length = %x\n" 139 "tmf->resp.resp_iu.data[0] = %x\n" 140 "tmf->resp.resp_iu.data[1] = %x\n" 141 "tmf->resp.resp_iu.data[2] = %x\n" 142 "tmf->resp.resp_iu.data[3] = %x\n", 143 __func__, 144 tmf->status, 145 tmf->resp.resp_iu.datapres, 146 tmf->resp.resp_iu.status, 147 be32_to_cpu(tmf->resp.resp_iu.response_data_len), 148 tmf->resp.resp_iu.resp_data[0], 149 tmf->resp.resp_iu.resp_data[1], 150 tmf->resp.resp_iu.resp_data[2], 151 tmf->resp.resp_iu.resp_data[3]); 152 } 153 154 155 int isci_task_execute_task( 156 struct sas_task *task, 157 int num, 158 gfp_t gfp_flags); 159 160 int isci_task_abort_task( 161 struct sas_task *task); 162 163 int isci_task_abort_task_set( 164 struct domain_device *d_device, 165 u8 *lun); 166 167 int isci_task_clear_aca( 168 struct domain_device *d_device, 169 u8 *lun); 170 171 int isci_task_clear_task_set( 172 struct domain_device *d_device, 173 u8 *lun); 174 175 int isci_task_query_task( 176 struct sas_task *task); 177 178 int isci_task_lu_reset( 179 struct domain_device *d_device, 180 u8 *lun); 181 182 int isci_task_clear_nexus_port( 183 struct asd_sas_port *port); 184 185 int isci_task_clear_nexus_ha( 186 struct sas_ha_struct *ha); 187 188 int isci_task_I_T_nexus_reset( 189 struct domain_device *d_device); 190 191 void isci_task_request_complete( 192 struct isci_host *isci_host, 193 struct isci_request *request, 194 enum sci_task_status completion_status); 195 196 u16 isci_task_ssp_request_get_io_tag_to_manage( 197 struct isci_request *request); 198 199 u8 isci_task_ssp_request_get_function( 200 struct isci_request *request); 201 202 203 void *isci_task_ssp_request_get_response_data_address( 204 struct isci_request *request); 205 206 u32 isci_task_ssp_request_get_response_data_length( 207 struct isci_request *request); 208 209 int isci_queuecommand( 210 struct scsi_cmnd *scsi_cmd, 211 void (*donefunc)(struct scsi_cmnd *)); 212 213 int isci_bus_reset_handler(struct scsi_cmnd *cmd); 214 215 /** 216 * enum isci_completion_selection - This enum defines the possible actions to 217 * take with respect to a given request's notification back to libsas. 218 * 219 * 220 */ 221 enum isci_completion_selection { 222 223 isci_perform_normal_io_completion, /* Normal notify (task_done) */ 224 isci_perform_aborted_io_completion, /* No notification. */ 225 isci_perform_error_io_completion /* Use sas_task_abort */ 226 }; 227 228 /** 229 * isci_task_set_completion_status() - This function sets the completion status 230 * for the request. 231 * @task: This parameter is the completed request. 232 * @response: This parameter is the response code for the completed task. 233 * @status: This parameter is the status code for the completed task. 234 * 235 * @return The new notification mode for the request. 236 */ 237 static inline enum isci_completion_selection 238 isci_task_set_completion_status( 239 struct sas_task *task, 240 enum service_response response, 241 enum exec_status status, 242 enum isci_completion_selection task_notification_selection) 243 { 244 unsigned long flags; 245 246 spin_lock_irqsave(&task->task_state_lock, flags); 247 248 /* If a device reset is being indicated, make sure the I/O 249 * is in the error path. 250 */ 251 if (task->task_state_flags & SAS_TASK_NEED_DEV_RESET) { 252 /* Fail the I/O to make sure it goes into the error path. */ 253 response = SAS_TASK_UNDELIVERED; 254 status = SAM_STAT_TASK_ABORTED; 255 256 task_notification_selection = isci_perform_error_io_completion; 257 } 258 task->task_status.resp = response; 259 task->task_status.stat = status; 260 261 switch (task->task_proto) { 262 263 case SAS_PROTOCOL_SATA: 264 case SAS_PROTOCOL_STP: 265 case SAS_PROTOCOL_SATA | SAS_PROTOCOL_STP: 266 267 if (task_notification_selection 268 == isci_perform_error_io_completion) { 269 /* SATA/STP I/O has it's own means of scheduling device 270 * error handling on the normal path. 271 */ 272 task_notification_selection 273 = isci_perform_normal_io_completion; 274 } 275 break; 276 default: 277 break; 278 } 279 280 switch (task_notification_selection) { 281 282 case isci_perform_error_io_completion: 283 284 if (task->task_proto == SAS_PROTOCOL_SMP) { 285 /* There is no error escalation in the SMP case. 286 * Convert to a normal completion to avoid the 287 * timeout in the discovery path and to let the 288 * next action take place quickly. 289 */ 290 task_notification_selection 291 = isci_perform_normal_io_completion; 292 293 /* Fall through to the normal case... */ 294 } else { 295 /* Use sas_task_abort */ 296 /* Leave SAS_TASK_STATE_DONE clear 297 * Leave SAS_TASK_AT_INITIATOR set. 298 */ 299 break; 300 } 301 302 case isci_perform_aborted_io_completion: 303 /* This path can occur with task-managed requests as well as 304 * requests terminated because of LUN or device resets. 305 */ 306 /* Fall through to the normal case... */ 307 case isci_perform_normal_io_completion: 308 /* Normal notification (task_done) */ 309 task->task_state_flags |= SAS_TASK_STATE_DONE; 310 task->task_state_flags &= ~(SAS_TASK_AT_INITIATOR | 311 SAS_TASK_STATE_PENDING); 312 break; 313 default: 314 WARN_ONCE(1, "unknown task_notification_selection: %d\n", 315 task_notification_selection); 316 break; 317 } 318 319 spin_unlock_irqrestore(&task->task_state_lock, flags); 320 321 return task_notification_selection; 322 323 } 324 /** 325 * isci_execpath_callback() - This function is called from the task 326 * execute path when the task needs to callback libsas about the submit-time 327 * task failure. The callback occurs either through the task's done function 328 * or through sas_task_abort. In the case of regular non-discovery SATA/STP I/O 329 * requests, libsas takes the host lock before calling execute task. Therefore 330 * in this situation the host lock must be managed before calling the func. 331 * 332 * @ihost: This parameter is the controller to which the I/O request was sent. 333 * @task: This parameter is the I/O request. 334 * @func: This parameter is the function to call in the correct context. 335 * @status: This parameter is the status code for the completed task. 336 * 337 */ 338 static inline void isci_execpath_callback(struct isci_host *ihost, 339 struct sas_task *task, 340 void (*func)(struct sas_task *)) 341 { 342 struct domain_device *dev = task->dev; 343 344 if (dev_is_sata(dev) && task->uldd_task) { 345 unsigned long flags; 346 347 /* Since we are still in the submit path, and since 348 * libsas takes the host lock on behalf of SATA 349 * devices before I/O starts (in the non-discovery case), 350 * we need to unlock before we can call the callback function. 351 */ 352 raw_local_irq_save(flags); 353 spin_unlock(dev->sata_dev.ap->lock); 354 func(task); 355 spin_lock(dev->sata_dev.ap->lock); 356 raw_local_irq_restore(flags); 357 } else 358 func(task); 359 } 360 #endif /* !defined(_SCI_TASK_H_) */ 361