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 * $FreeBSD$ 22 * 23 *******************************************************************************/ 24 /****************************************************************************** 25 PMC-Sierra TISA Initiator Device Driver for Linux 2.x.x. 26 27 Module Name: 28 osapi.c 29 Abstract: 30 Linux iSCSI/FC Initiator driver module itsdk required OS functions 31 Environment: 32 Part of oslayer module, Kernel or loadable module 33 34 ******************************************************************************* 35 ostiInitiatorEvent() 36 37 Purpose: 38 TI layer call back to OSlayer to inform events 39 Parameters: 40 tiRoot_t *ptiRoot (IN) Pointer to HBA data structure 41 tiDeviceHandle_t *ptiDevHandle (IN) Pointer to device handle 42 tiIntrEvenType_t evenType (IN) Event type 43 tiIntrEventStatus_t evetStatus (IN) Event status 44 void *parm (IN) pointer to even specific data 45 Return: 46 Note: 47 TBD, further event process required. 48 ******************************************************************************/ 49 void ostiInitiatorEvent( tiRoot_t *ptiRoot, 50 tiPortalContext_t *ptiPortalContext, 51 tiDeviceHandle_t *ptiDevHandle, 52 tiIntrEventType_t eventType, 53 U32 eventStatus, 54 void *parm ) 55 { 56 ag_portal_data_t *pPortalData; 57 ag_portal_info_t *pPortalInfo; 58 struct agtiapi_softc *pCard = TIROOT_TO_CARD( ptiRoot ); 59 ccb_t *pccb; 60 ccb_t *pTMccb; 61 ccb_t *ccbIO; 62 63 #ifdef AGTIAPI_EVENT_LOG 64 AGTIAPI_PRINTK("Initiator Event:\n"); 65 AGTIAPI_PRINTK("DevHandle %p, eventType 0x%x, eventStatus 0x%x\n", 66 ptiDevHandle, eventType, eventStatus); 67 AGTIAPI_PRINTK("Parameter: %s\n", (char *)parm); 68 #endif 69 70 AGTIAPI_PRINTK("ostiInitiatorEvent: eventType 0x%x eventStatus 0x%x\n", eventType, eventStatus); 71 72 switch (eventType) 73 { 74 case tiIntrEventTypeCnxError: 75 if (eventStatus == tiCnxUp) 76 { 77 AGTIAPI_PRINTK("tiIntrEventTypeCnxError - tiCnxUp!\n"); 78 } 79 if (eventStatus == tiCnxDown) 80 { 81 AGTIAPI_PRINTK("tiIntrEventTypeCnxError - tiCnxDown!\n"); 82 } 83 break; 84 case tiIntrEventTypeDiscovery: 85 pPortalData = PORTAL_CONTEXT_TO_PORTALDATA(ptiPortalContext); 86 pCard->flags |= AGTIAPI_CB_DONE; 87 if (eventStatus == tiDiscOK) 88 { 89 AGTIAPI_PRINTK("eventStatus - tiDiscOK\n"); 90 AGTIAPI_PRINTK("ostiInitiatorEvent: pcard %d eventStatus - tiDiscOK\n", pCard->cardNo ); 91 PORTAL_STATUS(pPortalData) |= AGTIAPI_DISC_COMPLETE; 92 #ifndef HOTPLUG_SUPPORT 93 if (!(pCard->flags & AGTIAPI_INIT_TIME)) 94 #else 95 if (TRUE) 96 #endif 97 { 98 99 agtiapi_GetDevHandle(pCard, &pPortalData->portalInfo, 100 tiIntrEventTypeDiscovery, tiDiscOK); 101 PORTAL_STATUS(pPortalData) |= 102 (AGTIAPI_DISC_DONE | AGTIAPI_PORT_LINK_UP); 103 } 104 /* Trigger CheckIOTimeout */ 105 callout_reset(&pCard->IO_timer, 20*hz, agtiapi_CheckIOTimeout, pCard); 106 } 107 else if (eventStatus == tiDiscFailed) 108 { 109 AGTIAPI_PRINTK("eventStatus - tiDiscFailed\n"); 110 agtiapi_GetDevHandle(pCard, &pPortalData->portalInfo, 111 tiIntrEventTypeDiscovery, tiDiscFailed); 112 PORTAL_STATUS(pPortalData) &= ~AGTIAPI_DISC_DONE; 113 } 114 AGTIAPI_PRINTK("tiIntrEventTypeDiscovery - portal %p, status 0x%x\n", 115 pPortalData, 116 PORTAL_STATUS(pPortalData)); 117 break; 118 case tiIntrEventTypeDeviceChange: 119 AGTIAPI_PRINTK("tiIntrEventTypeDeviceChange - portal %p es %d\n", 120 ptiPortalContext->osData, eventStatus); 121 pPortalData = PORTAL_CONTEXT_TO_PORTALDATA(ptiPortalContext); 122 pPortalInfo = &pPortalData->portalInfo; 123 #ifndef HOTPLUG_SUPPORT 124 if (!(pCard->flags & AGTIAPI_INIT_TIME)) 125 #else 126 if (TRUE) 127 #endif 128 { 129 agtiapi_GetDevHandle(pCard, pPortalInfo, tiIntrEventTypeDeviceChange, 130 eventStatus); 131 // agtiapi_StartIO(pCard); 132 } 133 break; 134 case tiIntrEventTypeTransportRecovery: 135 AGTIAPI_PRINTK("tiIntrEventTypeTransportRecovery!\n"); 136 break; 137 case tiIntrEventTypeTaskManagement: 138 AGTIAPI_PRINTK("tiIntrEventTypeTaskManagement!\n"); 139 pccb = (pccb_t)((tiIORequest_t *)parm)->osData; 140 if (pccb->flags & TASK_TIMEOUT) 141 { 142 AGTIAPI_PRINTK("tiIntrEventTypeTaskManagement: TM timeout!\n"); 143 agtiapi_FreeTMCCB(pCard, pccb); 144 } 145 else 146 { 147 pccb->flags |= AGTIAPI_CB_DONE; 148 if (eventStatus == tiTMOK) 149 { 150 pccb->flags |= TASK_SUCCESS; 151 AGTIAPI_PRINTK("tiIntrEventTypeTaskManagement: pTMccb %p flag %x \n", 152 pccb, pccb->flags); 153 154 /* Incase of TM_DEV_RESET, issue LocalAbort to abort pending IO */ 155 if (pccb->flags & DEV_RESET) 156 { 157 AGTIAPI_PRINTK("tiIntrEventTypeTaskManagement: Target Reset\n"); 158 ccbIO = pccb->pccbIO; 159 AGTIAPI_PRINTK("tiIntrEventTypeTaskManagement: IO to be aborted locally %p flag %x \n", 160 ccbIO, ccbIO->flags); 161 if (ccbIO->startTime == 0) /* IO has been completed. No local abort */ 162 { 163 } 164 else if (tiINIIOAbort(&pCard->tiRoot, &ccbIO->tiIORequest) != tiSuccess) 165 { 166 AGTIAPI_PRINTK("tiIntrEventTypeTaskManagement: Local Abort failed\n"); 167 /* TODO: call Soft reset here */ 168 } 169 } 170 else if (eventStatus == tiTMFailed) 171 { 172 ccbIO = pccb->pccbIO; 173 if (ccbIO->startTime == 0) /* IO has been completed. */ 174 { 175 AGTIAPI_PRINTK("tiIntrEventTypeTaskManagement: TM failed because IO has been completed! pTMccb %p flag %x \n", 176 pccb, pccb->flags); 177 } 178 else 179 { 180 AGTIAPI_PRINTK("tiIntrEventTypeTaskManagement: TM failed! pTMccb %p flag %x \n", 181 pccb, pccb->flags); 182 /* TODO:*/ 183 /* if TM_ABORT_TASK, call TM_TARGET_RESET */ 184 /* if TM_TARGET_RESET, call Soft_Reset */ 185 } 186 } 187 /* Free TM_DEV_RESET ccb */ 188 agtiapi_FreeTMCCB(pCard, pccb); 189 } 190 } 191 break; 192 case tiIntrEventTypeLocalAbort: 193 AGTIAPI_PRINTK("tiIntrEventTypeLocalAbort!\n"); 194 pccb = (pccb_t)((tiIORequest_t *)parm)->osData; 195 pccb->flags |= AGTIAPI_CB_DONE; 196 if (eventStatus == tiAbortOK) 197 { 198 AGTIAPI_PRINTK("tiIntrEventTypeLocalAbort: taskTag pccb %p flag %x \n", 199 pccb, pccb->flags); 200 /* If this was LocalAbort for TM ABORT_TASK, issue TM_DEV_RESET */ 201 if (pccb->flags & TASK_MANAGEMENT) 202 { 203 if ((pTMccb = agtiapi_GetCCB(pCard)) == NULL) 204 { 205 AGTIAPI_PRINTK("tiIntrEventTypeLocalAbort: TM resource unavailable!\n"); 206 /* TODO: SoftReset here? */ 207 } 208 pTMccb->pmcsc = pCard; 209 pTMccb->targetId = pccb->targetId; 210 pTMccb->devHandle = pccb->devHandle; 211 212 /* save pending io to issue local abort at Task mgmt CB */ 213 pTMccb->pccbIO = pccb->pccbIO; 214 pTMccb->flags &= ~(TASK_SUCCESS | ACTIVE); 215 pTMccb->flags |= DEV_RESET; 216 if (tiINITaskManagement(&pCard->tiRoot, 217 pccb->devHandle, 218 AG_TARGET_WARM_RESET, 219 &pccb->tiSuperScsiRequest.scsiCmnd.lun, 220 &pccb->tiIORequest, 221 &pTMccb->tiIORequest) 222 == tiSuccess) 223 { 224 AGTIAPI_PRINTK("tiIntrEventTypeLocalAbort: TM_TARGET_RESET request success ccb %p, pTMccb %p\n", 225 pccb, pTMccb); 226 pTMccb->startTime = ticks; 227 } 228 else 229 { 230 AGTIAPI_PRINTK("tiIntrEventTypeLocalAbort: TM_TARGET_RESET request failed ccb %p, pTMccb %p\n", 231 pccb, pTMccb); 232 agtiapi_FreeTMCCB(pCard, pTMccb); 233 /* TODO: SoftReset here? */ 234 } 235 /* Free ABORT_TASK TM ccb */ 236 agtiapi_FreeTMCCB(pCard, pccb); 237 } 238 } 239 else if (eventStatus == tiAbortFailed) 240 { 241 /* TODO: */ 242 /* If TM_ABORT_TASK fails, issue TM_DEV_RESET */ 243 /* if TM_DEV_RESET fails, issue Soft_Reset */ 244 AGTIAPI_PRINTK("tiIntrEventTypeLocalAbort: Abort Failed pccb %p\n", pccb); 245 } 246 break; 247 default: 248 AGTIAPI_PRINTK("tiIntrEventType default!\n"); 249 break; 250 } 251 } 252 253 254 /****************************************************************************** 255 ostiInitiatorIOCompleted() 256 257 Purpose: 258 IO request completion call back 259 Parameters: 260 tiRoot_t *ptiRoot (IN) Pointer to the HBA tiRoot 261 tiIORequest_t *ptiIORequest (IN) Pointer to the tiIORequest structure 262 tiIOStatus_t IOStatus (IN) I/O complated status 263 U32 statusDetail (IN) Additional information on status 264 tiSenseData_t *pSensedata (IN) Sense data buffer pointer 265 U32 context (IN) Interrupt dealing context 266 Returns: 267 Note: 268 ******************************************************************************/ 269 void 270 ostiInitiatorIOCompleted(tiRoot_t *ptiRoot, 271 tiIORequest_t *ptiIORequest, 272 tiIOStatus_t IOStatus, 273 U32 statusDetail, 274 tiSenseData_t *pSenseData, 275 U32 context ) 276 { 277 struct agtiapi_softc *pCard; 278 ccb_t *pccb; 279 280 pCard = TIROOT_TO_CARD(ptiRoot); 281 pccb = (ccb_t *)ptiIORequest->osData; 282 283 AGTIAPI_IO( "ostiInitiatorIOCompleted: start\n" ); 284 285 if (IOStatus == tiIODifError) 286 { 287 return; 288 } 289 OSTI_OUT_ENTER(ptiRoot); 290 291 pccb->ccbStatus = (U16)IOStatus; 292 pccb->scsiStatus = statusDetail; 293 294 if ((IOStatus == tiIOSuccess) && (statusDetail == SCSI_CHECK_CONDITION)) 295 { 296 if (pSenseData == (tiSenseData_t *)agNULL) 297 { 298 AGTIAPI_PRINTK( "ostiInitiatorIOCompleted: " 299 "check condition without sense data!\n" ); 300 } 301 else 302 { 303 union ccb *ccb = pccb->ccb; 304 struct ccb_scsiio *csio = &ccb->csio; 305 int sense_len = 0; 306 if (pccb->senseLen > pSenseData->senseLen) 307 { 308 csio->sense_resid = pccb->senseLen - pSenseData->senseLen; 309 } 310 else 311 { 312 csio->sense_resid = 0; 313 } 314 sense_len = MIN( pSenseData->senseLen, 315 pccb->senseLen - csio->sense_resid ); 316 bzero(&csio->sense_data, sizeof(csio->sense_data)); 317 AGTIAPI_PRINTK("ostiInitiatorIOCompleted: check condition copying\n"); 318 memcpy( (void *)pccb->pSenseData, 319 pSenseData->senseData, 320 sense_len ); 321 agtiapi_hexdump( "ostiInitiatorIOCompleted check condition", 322 (bit8 *)&csio->sense_data, sense_len ); 323 } 324 } 325 if ((IOStatus == tiIOFailed) && (statusDetail == tiDetailAborted)) 326 { 327 AGTIAPI_PRINTK("ostiInitiatorIOCompleted - aborted ccb %p, flag %x\n", 328 pccb, pccb->flags); 329 /* indicate aborted IO completion */ 330 pccb->startTime = 0; 331 agtiapi_Done(pCard, pccb); 332 } 333 else 334 { 335 #ifdef AGTIAPI_SA 336 /* 337 * SAS no data command does not trigger interrupt. 338 * Command is completed in tdlayer and IO completion is called directly. 339 * The completed IO therefore is not post processed. 340 * Flag is raised and TDTimer will check and process IO for SAS. 341 * This is a temporary solution. - Eddie, 07-17-2006 342 */ 343 pCard->flags |= AGTIAPI_FLAG_UP; 344 #endif 345 pccb->flags |= REQ_DONE; 346 agtiapi_QueueCCB(pCard, &pCard->ccbDoneHead, &pCard->ccbDoneTail 347 AG_CARD_LOCAL_LOCK(&pCard->doneLock), pccb); 348 } 349 OSTI_OUT_LEAVE(ptiRoot); 350 return; 351 } 352 #ifdef HIALEAH_ENCRYPTION 353 osGLOBAL void 354 ostidisableEncryption(tiRoot_t *ptiRoot) 355 { 356 struct agtiapi_softc *pCard; 357 pCard = TIROOT_TO_CARD(ptiRoot); 358 pCard->encrypt=agFALSE; 359 } 360 #endif 361 /* device Handle */ 362 osGLOBAL //FORCEINLINE 363 tiDeviceHandle_t* 364 ostiGetDevHandleFromSasAddr( 365 tiRoot_t *root, 366 unsigned char *sas_addr 367 ) 368 { 369 int i; 370 unsigned long x; 371 372 ag_portal_data_t *pPortal = NULL; 373 tiDeviceHandle_t *devHandle = NULL; 374 struct agtiapi_softc *pCard = TIROOT_TO_CARD(root); 375 bit8 sas_addr_hi[4], sas_addr_lo[4]; 376 377 378 for(i=0; i<4; i++) 379 { 380 sas_addr_hi[i] = sas_addr[3-i]; 381 } 382 383 for(i=0; i<4; i++) 384 { 385 sas_addr_lo[i] = sas_addr[7-i]; 386 } 387 388 /* Retrieve the handles for each portal */ 389 for (x=0; x < pCard->portCount; x++) 390 { 391 pPortal = &pCard->pPortalData[x]; 392 devHandle = tiINIGetExpDeviceHandleBySasAddress(&pCard->tiRoot, 393 &pPortal->portalInfo.tiPortalContext, 394 *(bit32*)sas_addr_hi, 395 *(bit32*)sas_addr_lo, 396 (bit32)1024/*gMaxTargets*/); 397 if(devHandle != NULL) 398 break; 399 } 400 return devHandle; 401 402 return NULL; 403 } 404 /****************************************************************************** 405 ostiInitiatorSMPCompleted() 406 407 Purpose: 408 IO request completion call back 409 Parameters: 410 tiRoot_t *ptiRoot (IN) Pointer to the HBA tiRoot 411 tiIORequest_t *ptiSMPRequest (IN) Pointer to the SMP request structure 412 tiIOStatus_t IOStatus (IN) I/O complated status 413 U32 tiSMPInfoLen (IN) Number of bytes of response frame len 414 tiFrameHandle (IN) Handle that referes to response frame 415 U32 context (IN) Interrupt dealing context 416 Returns: 417 Note: 418 ******************************************************************************/ 419 void 420 ostiInitiatorSMPCompleted(tiRoot_t *ptiRoot, 421 tiIORequest_t *ptiSMPRequest, 422 tiSMPStatus_t smpStatus, 423 bit32 tiSMPInfoLen, 424 void *tiFrameHandle, 425 bit32 context) 426 { 427 struct agtiapi_softc *pCard; 428 ccb_t *pccb; 429 pCard = TIROOT_TO_CARD(ptiRoot); 430 pccb = (ccb_t *)ptiSMPRequest->osData; 431 432 AGTIAPI_PRINTK("ostiInitiatorSMPCompleted: start\n"); 433 434 OSTI_OUT_ENTER(ptiRoot); 435 pccb->ccbStatus = (U16)smpStatus; 436 if(smpStatus != tiSMPSuccess) 437 { 438 AGTIAPI_PRINTK("ostiInitiatorSMPCompleted: SMP Error\n"); 439 } 440 else 441 { 442 union ccb *ccb = pccb->ccb; 443 struct ccb_smpio *csmpio = &ccb->smpio; 444 memcpy(csmpio->smp_response, tiFrameHandle, tiSMPInfoLen); 445 csmpio->smp_response_len = tiSMPInfoLen; 446 agtiapi_hexdump("ostiInitiatorSMPCompleted: Response Payload in CAM", (bit8 *)csmpio->smp_response, csmpio->smp_response_len); 447 } 448 pccb->flags |= REQ_DONE; 449 agtiapi_QueueCCB(pCard, &pCard->smpDoneHead, &pCard->smpDoneTail 450 AG_CARD_LOCAL_LOCK(&pCard->doneSMPLock), pccb); 451 AGTIAPI_PRINTK("ostiInitiatorSMPCompleted: Done\n"); 452 OSTI_OUT_LEAVE(ptiRoot); 453 454 return; 455 } 456 457 #ifdef FAST_IO_TEST 458 void 459 osti_FastIOCb(tiRoot_t *ptiRoot, 460 void *arg, 461 tiIOStatus_t IOStatus, 462 U32 statusDetail) 463 { 464 ccb_t *pccb = (ccb_t*)arg; 465 ag_card_t *pCard; 466 467 static int callNum = 0; 468 469 callNum++; 470 471 BUG_ON(!pccb); 472 473 if ((callNum % CMDS_PER_IO_DUP) != 0) 474 { 475 goto err; 476 } 477 478 pccb->ccbStatus = IOStatus; 479 pccb->scsiStatus = statusDetail; 480 481 /* pccb->pSenseData is copied already */ 482 483 if (pccb->flags & AGTIAPI_ABORT) 484 { 485 AGTIAPI_PRINTK("agtiapi_SuperIOCb: aborted ccb %p, flag %x\n", 486 pccb, pccb->flags); 487 pccb->startTime = 0; /* indicate aborted IO completion */ 488 BUG_ON(1); 489 goto err; 490 } 491 pCard = TIROOT_TO_CARD(ptiRoot); 492 pccb->flags |= REQ_DONE; 493 agtiapi_QueueCCB(pCard, &pCard->ccbDoneHead, &pCard->ccbDoneTail 494 AG_CARD_LOCAL_LOCK(&pCard->doneLock), pccb); 495 err: 496 return; 497 } /* osti_FastIOCb */ 498 #endif 499 500 501 /****************************************************************************** 502 ostiSingleThreadedEnter() 503 504 Purpose: 505 Critical region code excution protection. 506 Parameters: 507 tiRoot_t *ptiRoot (IN) Pointer to tiRoot data structure 508 U32 queueId (IN) spinlock Id 509 Returns: 510 Note: 511 Lock is held by oslayer. 512 ******************************************************************************/ 513 void 514 ostiSingleThreadedEnter(tiRoot_t *ptiRoot, U32 queueId) 515 { 516 struct agtiapi_softc *pCard = TIROOT_TO_CARD(ptiRoot); 517 mtx_lock( &pCard->STLock[queueId] ); // review: need irq save? ## 518 } 519 520 521 /****************************************************************************** 522 ostiSingleThreadedLeave() 523 524 Purpose: 525 Restore multi-threading environment. 526 Parameters: 527 tiRoot_t *ptiRoot (IN) Pointer to the tiRoot data structure 528 U32 queueId (IN) spinlock Id 529 Returns: 530 Note: 531 Lock is held by oslayer. 532 ******************************************************************************/ 533 void 534 ostiSingleThreadedLeave(tiRoot_t *ptiRoot, U32 queueId) 535 { 536 struct agtiapi_softc *pCard = TIROOT_TO_CARD(ptiRoot); 537 mtx_unlock( &pCard->STLock[queueId] ); // review: need irq restore? ## 538 } 539 540 541 osGLOBAL tiDeviceHandle_t* 542 ostiMapToDevHandle(tiRoot_t *root, 543 bit8 pathId, 544 bit8 targetId, 545 bit8 LUN 546 ) 547 { 548 tiDeviceHandle_t *dev = NULL; 549 struct agtiapi_softc *pCard; 550 bit32 offset; 551 552 pCard = TIROOT_TO_CARD(root); 553 554 offset = pathId * pCard->tgtCount + targetId; 555 556 if (offset > (pCard->tgtCount - 1) ) 557 { 558 dev = NULL; 559 } 560 else 561 { 562 dev = pCard->pDevList[offset].pDevHandle; 563 } 564 565 return dev; 566 } 567 568 569 570 #ifdef PERF_COUNT 571 572 #ifdef AGTIAPI_LOCAL_LOCK 573 #define OSTI_SPIN_LOCK(lock) spin_lock(lock) 574 #define OSTI_SPIN_UNLOCK(lock) spin_unlock(lock) 575 #else 576 #define OSTI_SPIN_LOCK(lock) 577 #define OSTI_SPIN_UNLOCK(lock) 578 #endif 579 580 581 void 582 ostiEnter(tiRoot_t *ptiRoot, U32 layer, int io) 583 { 584 ag_card_t *pCard = ((ag_card_info_t*)ptiRoot->osData)->pCard; 585 int ini = ((pCard->flags & AGTIAPI_INIT_TIME) == AGTIAPI_INIT_TIME); 586 587 BUG_ON((io != 0 && io != 1) || (layer != 0 && layer != 1 && layer != 2)); 588 if (!ini) 589 { 590 unsigned long long cycles = get_cycles(); 591 592 OSTI_SPIN_LOCK(&pCard->latLock); 593 BUG_ON(pCard->callLevel[io] >= sizeof(pCard->layer[0]) / 594 sizeof(pCard->layer[0][0])); 595 if (pCard->callLevel[io] > 0) 596 { 597 unsigned int prev_layer = pCard->layer[io][pCard->callLevel[io] - 1]; 598 599 pCard->totalCycles[io][prev_layer] += cycles - 600 pCard->enterCycles[io][prev_layer]; 601 } 602 pCard->enterCycles[io][layer] = cycles; 603 pCard->layer[io][pCard->callLevel[io]] = layer; 604 pCard->callLevel[io]++; 605 OSTI_SPIN_UNLOCK(&pCard->latLock); 606 } 607 } 608 609 void 610 ostiLeave(tiRoot_t *ptiRoot, U32 layer, int io) 611 { 612 ag_card_t *pCard = ((ag_card_info_t*)ptiRoot->osData)->pCard; 613 int ini = ((pCard->flags & AGTIAPI_INIT_TIME) == AGTIAPI_INIT_TIME); 614 615 BUG_ON((io != 0 && io != 1) || (layer != 0 && layer != 1 && layer != 2)); 616 if (!ini) 617 { 618 unsigned long long cycles = get_cycles(); 619 620 OSTI_SPIN_LOCK(&pCard->latLock); 621 pCard->callLevel[io]--; 622 623 BUG_ON(pCard->callLevel[io] < 0); 624 BUG_ON(pCard->layer[io][pCard->callLevel[io]] != layer); 625 626 pCard->totalCycles[io][layer] += cycles - pCard->enterCycles[io][layer]; 627 if (pCard->callLevel[io] > 0) 628 pCard->enterCycles[io][pCard->layer[io][pCard->callLevel[io] - 1]] = 629 cycles; 630 OSTI_SPIN_UNLOCK(&pCard->latLock); 631 } 632 } 633 #endif 634 635 636 637 osGLOBAL FORCEINLINE bit8 638 ostiBitScanForward( 639 tiRoot_t *root, 640 bit32 *Index, 641 bit32 Mask 642 ) 643 { 644 return 1; 645 646 } 647 648 #ifdef REMOVED 649 osGLOBAL sbit32 650 ostiAtomicIncrement( 651 tiRoot_t *root, 652 sbit32 volatile *Addend 653 ) 654 { 655 return 1; 656 657 } 658 659 osGLOBAL sbit32 660 ostiAtomicDecrement( 661 tiRoot_t *root, 662 sbit32 volatile *Addend 663 ) 664 { 665 666 return 1; 667 668 } 669 670 osGLOBAL sbit32 671 ostiAtomicBitClear( 672 tiRoot_t *root, 673 sbit32 volatile *Destination, 674 sbit32 Value 675 ) 676 { 677 678 return 0; 679 680 } 681 682 osGLOBAL sbit32 683 ostiAtomicBitSet( 684 tiRoot_t *root, 685 sbit32 volatile *Destination, 686 sbit32 Value 687 ) 688 { 689 return 0; 690 691 /* 692 set_bit(Value, (volatile unsigned long *)Destination); 693 return 0; 694 */ 695 } 696 697 osGLOBAL sbit32 698 ostiAtomicExchange( 699 tiRoot_t *root, 700 sbit32 volatile *Target, 701 sbit32 Value 702 ) 703 { 704 return 0; 705 706 } 707 #endif 708 709 osGLOBAL FORCEINLINE sbit32 710 ostiInterlockedExchange( 711 tiRoot_t *root, 712 sbit32 volatile *Target, 713 sbit32 Value 714 ) 715 { 716 return 0; 717 } 718 719 osGLOBAL FORCEINLINE sbit32 720 ostiInterlockedIncrement( 721 tiRoot_t *root, 722 sbit32 volatile *Addend 723 ) 724 { 725 return 0; 726 } 727 728 osGLOBAL FORCEINLINE sbit32 729 ostiInterlockedDecrement( 730 tiRoot_t *root, 731 sbit32 volatile *Addend 732 ) 733 { 734 return 0; 735 } 736 737 osGLOBAL FORCEINLINE sbit32 738 ostiInterlockedAnd( 739 tiRoot_t *root, 740 sbit32 volatile *Destination, 741 sbit32 Value 742 ) 743 { 744 return 0; 745 } 746 747 osGLOBAL FORCEINLINE sbit32 748 ostiInterlockedOr( 749 tiRoot_t *root, 750 sbit32 volatile *Destination, 751 sbit32 Value 752 ) 753 { 754 return 0; 755 } 756 757 // this is just stub code to allow compile and use of the module ... 758 // now that a call to this function has been added with windows specific 759 // intentions. 760 osGLOBAL bit32 761 ostiSetDeviceQueueDepth( tiRoot_t *tiRoot, 762 tiIORequest_t *tiIORequest, 763 bit32 QueueDepth 764 ) 765 { 766 bit32 retVal = 0; 767 struct agtiapi_softc *pCard = TIROOT_TO_CARD(tiRoot); 768 ccb_t *pccb = (ccb_t *) tiIORequest->osData; 769 tiDeviceHandle_t *tiDeviceHandle = pccb->devHandle; 770 ag_device_t *pDevice = (ag_device_t *)tiDeviceHandle->osData; 771 AGTIAPI_PRINTK( "ostiSetDeviceQueueDepth stub only: root%p, req%p, qdeep%d\n", 772 tiRoot, tiIORequest, QueueDepth ); 773 pDevice->qdepth = QueueDepth; 774 return retVal; 775 } 776 777 778 // this is just stub code to allow compile and use of the module ... 779 // now that a call to this function has been added with windows specific 780 // intentions. 781 osGLOBAL void 782 ostiGetSenseKeyCount(tiRoot_t *root, 783 bit32 fIsClear, 784 void *SenseKeyCount, 785 bit32 length 786 ) 787 { 788 AGTIAPI_PRINTK( "ostiGetSenseKeyCount stub only: rt%p, fcl%d, kyCt%p, ln%d\n", 789 root, fIsClear, SenseKeyCount, length ); 790 } 791 792 osGLOBAL void 793 ostiGetSCSIStatusCount(tiRoot_t *root, 794 bit32 fIsClear, 795 void *ScsiStatusCount, 796 bit32 length 797 ) 798 { 799 AGTIAPI_PRINTK( "ostiGetSCSIStatusCount: stub only rt%p, fcl%d, kyCt%p, ln%d\n", 800 root, fIsClear, ScsiStatusCount, length ); 801 802 } 803 804 osGLOBAL void ostiPCI_TRIGGER( tiRoot_t *tiRoot ) 805 { 806 ostiChipReadBit32Ext(tiRoot, 0, 0x5C); 807 808 } 809 810 osGLOBAL bit32 811 ostiNumOfLUNIOCTLreq( tiRoot_t *root, 812 void *param1, 813 void *param2, 814 void **tiRequestBody, 815 tiIORequest_t **tiIORequest 816 ) 817 { 818 bit32 status = IOCTL_CALL_SUCCESS; 819 pccb_t pccb; 820 AGTIAPI_PRINTK("ostiNumOfLUNIOCTLreq: start\n"); 821 struct agtiapi_softc *pCard = TIROOT_TO_CARD(root); 822 /* get a ccb */ 823 if ((pccb = agtiapi_GetCCB(pCard)) == NULL) 824 { 825 printf("ostiNumOfLUNIOCTLreq - GetCCB ERROR\n"); 826 status = IOCTL_CALL_FAIL; 827 //BUG_ON(1); 828 } 829 830 *tiIORequest = (tiIORequest_t*)&pccb->tiIORequest; 831 *tiRequestBody = &pccb->tdIOReqBody; 832 AGTIAPI_PRINTK("ostiNumOfLUNIOCTLreq:end\n"); 833 return status; 834 } 835 836