1 /******************************************************************************* 2 *Copyright (c) 2014 PMC-Sierra, Inc. All rights reserved. 3 * 4 *Redistribution and use in source and binary forms, with or without modification, are permitted provided 5 *that the following conditions are met: 6 *1. Redistributions of source code must retain the above copyright notice, this list of conditions and the 7 *following disclaimer. 8 *2. Redistributions in binary form must reproduce the above copyright notice, 9 *this list of conditions and the following disclaimer in the documentation and/or other materials provided 10 *with the distribution. 11 * 12 *THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED 13 *WARRANTIES,INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 14 *FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 15 *FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 16 *NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR 17 *BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 18 *LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 19 *SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE 20 21 ********************************************************************************/ 22 #include <sys/cdefs.h> 23 __FBSDID("$FreeBSD$"); 24 #include <dev/pms/config.h> 25 26 #include <dev/pms/freebsd/driver/common/osenv.h> 27 #include <dev/pms/freebsd/driver/common/ostypes.h> 28 #include <dev/pms/freebsd/driver/common/osdebug.h> 29 30 #include <dev/pms/RefTisa/tisa/api/titypes.h> 31 32 #include <dev/pms/RefTisa/sallsdk/api/sa.h> 33 #include <dev/pms/RefTisa/sallsdk/api/saapi.h> 34 #include <dev/pms/RefTisa/sallsdk/api/saosapi.h> 35 36 #include <dev/pms/RefTisa/sat/api/sm.h> 37 #include <dev/pms/RefTisa/sat/api/smapi.h> 38 #include <dev/pms/RefTisa/sat/api/tdsmapi.h> 39 40 #include <dev/pms/RefTisa/sat/src/smdefs.h> 41 #include <dev/pms/RefTisa/sat/src/smproto.h> 42 #include <dev/pms/RefTisa/sat/src/smtypes.h> 43 44 /* 45 * This table is used to map LL Layer saSATAStart() status to TISA status. 46 */ 47 48 49 FORCEINLINE bit32 50 smsataLLIOStart( 51 smRoot_t *smRoot, 52 smIORequest_t *smIORequest, 53 smDeviceHandle_t *smDeviceHandle, 54 smScsiInitiatorRequest_t *smScsiRequest, 55 smSatIOContext_t *satIOContext 56 ) 57 { 58 smDeviceData_t *oneDeviceData = (smDeviceData_t *)smDeviceHandle->smData; 59 smIntRoot_t *smIntRoot = (smIntRoot_t *) smRoot->smData; 60 smIntContext_t *smAllShared = (smIntContext_t *)&(smIntRoot->smAllShared); 61 smIORequestBody_t *smIORequestBody = (smIORequestBody_t *)satIOContext->smRequestBody; 62 smDeviceData_t *pSatDevData = satIOContext->pSatDevData; 63 smSatInternalIo_t *satIntIo = satIOContext->satIntIoContext; 64 agsaRoot_t *agRoot = smAllShared->agRoot; 65 agsaIORequest_t *agIORequest = &(smIORequestBody->agIORequest); 66 agsaDevHandle_t *agDevHandle = oneDeviceData->agDevHandle; 67 agsaSATAInitiatorRequest_t *agSATAReq = &(smIORequestBody->transport.SATA.agSATARequestBody); 68 bit32 RLERecovery = agFALSE; 69 bit32 status = SM_RC_FAILURE; 70 bit32 nQNumber = 0; 71 /* 72 * If this is a super I/O request, check for optional settings. 73 * Be careful. Use the superRequest pointer for all references 74 * in this block of code. 75 */ 76 agSATAReq->option = 0; 77 if (satIOContext->superIOFlag) 78 { 79 smSuperScsiInitiatorRequest_t *superRequest = (smSuperScsiInitiatorRequest_t *) smScsiRequest; 80 81 if (superRequest->flags & SM_SCSI_INITIATOR_ENCRYPT) 82 { 83 /* Copy all of the relevant encrypt information */ 84 agSATAReq->option |= AGSA_SATA_ENABLE_ENCRYPTION; 85 sm_memcpy(&agSATAReq->encrypt, &superRequest->Encrypt, sizeof(agsaEncrypt_t)); 86 } 87 { 88 /* initialize expDataLength */ 89 if (satIOContext->reqType == AGSA_SATA_PROTOCOL_NON_DATA || 90 satIOContext->reqType == AGSA_SATA_PROTOCOL_SRST_ASSERT || 91 satIOContext->reqType == AGSA_SATA_PROTOCOL_SRST_DEASSERT ) 92 { 93 smIORequestBody->IOType.InitiatorRegIO.expDataLength = 0; 94 } 95 else 96 { 97 smIORequestBody->IOType.InitiatorRegIO.expDataLength = smScsiRequest->scsiCmnd.expDataLength; 98 } 99 100 agSATAReq->dataLength = smIORequestBody->IOType.InitiatorRegIO.expDataLength; 101 } 102 } 103 else 104 { 105 /* initialize expDataLength */ 106 if (satIOContext->reqType == AGSA_SATA_PROTOCOL_NON_DATA || 107 satIOContext->reqType == AGSA_SATA_PROTOCOL_SRST_ASSERT || 108 satIOContext->reqType == AGSA_SATA_PROTOCOL_SRST_DEASSERT ) 109 { 110 smIORequestBody->IOType.InitiatorRegIO.expDataLength = 0; 111 } 112 else 113 { 114 smIORequestBody->IOType.InitiatorRegIO.expDataLength = smScsiRequest->scsiCmnd.expDataLength; 115 } 116 117 agSATAReq->dataLength = smIORequestBody->IOType.InitiatorRegIO.expDataLength; 118 } 119 120 if ( (pSatDevData->satDriveState == SAT_DEV_STATE_IN_RECOVERY) && 121 (satIOContext->pFis->h.command == SAT_READ_LOG_EXT) ) 122 { 123 RLERecovery = agTRUE; 124 } 125 126 /* check max io, be sure to free */ 127 if ( (pSatDevData->satDriveState != SAT_DEV_STATE_IN_RECOVERY) || 128 (RLERecovery == agTRUE) ) 129 { 130 if (RLERecovery == agFALSE) /* RLE is not checked against pending IO's */ 131 { 132 #ifdef CCFLAG_OPTIMIZE_SAT_LOCK 133 bit32 volatile satPendingNCQIO = 0; 134 bit32 volatile satPendingNONNCQIO = 0; 135 bit32 volatile satPendingIO = 0; 136 137 tdsmInterlockedExchange(smRoot, &satPendingNCQIO, pSatDevData->satPendingNCQIO); 138 tdsmInterlockedExchange(smRoot, &satPendingNONNCQIO, pSatDevData->satPendingNONNCQIO); 139 tdsmInterlockedExchange(smRoot, &satPendingIO, pSatDevData->satPendingIO); 140 #endif 141 142 if ( (satIOContext->reqType == AGSA_SATA_PROTOCOL_FPDMA_WRITE) || 143 (satIOContext->reqType == AGSA_SATA_PROTOCOL_FPDMA_READ) ) 144 { 145 #ifdef CCFLAG_OPTIMIZE_SAT_LOCK 146 if ( satPendingNCQIO >= pSatDevData->satNCQMaxIO || 147 satPendingNONNCQIO != 0) 148 { 149 SM_DBG1(("smsataLLIOStart: 1st busy did %d!!!\n", pSatDevData->id)); 150 SM_DBG1(("smsataLLIOStart: 1st busy NCQ. NCQ Pending 0x%x NONNCQ Pending 0x%x All Pending 0x%x!!!\n", satPendingNCQIO, 151 satPendingNONNCQIO, satPendingIO)); 152 /* free resource */ 153 smsatFreeIntIoResource( smRoot, 154 pSatDevData, 155 satIntIo); 156 return SM_RC_DEVICE_BUSY; 157 } 158 #else 159 tdsmSingleThreadedEnter(smRoot, SM_EXTERNAL_IO_LOCK); 160 if (pSatDevData->satPendingNCQIO >= pSatDevData->satNCQMaxIO || 161 pSatDevData->satPendingNONNCQIO != 0) 162 { 163 SM_DBG1(("smsataLLIOStart: 1st busy did %d!!!\n", pSatDevData->id)); 164 SM_DBG1(("smsataLLIOStart: 1st busy NCQ. NCQ Pending 0x%x NONNCQ Pending 0x%x All Pending 0x%x!!!\n", pSatDevData->satPendingNCQIO, 165 pSatDevData->satPendingNONNCQIO, pSatDevData->satPendingIO)); 166 tdsmSingleThreadedLeave(smRoot, SM_EXTERNAL_IO_LOCK); 167 /* free resource */ 168 smsatFreeIntIoResource( smRoot, 169 pSatDevData, 170 satIntIo); 171 return SM_RC_DEVICE_BUSY; 172 } 173 tdsmSingleThreadedLeave(smRoot, SM_EXTERNAL_IO_LOCK); 174 #endif 175 176 } 177 else if ( (satIOContext->reqType == AGSA_SATA_PROTOCOL_D2H_PKT) || 178 (satIOContext->reqType == AGSA_SATA_PROTOCOL_H2D_PKT) || 179 (satIOContext->reqType == AGSA_SATA_PROTOCOL_NON_PKT) ) 180 { 181 sm_memcpy(agSATAReq->scsiCDB, smScsiRequest->scsiCmnd.cdb, 16); 182 #ifdef CCFLAG_OPTIMIZE_SAT_LOCK 183 if ( satPendingNONNCQIO >= SAT_APAPI_CMDQ_MAX || 184 satPendingNCQIO != 0) 185 { 186 SM_DBG1(("smsataLLIOStart: ATAPI busy did %d!!!\n", pSatDevData->id)); 187 SM_DBG1(("smsataLLIOStart: ATAPI busy NON-NCQ. NCQ Pending 0x%x NON-NCQ Pending 0x%x All Pending 0x%x!!!\n", satPendingNCQIO, 188 satPendingNONNCQIO, satPendingIO)); 189 /* free resource */ 190 smsatFreeIntIoResource( smRoot, 191 pSatDevData, 192 satIntIo); 193 return SM_RC_DEVICE_BUSY; 194 } 195 #else 196 tdsmSingleThreadedEnter(smRoot, SM_EXTERNAL_IO_LOCK); 197 if ( pSatDevData->satPendingNONNCQIO >= SAT_APAPI_CMDQ_MAX || 198 pSatDevData->satPendingNCQIO != 0) 199 { 200 SM_DBG1(("smsataLLIOStart: ATAPI busy did %d!!!\n", pSatDevData->id)); 201 SM_DBG1(("smsataLLIOStart: ATAPI busy NON-NCQ. NCQ Pending 0x%x NON-NCQ Pending 0x%x All Pending 0x%x!!!\n", pSatDevData->satPendingNCQIO, 202 pSatDevData->satPendingNONNCQIO, pSatDevData->satPendingIO)); 203 tdsmSingleThreadedLeave(smRoot, SM_EXTERNAL_IO_LOCK); 204 /* free resource */ 205 smsatFreeIntIoResource( smRoot, 206 pSatDevData, 207 satIntIo); 208 return SM_RC_DEVICE_BUSY; 209 } 210 tdsmSingleThreadedLeave(smRoot, SM_EXTERNAL_IO_LOCK); 211 #endif 212 213 } 214 else 215 { 216 #ifdef CCFLAG_OPTIMIZE_SAT_LOCK 217 if ( satPendingNONNCQIO >= SAT_NONNCQ_MAX || 218 satPendingNCQIO != 0) 219 { 220 SM_DBG1(("smsataLLIOStart: 2nd busy did %d!!!\n", pSatDevData->id)); 221 SM_DBG1(("smsataLLIOStart: 2nd busy NCQ. NCQ Pending 0x%x NONNCQ Pending 0x%x All Pending 0x%x!!!\n", satPendingNCQIO, 222 satPendingNONNCQIO, satPendingIO)); 223 /* free resource */ 224 smsatFreeIntIoResource( smRoot, 225 pSatDevData, 226 satIntIo); 227 return SM_RC_DEVICE_BUSY; 228 } 229 #else 230 tdsmSingleThreadedEnter(smRoot, SM_EXTERNAL_IO_LOCK); 231 if (pSatDevData->satPendingNONNCQIO >= SAT_NONNCQ_MAX || 232 pSatDevData->satPendingNCQIO != 0) 233 { 234 SM_DBG1(("smsataLLIOStart: 2nd busy did %d!!!\n", pSatDevData->id)); 235 SM_DBG1(("smsataLLIOStart: 2nd busy NCQ. NCQ Pending 0x%x NONNCQ Pending 0x%x All Pending 0x%x!!!\n", pSatDevData->satPendingNCQIO, 236 pSatDevData->satPendingNONNCQIO, pSatDevData->satPendingIO)); 237 tdsmSingleThreadedLeave(smRoot, SM_EXTERNAL_IO_LOCK); 238 /* free resource */ 239 smsatFreeIntIoResource( smRoot, 240 pSatDevData, 241 satIntIo); 242 return SM_RC_DEVICE_BUSY; 243 } 244 tdsmSingleThreadedLeave(smRoot, SM_EXTERNAL_IO_LOCK); 245 #endif 246 } 247 } /* RLE */ 248 /* for internal SATA command only */ 249 if (satIOContext->satOrgIOContext != agNULL) 250 { 251 /* Initialize tiIORequest */ 252 smIORequestBody->smIORequest = smIORequest; 253 if (smIORequest == agNULL) 254 { 255 SM_DBG1(("smsataLLIOStart: 1 check!!!\n")); 256 } 257 } 258 /* Initialize tiDevhandle */ 259 smIORequestBody->smDevHandle = smDeviceHandle; 260 261 /* Initializes Scatter Gather and ESGL */ 262 status = smsatIOPrepareSGL( smRoot, 263 smIORequestBody, 264 &smScsiRequest->smSgl1, 265 smScsiRequest->sglVirtualAddr ); 266 267 if (status != SM_RC_SUCCESS) 268 { 269 SM_DBG1(("smsataLLIOStart: can't get SGL!!!\n")); 270 /* free resource */ 271 smsatFreeIntIoResource( smRoot, 272 pSatDevData, 273 satIntIo); 274 return status; 275 } 276 277 /* Initialize LL Layer agIORequest */ 278 agIORequest->osData = (void *) smIORequestBody; 279 agIORequest->sdkData = agNULL; /* SA takes care of this */ 280 281 smIORequestBody->ioStarted = agTRUE; 282 smIORequestBody->ioCompleted = agFALSE; 283 284 /* assign tag value for SATA */ 285 if ( (satIOContext->reqType == AGSA_SATA_PROTOCOL_FPDMA_WRITE) || 286 (satIOContext->reqType == AGSA_SATA_PROTOCOL_FPDMA_READ) ) 287 { 288 if (agFALSE == smsatTagAlloc(smRoot, pSatDevData, &satIOContext->sataTag)) 289 { 290 SM_DBG1(("smsataLLIOStart: No more NCQ tag!!!\n")); 291 smIORequestBody->ioStarted = agFALSE; 292 smIORequestBody->ioCompleted = agTRUE; 293 return SM_RC_DEVICE_BUSY; 294 } 295 SM_DBG3(("smsataLLIOStart: ncq tag 0x%x\n",satIOContext->sataTag)); 296 } 297 else 298 { 299 satIOContext->sataTag = 0xFF; 300 } 301 } 302 else /* AGSA_SATA_PROTOCOL_SRST_ASSERT or AGSA_SATA_PROTOCOL_SRST_DEASSERT 303 or SAT_CHECK_POWER_MODE as ABORT */ 304 { 305 agsaSgl_t *agSgl; 306 307 /* for internal SATA command only */ 308 if (satIOContext->satOrgIOContext != agNULL) 309 { 310 /* Initialize tiIORequest */ 311 smIORequestBody->smIORequest = smIORequest; 312 if (smIORequest == agNULL) 313 { 314 SM_DBG1(("smsataLLIOStart: 2 check!!!\n")); 315 } 316 } 317 /* Initialize tiDevhandle */ 318 smIORequestBody->smDevHandle = smDeviceHandle; 319 320 321 smIORequestBody->IOType.InitiatorRegIO.expDataLength = 0; 322 /* SGL for SATA request */ 323 agSgl = &(smIORequestBody->transport.SATA.agSATARequestBody.agSgl); 324 agSgl->len = 0; 325 326 agSgl->sgUpper = 0; 327 agSgl->sgLower = 0; 328 agSgl->len = 0; 329 SM_CLEAR_ESGL_EXTEND(agSgl->extReserved); 330 331 /* Initialize LL Layer agIORequest */ 332 agIORequest = &(smIORequestBody->agIORequest); 333 agIORequest->osData = (void *) smIORequestBody; 334 agIORequest->sdkData = agNULL; /* SA takes care of this */ 335 336 smIORequestBody->ioStarted = agTRUE; 337 smIORequestBody->ioCompleted = agFALSE; 338 339 /* setting the data length */ 340 agSATAReq->dataLength = 0; 341 342 } 343 344 345 smIORequestBody->reTries = 0; 346 347 #ifdef TD_INTERNAL_DEBUG 348 smhexdump("smsataLLIOStart", (bit8 *)satIOContext->pFis, sizeof(agsaFisRegHostToDevice_t)); 349 smhexdump("smsataLLIOStart LL", (bit8 *)&agSATAReq->fis.fisRegHostToDev, 350 sizeof(agsaFisRegHostToDevice_t)); 351 #endif 352 353 SM_DBG6(("smsataLLIOStart: agDevHandle %p\n", agDevHandle)); 354 355 /* to get better IO performance, rotate the OBQ number on main IO path */ 356 if (smScsiRequest == agNULL) 357 { 358 nQNumber = 0; 359 } 360 else 361 { 362 switch (smScsiRequest->scsiCmnd.cdb[0]) 363 { 364 case SCSIOPC_READ_10: 365 case SCSIOPC_WRITE_10: 366 case SCSIOPC_READ_6: 367 case SCSIOPC_WRITE_6: 368 case SCSIOPC_READ_12: 369 case SCSIOPC_WRITE_12: 370 case SCSIOPC_READ_16: 371 case SCSIOPC_WRITE_16: 372 nQNumber = tdsmRotateQnumber(smRoot, smDeviceHandle); 373 break; 374 375 default: 376 nQNumber = 0; 377 break; 378 } 379 } 380 381 SM_DBG3(("sataLLIOStart: Lock in\n")); 382 383 #ifdef CCFLAG_OPTIMIZE_SAT_LOCK 384 if ( (satIOContext->reqType == AGSA_SATA_PROTOCOL_FPDMA_WRITE) || 385 (satIOContext->reqType == AGSA_SATA_PROTOCOL_FPDMA_READ) ) 386 { 387 tdsmInterlockedIncrement(smRoot,&pSatDevData->satPendingNCQIO); 388 } 389 else 390 { 391 tdsmInterlockedIncrement(smRoot,&pSatDevData->satPendingNONNCQIO); 392 } 393 tdsmInterlockedIncrement(smRoot,&pSatDevData->satPendingIO); 394 #else 395 tdsmSingleThreadedEnter(smRoot, SM_EXTERNAL_IO_LOCK); 396 if ( (satIOContext->reqType == AGSA_SATA_PROTOCOL_FPDMA_WRITE) || 397 (satIOContext->reqType == AGSA_SATA_PROTOCOL_FPDMA_READ) ) 398 { 399 pSatDevData->satPendingNCQIO++; 400 } 401 else 402 { 403 pSatDevData->satPendingNONNCQIO++; 404 } 405 pSatDevData->satPendingIO++; 406 407 SMLIST_INIT_ELEMENT (&satIOContext->satIoContextLink); 408 SMLIST_ENQUEUE_AT_TAIL (&satIOContext->satIoContextLink, &pSatDevData->satIoLinkList); 409 tdsmSingleThreadedLeave(smRoot, SM_EXTERNAL_IO_LOCK); 410 #endif 411 /* post SATA command to low level MPI */ 412 status = saSATAStart( agRoot, 413 agIORequest, 414 nQNumber, 415 agDevHandle, 416 satIOContext->reqType, 417 agSATAReq, 418 satIOContext->sataTag, 419 smllSATACompleted 420 ); 421 422 if (status != AGSA_RC_SUCCESS) 423 { 424 if (status == AGSA_RC_BUSY) 425 { 426 SM_DBG1(("smsataLLIOStart: saSATAStart busy!!!\n")); 427 status = SM_RC_BUSY; 428 } 429 else 430 { 431 SM_DBG1(("smsataLLIOStart: saSATAStart failed!!!\n")); 432 status = SM_RC_FAILURE; 433 } 434 435 if ( (satIOContext->reqType == AGSA_SATA_PROTOCOL_FPDMA_WRITE) || 436 (satIOContext->reqType == AGSA_SATA_PROTOCOL_FPDMA_READ) ) 437 { 438 smsatTagRelease(smRoot, pSatDevData, satIOContext->sataTag); 439 } 440 441 #ifdef CCFLAG_OPTIMIZE_SAT_LOCK 442 if ( (satIOContext->reqType == AGSA_SATA_PROTOCOL_FPDMA_WRITE) || 443 (satIOContext->reqType == AGSA_SATA_PROTOCOL_FPDMA_READ) ) 444 { 445 tdsmInterlockedDecrement(smRoot,&oneDeviceData->satPendingNCQIO); 446 } 447 else 448 { 449 tdsmInterlockedDecrement(smRoot,&oneDeviceData->satPendingNONNCQIO); 450 } 451 tdsmInterlockedDecrement(smRoot,&oneDeviceData->satPendingIO); 452 #else 453 if ( (satIOContext->reqType == AGSA_SATA_PROTOCOL_FPDMA_WRITE) || 454 (satIOContext->reqType == AGSA_SATA_PROTOCOL_FPDMA_READ) ) 455 { 456 tdsmSingleThreadedEnter(smRoot, SM_EXTERNAL_IO_LOCK); 457 oneDeviceData->satPendingNCQIO--; 458 oneDeviceData->satPendingIO--; 459 SMLIST_DEQUEUE_THIS (&satIOContext->satIoContextLink); 460 tdsmSingleThreadedLeave(smRoot, SM_EXTERNAL_IO_LOCK); 461 } 462 else 463 { 464 tdsmSingleThreadedEnter(smRoot, SM_EXTERNAL_IO_LOCK); 465 oneDeviceData->satPendingNONNCQIO--; 466 oneDeviceData->satPendingIO--; 467 SMLIST_DEQUEUE_THIS (&satIOContext->satIoContextLink); 468 tdsmSingleThreadedLeave(smRoot, SM_EXTERNAL_IO_LOCK); 469 } 470 #endif /* CCFLAG_OPTIMIZE_SAT_LOCK */ 471 472 /* Free the ESGL pages associated with this I/O */ 473 smIORequestBody->ioStarted = agFALSE; 474 smIORequestBody->ioCompleted = agTRUE; 475 return (status); 476 } 477 478 return SM_RC_SUCCESS; 479 } 480 481 482 osGLOBAL FORCEINLINE bit32 483 smsatIOPrepareSGL( 484 smRoot_t *smRoot, 485 smIORequestBody_t *smIORequestBody, 486 smSgl_t *smSgl1, 487 void *sglVirtualAddr 488 ) 489 { 490 agsaSgl_t *agSgl; 491 492 /* Uppper should be zero-out */ 493 SM_DBG5(("smsatIOPrepareSGL: start\n")); 494 495 SM_DBG5(("smsatIOPrepareSGL: smSgl1->upper %d smSgl1->lower %d smSgl1->len %d\n", 496 smSgl1->upper, smSgl1->lower, smSgl1->len)); 497 SM_DBG5(("smsatIOPrepareSGL: smSgl1->type %d\n", smSgl1->type)); 498 499 /* SGL for SATA request */ 500 agSgl = &(smIORequestBody->transport.SATA.agSATARequestBody.agSgl); 501 agSgl->len = 0; 502 503 if (smSgl1 == agNULL) 504 { 505 SM_DBG1(("smsatIOPrepareSGL: Error smSgl1 is NULL!!!\n")); 506 return tiError; 507 } 508 509 if (smIORequestBody->IOType.InitiatorRegIO.expDataLength == 0) 510 { 511 SM_DBG3(("smsatIOPrepareSGL: expDataLength is 0\n")); 512 agSgl->sgUpper = 0; 513 agSgl->sgLower = 0; 514 agSgl->len = 0; 515 SM_CLEAR_ESGL_EXTEND(agSgl->extReserved); 516 return SM_RC_SUCCESS; 517 } 518 519 agSgl->sgUpper = smSgl1->upper; 520 agSgl->sgLower = smSgl1->lower; 521 agSgl->len = smSgl1->len; 522 agSgl->extReserved = smSgl1->type; 523 524 return SM_RC_SUCCESS; 525 526 } 527 528 529 530 531