1 /* 2 * Aic94xx Task Management Functions 3 * 4 * Copyright (C) 2005 Adaptec, Inc. All rights reserved. 5 * Copyright (C) 2005 Luben Tuikov <luben_tuikov@adaptec.com> 6 * 7 * This file is licensed under GPLv2. 8 * 9 * This file is part of the aic94xx driver. 10 * 11 * The aic94xx driver is free software; you can redistribute it and/or 12 * modify it under the terms of the GNU General Public License as 13 * published by the Free Software Foundation; version 2 of the 14 * License. 15 * 16 * The aic94xx driver is distributed in the hope that it will be useful, 17 * but WITHOUT ANY WARRANTY; without even the implied warranty of 18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 19 * General Public License for more details. 20 * 21 * You should have received a copy of the GNU General Public License 22 * along with the aic94xx driver; if not, write to the Free Software 23 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 24 * 25 */ 26 27 #include <linux/spinlock.h> 28 #include "aic94xx.h" 29 #include "aic94xx_sas.h" 30 #include "aic94xx_hwi.h" 31 32 /* ---------- Internal enqueue ---------- */ 33 34 static int asd_enqueue_internal(struct asd_ascb *ascb, 35 void (*tasklet_complete)(struct asd_ascb *, 36 struct done_list_struct *), 37 void (*timed_out)(unsigned long)) 38 { 39 int res; 40 41 ascb->tasklet_complete = tasklet_complete; 42 ascb->uldd_timer = 1; 43 44 ascb->timer.data = (unsigned long) ascb; 45 ascb->timer.function = timed_out; 46 ascb->timer.expires = jiffies + AIC94XX_SCB_TIMEOUT; 47 48 add_timer(&ascb->timer); 49 50 res = asd_post_ascb_list(ascb->ha, ascb, 1); 51 if (unlikely(res)) 52 del_timer(&ascb->timer); 53 return res; 54 } 55 56 static inline void asd_timedout_common(unsigned long data) 57 { 58 struct asd_ascb *ascb = (void *) data; 59 struct asd_seq_data *seq = &ascb->ha->seq; 60 unsigned long flags; 61 62 spin_lock_irqsave(&seq->pend_q_lock, flags); 63 seq->pending--; 64 list_del_init(&ascb->list); 65 spin_unlock_irqrestore(&seq->pend_q_lock, flags); 66 } 67 68 /* ---------- CLEAR NEXUS ---------- */ 69 70 static void asd_clear_nexus_tasklet_complete(struct asd_ascb *ascb, 71 struct done_list_struct *dl) 72 { 73 ASD_DPRINTK("%s: here\n", __FUNCTION__); 74 if (!del_timer(&ascb->timer)) { 75 ASD_DPRINTK("%s: couldn't delete timer\n", __FUNCTION__); 76 return; 77 } 78 ASD_DPRINTK("%s: opcode: 0x%x\n", __FUNCTION__, dl->opcode); 79 ascb->uldd_task = (void *) (unsigned long) dl->opcode; 80 complete(&ascb->completion); 81 } 82 83 static void asd_clear_nexus_timedout(unsigned long data) 84 { 85 struct asd_ascb *ascb = (void *) data; 86 87 ASD_DPRINTK("%s: here\n", __FUNCTION__); 88 asd_timedout_common(data); 89 ascb->uldd_task = (void *) TMF_RESP_FUNC_FAILED; 90 complete(&ascb->completion); 91 } 92 93 #define CLEAR_NEXUS_PRE \ 94 ASD_DPRINTK("%s: PRE\n", __FUNCTION__); \ 95 res = 1; \ 96 ascb = asd_ascb_alloc_list(asd_ha, &res, GFP_KERNEL); \ 97 if (!ascb) \ 98 return -ENOMEM; \ 99 \ 100 scb = ascb->scb; \ 101 scb->header.opcode = CLEAR_NEXUS 102 103 #define CLEAR_NEXUS_POST \ 104 ASD_DPRINTK("%s: POST\n", __FUNCTION__); \ 105 res = asd_enqueue_internal(ascb, asd_clear_nexus_tasklet_complete, \ 106 asd_clear_nexus_timedout); \ 107 if (res) \ 108 goto out_err; \ 109 ASD_DPRINTK("%s: clear nexus posted, waiting...\n", __FUNCTION__); \ 110 wait_for_completion(&ascb->completion); \ 111 res = (int) (unsigned long) ascb->uldd_task; \ 112 if (res == TC_NO_ERROR) \ 113 res = TMF_RESP_FUNC_COMPLETE; \ 114 out_err: \ 115 asd_ascb_free(ascb); \ 116 return res 117 118 int asd_clear_nexus_ha(struct sas_ha_struct *sas_ha) 119 { 120 struct asd_ha_struct *asd_ha = sas_ha->lldd_ha; 121 struct asd_ascb *ascb; 122 struct scb *scb; 123 int res; 124 125 CLEAR_NEXUS_PRE; 126 scb->clear_nexus.nexus = NEXUS_ADAPTER; 127 CLEAR_NEXUS_POST; 128 } 129 130 int asd_clear_nexus_port(struct asd_sas_port *port) 131 { 132 struct asd_ha_struct *asd_ha = port->ha->lldd_ha; 133 struct asd_ascb *ascb; 134 struct scb *scb; 135 int res; 136 137 CLEAR_NEXUS_PRE; 138 scb->clear_nexus.nexus = NEXUS_PORT; 139 scb->clear_nexus.conn_mask = port->phy_mask; 140 CLEAR_NEXUS_POST; 141 } 142 143 #if 0 144 static int asd_clear_nexus_I_T(struct domain_device *dev) 145 { 146 struct asd_ha_struct *asd_ha = dev->port->ha->lldd_ha; 147 struct asd_ascb *ascb; 148 struct scb *scb; 149 int res; 150 151 CLEAR_NEXUS_PRE; 152 scb->clear_nexus.nexus = NEXUS_I_T; 153 scb->clear_nexus.flags = SEND_Q | EXEC_Q | NOTINQ; 154 if (dev->tproto) 155 scb->clear_nexus.flags |= SUSPEND_TX; 156 scb->clear_nexus.conn_handle = cpu_to_le16((u16)(unsigned long) 157 dev->lldd_dev); 158 CLEAR_NEXUS_POST; 159 } 160 #endif 161 162 static int asd_clear_nexus_I_T_L(struct domain_device *dev, u8 *lun) 163 { 164 struct asd_ha_struct *asd_ha = dev->port->ha->lldd_ha; 165 struct asd_ascb *ascb; 166 struct scb *scb; 167 int res; 168 169 CLEAR_NEXUS_PRE; 170 scb->clear_nexus.nexus = NEXUS_I_T_L; 171 scb->clear_nexus.flags = SEND_Q | EXEC_Q | NOTINQ; 172 if (dev->tproto) 173 scb->clear_nexus.flags |= SUSPEND_TX; 174 memcpy(scb->clear_nexus.ssp_task.lun, lun, 8); 175 scb->clear_nexus.conn_handle = cpu_to_le16((u16)(unsigned long) 176 dev->lldd_dev); 177 CLEAR_NEXUS_POST; 178 } 179 180 static int asd_clear_nexus_tag(struct sas_task *task) 181 { 182 struct asd_ha_struct *asd_ha = task->dev->port->ha->lldd_ha; 183 struct asd_ascb *tascb = task->lldd_task; 184 struct asd_ascb *ascb; 185 struct scb *scb; 186 int res; 187 188 CLEAR_NEXUS_PRE; 189 scb->clear_nexus.nexus = NEXUS_TAG; 190 memcpy(scb->clear_nexus.ssp_task.lun, task->ssp_task.LUN, 8); 191 scb->clear_nexus.ssp_task.tag = tascb->tag; 192 if (task->dev->tproto) 193 scb->clear_nexus.conn_handle = cpu_to_le16((u16)(unsigned long) 194 task->dev->lldd_dev); 195 CLEAR_NEXUS_POST; 196 } 197 198 static int asd_clear_nexus_index(struct sas_task *task) 199 { 200 struct asd_ha_struct *asd_ha = task->dev->port->ha->lldd_ha; 201 struct asd_ascb *tascb = task->lldd_task; 202 struct asd_ascb *ascb; 203 struct scb *scb; 204 int res; 205 206 CLEAR_NEXUS_PRE; 207 scb->clear_nexus.nexus = NEXUS_TRANS_CX; 208 if (task->dev->tproto) 209 scb->clear_nexus.conn_handle = cpu_to_le16((u16)(unsigned long) 210 task->dev->lldd_dev); 211 scb->clear_nexus.index = cpu_to_le16(tascb->tc_index); 212 CLEAR_NEXUS_POST; 213 } 214 215 /* ---------- TMFs ---------- */ 216 217 static void asd_tmf_timedout(unsigned long data) 218 { 219 struct asd_ascb *ascb = (void *) data; 220 221 ASD_DPRINTK("tmf timed out\n"); 222 asd_timedout_common(data); 223 ascb->uldd_task = (void *) TMF_RESP_FUNC_FAILED; 224 complete(&ascb->completion); 225 } 226 227 static int asd_get_tmf_resp_tasklet(struct asd_ascb *ascb, 228 struct done_list_struct *dl) 229 { 230 struct asd_ha_struct *asd_ha = ascb->ha; 231 unsigned long flags; 232 struct tc_resp_sb_struct { 233 __le16 index_escb; 234 u8 len_lsb; 235 u8 flags; 236 } __attribute__ ((packed)) *resp_sb = (void *) dl->status_block; 237 238 int edb_id = ((resp_sb->flags & 0x70) >> 4)-1; 239 struct asd_ascb *escb; 240 struct asd_dma_tok *edb; 241 struct ssp_frame_hdr *fh; 242 struct ssp_response_iu *ru; 243 int res = TMF_RESP_FUNC_FAILED; 244 245 ASD_DPRINTK("tmf resp tasklet\n"); 246 247 spin_lock_irqsave(&asd_ha->seq.tc_index_lock, flags); 248 escb = asd_tc_index_find(&asd_ha->seq, 249 (int)le16_to_cpu(resp_sb->index_escb)); 250 spin_unlock_irqrestore(&asd_ha->seq.tc_index_lock, flags); 251 252 if (!escb) { 253 ASD_DPRINTK("Uh-oh! No escb for this dl?!\n"); 254 return res; 255 } 256 257 edb = asd_ha->seq.edb_arr[edb_id + escb->edb_index]; 258 ascb->tag = *(__be16 *)(edb->vaddr+4); 259 fh = edb->vaddr + 16; 260 ru = edb->vaddr + 16 + sizeof(*fh); 261 res = ru->status; 262 if (ru->datapres == 1) /* Response data present */ 263 res = ru->resp_data[3]; 264 #if 0 265 ascb->tag = fh->tag; 266 #endif 267 ascb->tag_valid = 1; 268 269 asd_invalidate_edb(escb, edb_id); 270 return res; 271 } 272 273 static void asd_tmf_tasklet_complete(struct asd_ascb *ascb, 274 struct done_list_struct *dl) 275 { 276 if (!del_timer(&ascb->timer)) 277 return; 278 279 ASD_DPRINTK("tmf tasklet complete\n"); 280 281 if (dl->opcode == TC_SSP_RESP) 282 ascb->uldd_task = (void *) (unsigned long) 283 asd_get_tmf_resp_tasklet(ascb, dl); 284 else 285 ascb->uldd_task = (void *) 0xFF00 + (unsigned long) dl->opcode; 286 287 complete(&ascb->completion); 288 } 289 290 static inline int asd_clear_nexus(struct sas_task *task) 291 { 292 int res = TMF_RESP_FUNC_FAILED; 293 struct asd_ascb *tascb = task->lldd_task; 294 unsigned long flags; 295 296 ASD_DPRINTK("task not done, clearing nexus\n"); 297 if (tascb->tag_valid) 298 res = asd_clear_nexus_tag(task); 299 else 300 res = asd_clear_nexus_index(task); 301 wait_for_completion_timeout(&tascb->completion, 302 AIC94XX_SCB_TIMEOUT); 303 ASD_DPRINTK("came back from clear nexus\n"); 304 spin_lock_irqsave(&task->task_state_lock, flags); 305 if (task->task_state_flags & SAS_TASK_STATE_DONE) 306 res = TMF_RESP_FUNC_COMPLETE; 307 spin_unlock_irqrestore(&task->task_state_lock, flags); 308 309 return res; 310 } 311 312 /** 313 * asd_abort_task -- ABORT TASK TMF 314 * @task: the task to be aborted 315 * 316 * Before calling ABORT TASK the task state flags should be ORed with 317 * SAS_TASK_STATE_ABORTED (unless SAS_TASK_STATE_DONE is set) under 318 * the task_state_lock IRQ spinlock, then ABORT TASK *must* be called. 319 * 320 * Implements the ABORT TASK TMF, I_T_L_Q nexus. 321 * Returns: SAS TMF responses (see sas_task.h), 322 * -ENOMEM, 323 * -SAS_QUEUE_FULL. 324 * 325 * When ABORT TASK returns, the caller of ABORT TASK checks first the 326 * task->task_state_flags, and then the return value of ABORT TASK. 327 * 328 * If the task has task state bit SAS_TASK_STATE_DONE set, then the 329 * task was completed successfully prior to it being aborted. The 330 * caller of ABORT TASK has responsibility to call task->task_done() 331 * xor free the task, depending on their framework. The return code 332 * is TMF_RESP_FUNC_FAILED in this case. 333 * 334 * Else the SAS_TASK_STATE_DONE bit is not set, 335 * If the return code is TMF_RESP_FUNC_COMPLETE, then 336 * the task was aborted successfully. The caller of 337 * ABORT TASK has responsibility to call task->task_done() 338 * to finish the task, xor free the task depending on their 339 * framework. 340 * else 341 * the ABORT TASK returned some kind of error. The task 342 * was _not_ cancelled. Nothing can be assumed. 343 * The caller of ABORT TASK may wish to retry. 344 */ 345 int asd_abort_task(struct sas_task *task) 346 { 347 struct asd_ascb *tascb = task->lldd_task; 348 struct asd_ha_struct *asd_ha = tascb->ha; 349 int res = 1; 350 unsigned long flags; 351 struct asd_ascb *ascb = NULL; 352 struct scb *scb; 353 354 spin_lock_irqsave(&task->task_state_lock, flags); 355 if (task->task_state_flags & SAS_TASK_STATE_DONE) { 356 spin_unlock_irqrestore(&task->task_state_lock, flags); 357 res = TMF_RESP_FUNC_COMPLETE; 358 ASD_DPRINTK("%s: task 0x%p done\n", __FUNCTION__, task); 359 goto out_done; 360 } 361 spin_unlock_irqrestore(&task->task_state_lock, flags); 362 363 ascb = asd_ascb_alloc_list(asd_ha, &res, GFP_KERNEL); 364 if (!ascb) 365 return -ENOMEM; 366 scb = ascb->scb; 367 368 scb->header.opcode = ABORT_TASK; 369 370 switch (task->task_proto) { 371 case SATA_PROTO: 372 case SAS_PROTO_STP: 373 scb->abort_task.proto_conn_rate = (1 << 5); /* STP */ 374 break; 375 case SAS_PROTO_SSP: 376 scb->abort_task.proto_conn_rate = (1 << 4); /* SSP */ 377 scb->abort_task.proto_conn_rate |= task->dev->linkrate; 378 break; 379 case SAS_PROTO_SMP: 380 break; 381 default: 382 break; 383 } 384 385 if (task->task_proto == SAS_PROTO_SSP) { 386 scb->abort_task.ssp_frame.frame_type = SSP_TASK; 387 memcpy(scb->abort_task.ssp_frame.hashed_dest_addr, 388 task->dev->hashed_sas_addr, HASHED_SAS_ADDR_SIZE); 389 memcpy(scb->abort_task.ssp_frame.hashed_src_addr, 390 task->dev->port->ha->hashed_sas_addr, 391 HASHED_SAS_ADDR_SIZE); 392 scb->abort_task.ssp_frame.tptt = cpu_to_be16(0xFFFF); 393 394 memcpy(scb->abort_task.ssp_task.lun, task->ssp_task.LUN, 8); 395 scb->abort_task.ssp_task.tmf = TMF_ABORT_TASK; 396 scb->abort_task.ssp_task.tag = cpu_to_be16(0xFFFF); 397 } 398 399 scb->abort_task.sister_scb = cpu_to_le16(0xFFFF); 400 scb->abort_task.conn_handle = cpu_to_le16( 401 (u16)(unsigned long)task->dev->lldd_dev); 402 scb->abort_task.retry_count = 1; 403 scb->abort_task.index = cpu_to_le16((u16)tascb->tc_index); 404 scb->abort_task.itnl_to = cpu_to_le16(ITNL_TIMEOUT_CONST); 405 406 res = asd_enqueue_internal(ascb, asd_tmf_tasklet_complete, 407 asd_tmf_timedout); 408 if (res) 409 goto out; 410 wait_for_completion(&ascb->completion); 411 ASD_DPRINTK("tmf came back\n"); 412 413 res = (int) (unsigned long) ascb->uldd_task; 414 tascb->tag = ascb->tag; 415 tascb->tag_valid = ascb->tag_valid; 416 417 spin_lock_irqsave(&task->task_state_lock, flags); 418 if (task->task_state_flags & SAS_TASK_STATE_DONE) { 419 spin_unlock_irqrestore(&task->task_state_lock, flags); 420 res = TMF_RESP_FUNC_COMPLETE; 421 ASD_DPRINTK("%s: task 0x%p done\n", __FUNCTION__, task); 422 goto out_done; 423 } 424 spin_unlock_irqrestore(&task->task_state_lock, flags); 425 426 switch (res) { 427 /* The task to be aborted has been sent to the device. 428 * We got a Response IU for the ABORT TASK TMF. */ 429 case TC_NO_ERROR + 0xFF00: 430 case TMF_RESP_FUNC_COMPLETE: 431 case TMF_RESP_FUNC_FAILED: 432 res = asd_clear_nexus(task); 433 break; 434 case TMF_RESP_INVALID_FRAME: 435 case TMF_RESP_OVERLAPPED_TAG: 436 case TMF_RESP_FUNC_ESUPP: 437 case TMF_RESP_NO_LUN: 438 goto out_done; break; 439 } 440 /* In the following we assume that the managing layer 441 * will _never_ make a mistake, when issuing ABORT TASK. 442 */ 443 switch (res) { 444 default: 445 res = asd_clear_nexus(task); 446 /* fallthrough */ 447 case TC_NO_ERROR + 0xFF00: 448 case TMF_RESP_FUNC_COMPLETE: 449 break; 450 /* The task hasn't been sent to the device xor we never got 451 * a (sane) Response IU for the ABORT TASK TMF. 452 */ 453 case TF_NAK_RECV + 0xFF00: 454 res = TMF_RESP_INVALID_FRAME; 455 break; 456 case TF_TMF_TASK_DONE + 0xFF00: /* done but not reported yet */ 457 res = TMF_RESP_FUNC_FAILED; 458 wait_for_completion_timeout(&tascb->completion, 459 AIC94XX_SCB_TIMEOUT); 460 spin_lock_irqsave(&task->task_state_lock, flags); 461 if (task->task_state_flags & SAS_TASK_STATE_DONE) 462 res = TMF_RESP_FUNC_COMPLETE; 463 spin_unlock_irqrestore(&task->task_state_lock, flags); 464 goto out_done; 465 case TF_TMF_NO_TAG + 0xFF00: 466 case TF_TMF_TAG_FREE + 0xFF00: /* the tag is in the free list */ 467 case TF_TMF_NO_CONN_HANDLE + 0xFF00: /* no such device */ 468 res = TMF_RESP_FUNC_COMPLETE; 469 goto out_done; 470 case TF_TMF_NO_CTX + 0xFF00: /* not in seq, or proto != SSP */ 471 res = TMF_RESP_FUNC_ESUPP; 472 goto out; 473 } 474 out_done: 475 if (res == TMF_RESP_FUNC_COMPLETE) { 476 task->lldd_task = NULL; 477 mb(); 478 asd_ascb_free(tascb); 479 } 480 out: 481 asd_ascb_free(ascb); 482 ASD_DPRINTK("task 0x%p aborted, res: 0x%x\n", task, res); 483 return res; 484 } 485 486 /** 487 * asd_initiate_ssp_tmf -- send a TMF to an I_T_L or I_T_L_Q nexus 488 * @dev: pointer to struct domain_device of interest 489 * @lun: pointer to u8[8] which is the LUN 490 * @tmf: the TMF to be performed (see sas_task.h or the SAS spec) 491 * @index: the transaction context of the task to be queried if QT TMF 492 * 493 * This function is used to send ABORT TASK SET, CLEAR ACA, 494 * CLEAR TASK SET, LU RESET and QUERY TASK TMFs. 495 * 496 * No SCBs should be queued to the I_T_L nexus when this SCB is 497 * pending. 498 * 499 * Returns: TMF response code (see sas_task.h or the SAS spec) 500 */ 501 static int asd_initiate_ssp_tmf(struct domain_device *dev, u8 *lun, 502 int tmf, int index) 503 { 504 struct asd_ha_struct *asd_ha = dev->port->ha->lldd_ha; 505 struct asd_ascb *ascb; 506 int res = 1; 507 struct scb *scb; 508 509 if (!(dev->tproto & SAS_PROTO_SSP)) 510 return TMF_RESP_FUNC_ESUPP; 511 512 ascb = asd_ascb_alloc_list(asd_ha, &res, GFP_KERNEL); 513 if (!ascb) 514 return -ENOMEM; 515 scb = ascb->scb; 516 517 if (tmf == TMF_QUERY_TASK) 518 scb->header.opcode = QUERY_SSP_TASK; 519 else 520 scb->header.opcode = INITIATE_SSP_TMF; 521 522 scb->ssp_tmf.proto_conn_rate = (1 << 4); /* SSP */ 523 scb->ssp_tmf.proto_conn_rate |= dev->linkrate; 524 /* SSP frame header */ 525 scb->ssp_tmf.ssp_frame.frame_type = SSP_TASK; 526 memcpy(scb->ssp_tmf.ssp_frame.hashed_dest_addr, 527 dev->hashed_sas_addr, HASHED_SAS_ADDR_SIZE); 528 memcpy(scb->ssp_tmf.ssp_frame.hashed_src_addr, 529 dev->port->ha->hashed_sas_addr, HASHED_SAS_ADDR_SIZE); 530 scb->ssp_tmf.ssp_frame.tptt = cpu_to_be16(0xFFFF); 531 /* SSP Task IU */ 532 memcpy(scb->ssp_tmf.ssp_task.lun, lun, 8); 533 scb->ssp_tmf.ssp_task.tmf = tmf; 534 535 scb->ssp_tmf.sister_scb = cpu_to_le16(0xFFFF); 536 scb->ssp_tmf.conn_handle= cpu_to_le16((u16)(unsigned long) 537 dev->lldd_dev); 538 scb->ssp_tmf.retry_count = 1; 539 scb->ssp_tmf.itnl_to = cpu_to_le16(ITNL_TIMEOUT_CONST); 540 if (tmf == TMF_QUERY_TASK) 541 scb->ssp_tmf.index = cpu_to_le16(index); 542 543 res = asd_enqueue_internal(ascb, asd_tmf_tasklet_complete, 544 asd_tmf_timedout); 545 if (res) 546 goto out_err; 547 wait_for_completion(&ascb->completion); 548 res = (int) (unsigned long) ascb->uldd_task; 549 550 switch (res) { 551 case TC_NO_ERROR + 0xFF00: 552 res = TMF_RESP_FUNC_COMPLETE; 553 break; 554 case TF_NAK_RECV + 0xFF00: 555 res = TMF_RESP_INVALID_FRAME; 556 break; 557 case TF_TMF_TASK_DONE + 0xFF00: 558 res = TMF_RESP_FUNC_FAILED; 559 break; 560 case TF_TMF_NO_TAG + 0xFF00: 561 case TF_TMF_TAG_FREE + 0xFF00: /* the tag is in the free list */ 562 case TF_TMF_NO_CONN_HANDLE + 0xFF00: /* no such device */ 563 res = TMF_RESP_FUNC_COMPLETE; 564 break; 565 case TF_TMF_NO_CTX + 0xFF00: /* not in seq, or proto != SSP */ 566 res = TMF_RESP_FUNC_ESUPP; 567 break; 568 default: 569 /* Allow TMF response codes to propagate upwards */ 570 break; 571 } 572 out_err: 573 asd_ascb_free(ascb); 574 return res; 575 } 576 577 int asd_abort_task_set(struct domain_device *dev, u8 *lun) 578 { 579 int res = asd_initiate_ssp_tmf(dev, lun, TMF_ABORT_TASK_SET, 0); 580 581 if (res == TMF_RESP_FUNC_COMPLETE) 582 asd_clear_nexus_I_T_L(dev, lun); 583 return res; 584 } 585 586 int asd_clear_aca(struct domain_device *dev, u8 *lun) 587 { 588 int res = asd_initiate_ssp_tmf(dev, lun, TMF_CLEAR_ACA, 0); 589 590 if (res == TMF_RESP_FUNC_COMPLETE) 591 asd_clear_nexus_I_T_L(dev, lun); 592 return res; 593 } 594 595 int asd_clear_task_set(struct domain_device *dev, u8 *lun) 596 { 597 int res = asd_initiate_ssp_tmf(dev, lun, TMF_CLEAR_TASK_SET, 0); 598 599 if (res == TMF_RESP_FUNC_COMPLETE) 600 asd_clear_nexus_I_T_L(dev, lun); 601 return res; 602 } 603 604 int asd_lu_reset(struct domain_device *dev, u8 *lun) 605 { 606 int res = asd_initiate_ssp_tmf(dev, lun, TMF_LU_RESET, 0); 607 608 if (res == TMF_RESP_FUNC_COMPLETE) 609 asd_clear_nexus_I_T_L(dev, lun); 610 return res; 611 } 612 613 /** 614 * asd_query_task -- send a QUERY TASK TMF to an I_T_L_Q nexus 615 * task: pointer to sas_task struct of interest 616 * 617 * Returns: TMF_RESP_FUNC_COMPLETE if the task is not in the task set, 618 * or TMF_RESP_FUNC_SUCC if the task is in the task set. 619 * 620 * Normally the management layer sets the task to aborted state, 621 * and then calls query task and then abort task. 622 */ 623 int asd_query_task(struct sas_task *task) 624 { 625 struct asd_ascb *ascb = task->lldd_task; 626 int index; 627 628 if (ascb) { 629 index = ascb->tc_index; 630 return asd_initiate_ssp_tmf(task->dev, task->ssp_task.LUN, 631 TMF_QUERY_TASK, index); 632 } 633 return TMF_RESP_FUNC_COMPLETE; 634 } 635