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