/******************************************************************************* *Copyright (c) 2014 PMC-Sierra, Inc. All rights reserved. * *Redistribution and use in source and binary forms, with or without modification, are permitted provided *that the following conditions are met: *1. Redistributions of source code must retain the above copyright notice, this list of conditions and the *following disclaimer. *2. Redistributions in binary form must reproduce the above copyright notice, *this list of conditions and the following disclaimer in the documentation and/or other materials provided *with the distribution. * *THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED *WARRANTIES,INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS *FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE *FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT *NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR *BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT *LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS *SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE * * *******************************************************************************/ /****************************************************************************** PMC-Sierra TISA Initiator Device Driver for Linux 2.x.x. Module Name: osapi.c Abstract: Linux iSCSI/FC Initiator driver module itsdk required OS functions Environment: Part of oslayer module, Kernel or loadable module ******************************************************************************* ostiInitiatorEvent() Purpose: TI layer call back to OSlayer to inform events Parameters: tiRoot_t *ptiRoot (IN) Pointer to HBA data structure tiDeviceHandle_t *ptiDevHandle (IN) Pointer to device handle tiIntrEvenType_t evenType (IN) Event type tiIntrEventStatus_t evetStatus (IN) Event status void *parm (IN) pointer to even specific data Return: Note: TBD, further event process required. ******************************************************************************/ void ostiInitiatorEvent( tiRoot_t *ptiRoot, tiPortalContext_t *ptiPortalContext, tiDeviceHandle_t *ptiDevHandle, tiIntrEventType_t eventType, U32 eventStatus, void *parm ) { ag_portal_data_t *pPortalData; ag_portal_info_t *pPortalInfo; struct agtiapi_softc *pCard = TIROOT_TO_CARD( ptiRoot ); ccb_t *pccb; ccb_t *pTMccb; ccb_t *ccbIO; #ifdef AGTIAPI_EVENT_LOG AGTIAPI_PRINTK("Initiator Event:\n"); AGTIAPI_PRINTK("DevHandle %p, eventType 0x%x, eventStatus 0x%x\n", ptiDevHandle, eventType, eventStatus); AGTIAPI_PRINTK("Parameter: %s\n", (char *)parm); #endif AGTIAPI_PRINTK("ostiInitiatorEvent: eventType 0x%x eventStatus 0x%x\n", eventType, eventStatus); switch (eventType) { case tiIntrEventTypeCnxError: if (eventStatus == tiCnxUp) { AGTIAPI_PRINTK("tiIntrEventTypeCnxError - tiCnxUp!\n"); } if (eventStatus == tiCnxDown) { AGTIAPI_PRINTK("tiIntrEventTypeCnxError - tiCnxDown!\n"); } break; case tiIntrEventTypeDiscovery: pPortalData = PORTAL_CONTEXT_TO_PORTALDATA(ptiPortalContext); pCard->flags |= AGTIAPI_CB_DONE; if (eventStatus == tiDiscOK) { AGTIAPI_PRINTK("eventStatus - tiDiscOK\n"); AGTIAPI_PRINTK("ostiInitiatorEvent: pcard %d eventStatus - tiDiscOK\n", pCard->cardNo ); PORTAL_STATUS(pPortalData) |= AGTIAPI_DISC_COMPLETE; #ifndef HOTPLUG_SUPPORT if (!(pCard->flags & AGTIAPI_INIT_TIME)) #else if (TRUE) #endif { agtiapi_GetDevHandle(pCard, &pPortalData->portalInfo, tiIntrEventTypeDiscovery, tiDiscOK); PORTAL_STATUS(pPortalData) |= (AGTIAPI_DISC_DONE | AGTIAPI_PORT_LINK_UP); } /* Trigger CheckIOTimeout */ callout_reset(&pCard->IO_timer, 20*hz, agtiapi_CheckIOTimeout, pCard); } else if (eventStatus == tiDiscFailed) { AGTIAPI_PRINTK("eventStatus - tiDiscFailed\n"); agtiapi_GetDevHandle(pCard, &pPortalData->portalInfo, tiIntrEventTypeDiscovery, tiDiscFailed); PORTAL_STATUS(pPortalData) &= ~AGTIAPI_DISC_DONE; } AGTIAPI_PRINTK("tiIntrEventTypeDiscovery - portal %p, status 0x%x\n", pPortalData, PORTAL_STATUS(pPortalData)); break; case tiIntrEventTypeDeviceChange: AGTIAPI_PRINTK("tiIntrEventTypeDeviceChange - portal %p es %d\n", ptiPortalContext->osData, eventStatus); pPortalData = PORTAL_CONTEXT_TO_PORTALDATA(ptiPortalContext); pPortalInfo = &pPortalData->portalInfo; #ifndef HOTPLUG_SUPPORT if (!(pCard->flags & AGTIAPI_INIT_TIME)) #else if (TRUE) #endif { agtiapi_GetDevHandle(pCard, pPortalInfo, tiIntrEventTypeDeviceChange, eventStatus); // agtiapi_StartIO(pCard); } break; case tiIntrEventTypeTransportRecovery: AGTIAPI_PRINTK("tiIntrEventTypeTransportRecovery!\n"); break; case tiIntrEventTypeTaskManagement: AGTIAPI_PRINTK("tiIntrEventTypeTaskManagement!\n"); pccb = (pccb_t)((tiIORequest_t *)parm)->osData; if (pccb->flags & TASK_TIMEOUT) { AGTIAPI_PRINTK("tiIntrEventTypeTaskManagement: TM timeout!\n"); agtiapi_FreeTMCCB(pCard, pccb); } else { pccb->flags |= AGTIAPI_CB_DONE; if (eventStatus == tiTMOK) { pccb->flags |= TASK_SUCCESS; AGTIAPI_PRINTK("tiIntrEventTypeTaskManagement: pTMccb %p flag %x \n", pccb, pccb->flags); /* Incase of TM_DEV_RESET, issue LocalAbort to abort pending IO */ if (pccb->flags & DEV_RESET) { AGTIAPI_PRINTK("tiIntrEventTypeTaskManagement: Target Reset\n"); ccbIO = pccb->pccbIO; AGTIAPI_PRINTK("tiIntrEventTypeTaskManagement: IO to be aborted locally %p flag %x \n", ccbIO, ccbIO->flags); if (ccbIO->startTime == 0) /* IO has been completed. No local abort */ { } else if (tiINIIOAbort(&pCard->tiRoot, &ccbIO->tiIORequest) != tiSuccess) { AGTIAPI_PRINTK("tiIntrEventTypeTaskManagement: Local Abort failed\n"); /* TODO: call Soft reset here */ } } else if (eventStatus == tiTMFailed) { ccbIO = pccb->pccbIO; if (ccbIO->startTime == 0) /* IO has been completed. */ { AGTIAPI_PRINTK("tiIntrEventTypeTaskManagement: TM failed because IO has been completed! pTMccb %p flag %x \n", pccb, pccb->flags); } else { AGTIAPI_PRINTK("tiIntrEventTypeTaskManagement: TM failed! pTMccb %p flag %x \n", pccb, pccb->flags); /* TODO:*/ /* if TM_ABORT_TASK, call TM_TARGET_RESET */ /* if TM_TARGET_RESET, call Soft_Reset */ } } /* Free TM_DEV_RESET ccb */ agtiapi_FreeTMCCB(pCard, pccb); } } break; case tiIntrEventTypeLocalAbort: AGTIAPI_PRINTK("tiIntrEventTypeLocalAbort!\n"); pccb = (pccb_t)((tiIORequest_t *)parm)->osData; pccb->flags |= AGTIAPI_CB_DONE; if (eventStatus == tiAbortOK) { AGTIAPI_PRINTK("tiIntrEventTypeLocalAbort: taskTag pccb %p flag %x \n", pccb, pccb->flags); /* If this was LocalAbort for TM ABORT_TASK, issue TM_DEV_RESET */ if (pccb->flags & TASK_MANAGEMENT) { if ((pTMccb = agtiapi_GetCCB(pCard)) == NULL) { AGTIAPI_PRINTK("tiIntrEventTypeLocalAbort: TM resource unavailable!\n"); /* TODO: SoftReset here? */ } pTMccb->pmcsc = pCard; pTMccb->targetId = pccb->targetId; pTMccb->devHandle = pccb->devHandle; /* save pending io to issue local abort at Task mgmt CB */ pTMccb->pccbIO = pccb->pccbIO; pTMccb->flags &= ~(TASK_SUCCESS | ACTIVE); pTMccb->flags |= DEV_RESET; if (tiINITaskManagement(&pCard->tiRoot, pccb->devHandle, AG_TARGET_WARM_RESET, &pccb->tiSuperScsiRequest.scsiCmnd.lun, &pccb->tiIORequest, &pTMccb->tiIORequest) == tiSuccess) { AGTIAPI_PRINTK("tiIntrEventTypeLocalAbort: TM_TARGET_RESET request success ccb %p, pTMccb %p\n", pccb, pTMccb); pTMccb->startTime = ticks; } else { AGTIAPI_PRINTK("tiIntrEventTypeLocalAbort: TM_TARGET_RESET request failed ccb %p, pTMccb %p\n", pccb, pTMccb); agtiapi_FreeTMCCB(pCard, pTMccb); /* TODO: SoftReset here? */ } /* Free ABORT_TASK TM ccb */ agtiapi_FreeTMCCB(pCard, pccb); } } else if (eventStatus == tiAbortFailed) { /* TODO: */ /* If TM_ABORT_TASK fails, issue TM_DEV_RESET */ /* if TM_DEV_RESET fails, issue Soft_Reset */ AGTIAPI_PRINTK("tiIntrEventTypeLocalAbort: Abort Failed pccb %p\n", pccb); } break; default: AGTIAPI_PRINTK("tiIntrEventType default!\n"); break; } } /****************************************************************************** ostiInitiatorIOCompleted() Purpose: IO request completion call back Parameters: tiRoot_t *ptiRoot (IN) Pointer to the HBA tiRoot tiIORequest_t *ptiIORequest (IN) Pointer to the tiIORequest structure tiIOStatus_t IOStatus (IN) I/O complated status U32 statusDetail (IN) Additional information on status tiSenseData_t *pSensedata (IN) Sense data buffer pointer U32 context (IN) Interrupt dealing context Returns: Note: ******************************************************************************/ void ostiInitiatorIOCompleted(tiRoot_t *ptiRoot, tiIORequest_t *ptiIORequest, tiIOStatus_t IOStatus, U32 statusDetail, tiSenseData_t *pSenseData, U32 context ) { struct agtiapi_softc *pCard; ccb_t *pccb; pCard = TIROOT_TO_CARD(ptiRoot); pccb = (ccb_t *)ptiIORequest->osData; AGTIAPI_IO( "ostiInitiatorIOCompleted: start\n" ); if (IOStatus == tiIODifError) { return; } OSTI_OUT_ENTER(ptiRoot); pccb->ccbStatus = (U16)IOStatus; pccb->scsiStatus = statusDetail; if ((IOStatus == tiIOSuccess) && (statusDetail == SCSI_CHECK_CONDITION)) { if (pSenseData == (tiSenseData_t *)agNULL) { AGTIAPI_PRINTK( "ostiInitiatorIOCompleted: " "check condition without sense data!\n" ); } else { union ccb *ccb = pccb->ccb; struct ccb_scsiio *csio = &ccb->csio; int sense_len = 0; if (pccb->senseLen > pSenseData->senseLen) { csio->sense_resid = pccb->senseLen - pSenseData->senseLen; } else { csio->sense_resid = 0; } sense_len = MIN( pSenseData->senseLen, pccb->senseLen - csio->sense_resid ); bzero(&csio->sense_data, sizeof(csio->sense_data)); AGTIAPI_PRINTK("ostiInitiatorIOCompleted: check condition copying\n"); memcpy( (void *)pccb->pSenseData, pSenseData->senseData, sense_len ); agtiapi_hexdump( "ostiInitiatorIOCompleted check condition", (bit8 *)&csio->sense_data, sense_len ); } } if ((IOStatus == tiIOFailed) && (statusDetail == tiDetailAborted)) { AGTIAPI_PRINTK("ostiInitiatorIOCompleted - aborted ccb %p, flag %x\n", pccb, pccb->flags); /* indicate aborted IO completion */ pccb->startTime = 0; agtiapi_Done(pCard, pccb); } else { #ifdef AGTIAPI_SA /* * SAS no data command does not trigger interrupt. * Command is completed in tdlayer and IO completion is called directly. * The completed IO therefore is not post processed. * Flag is raised and TDTimer will check and process IO for SAS. * This is a temporary solution. - Eddie, 07-17-2006 */ pCard->flags |= AGTIAPI_FLAG_UP; #endif pccb->flags |= REQ_DONE; agtiapi_QueueCCB(pCard, &pCard->ccbDoneHead, &pCard->ccbDoneTail AG_CARD_LOCAL_LOCK(&pCard->doneLock), pccb); } OSTI_OUT_LEAVE(ptiRoot); return; } #ifdef HIALEAH_ENCRYPTION osGLOBAL void ostidisableEncryption(tiRoot_t *ptiRoot) { struct agtiapi_softc *pCard; pCard = TIROOT_TO_CARD(ptiRoot); pCard->encrypt=agFALSE; } #endif /* device Handle */ osGLOBAL //FORCEINLINE tiDeviceHandle_t* ostiGetDevHandleFromSasAddr( tiRoot_t *root, unsigned char *sas_addr ) { int i; unsigned long x; ag_portal_data_t *pPortal = NULL; tiDeviceHandle_t *devHandle = NULL; struct agtiapi_softc *pCard = TIROOT_TO_CARD(root); bit8 sas_addr_hi[4], sas_addr_lo[4]; for(i=0; i<4; i++) { sas_addr_hi[i] = sas_addr[3-i]; } for(i=0; i<4; i++) { sas_addr_lo[i] = sas_addr[7-i]; } /* Retrieve the handles for each portal */ for (x=0; x < pCard->portCount; x++) { pPortal = &pCard->pPortalData[x]; devHandle = tiINIGetExpDeviceHandleBySasAddress(&pCard->tiRoot, &pPortal->portalInfo.tiPortalContext, *(bit32*)sas_addr_hi, *(bit32*)sas_addr_lo, (bit32)1024/*gMaxTargets*/); if(devHandle != NULL) break; } return devHandle; return NULL; } /****************************************************************************** ostiInitiatorSMPCompleted() Purpose: IO request completion call back Parameters: tiRoot_t *ptiRoot (IN) Pointer to the HBA tiRoot tiIORequest_t *ptiSMPRequest (IN) Pointer to the SMP request structure tiIOStatus_t IOStatus (IN) I/O complated status U32 tiSMPInfoLen (IN) Number of bytes of response frame len tiFrameHandle (IN) Handle that referes to response frame U32 context (IN) Interrupt dealing context Returns: Note: ******************************************************************************/ void ostiInitiatorSMPCompleted(tiRoot_t *ptiRoot, tiIORequest_t *ptiSMPRequest, tiSMPStatus_t smpStatus, bit32 tiSMPInfoLen, void *tiFrameHandle, bit32 context) { struct agtiapi_softc *pCard; ccb_t *pccb; pCard = TIROOT_TO_CARD(ptiRoot); pccb = (ccb_t *)ptiSMPRequest->osData; AGTIAPI_PRINTK("ostiInitiatorSMPCompleted: start\n"); OSTI_OUT_ENTER(ptiRoot); pccb->ccbStatus = (U16)smpStatus; if(smpStatus != tiSMPSuccess) { AGTIAPI_PRINTK("ostiInitiatorSMPCompleted: SMP Error\n"); } else { union ccb *ccb = pccb->ccb; struct ccb_smpio *csmpio = &ccb->smpio; memcpy(csmpio->smp_response, tiFrameHandle, tiSMPInfoLen); csmpio->smp_response_len = tiSMPInfoLen; agtiapi_hexdump("ostiInitiatorSMPCompleted: Response Payload in CAM", (bit8 *)csmpio->smp_response, csmpio->smp_response_len); } pccb->flags |= REQ_DONE; agtiapi_QueueCCB(pCard, &pCard->smpDoneHead, &pCard->smpDoneTail AG_CARD_LOCAL_LOCK(&pCard->doneSMPLock), pccb); AGTIAPI_PRINTK("ostiInitiatorSMPCompleted: Done\n"); OSTI_OUT_LEAVE(ptiRoot); return; } #ifdef FAST_IO_TEST void osti_FastIOCb(tiRoot_t *ptiRoot, void *arg, tiIOStatus_t IOStatus, U32 statusDetail) { ccb_t *pccb = (ccb_t*)arg; ag_card_t *pCard; static int callNum = 0; callNum++; BUG_ON(!pccb); if ((callNum % CMDS_PER_IO_DUP) != 0) { goto err; } pccb->ccbStatus = IOStatus; pccb->scsiStatus = statusDetail; /* pccb->pSenseData is copied already */ if (pccb->flags & AGTIAPI_ABORT) { AGTIAPI_PRINTK("agtiapi_SuperIOCb: aborted ccb %p, flag %x\n", pccb, pccb->flags); pccb->startTime = 0; /* indicate aborted IO completion */ BUG_ON(1); goto err; } pCard = TIROOT_TO_CARD(ptiRoot); pccb->flags |= REQ_DONE; agtiapi_QueueCCB(pCard, &pCard->ccbDoneHead, &pCard->ccbDoneTail AG_CARD_LOCAL_LOCK(&pCard->doneLock), pccb); err: return; } /* osti_FastIOCb */ #endif /****************************************************************************** ostiSingleThreadedEnter() Purpose: Critical region code excution protection. Parameters: tiRoot_t *ptiRoot (IN) Pointer to tiRoot data structure U32 queueId (IN) spinlock Id Returns: Note: Lock is held by oslayer. ******************************************************************************/ void ostiSingleThreadedEnter(tiRoot_t *ptiRoot, U32 queueId) { struct agtiapi_softc *pCard = TIROOT_TO_CARD(ptiRoot); mtx_lock( &pCard->STLock[queueId] ); // review: need irq save? ## } /****************************************************************************** ostiSingleThreadedLeave() Purpose: Restore multi-threading environment. Parameters: tiRoot_t *ptiRoot (IN) Pointer to the tiRoot data structure U32 queueId (IN) spinlock Id Returns: Note: Lock is held by oslayer. ******************************************************************************/ void ostiSingleThreadedLeave(tiRoot_t *ptiRoot, U32 queueId) { struct agtiapi_softc *pCard = TIROOT_TO_CARD(ptiRoot); mtx_unlock( &pCard->STLock[queueId] ); // review: need irq restore? ## } osGLOBAL tiDeviceHandle_t* ostiMapToDevHandle(tiRoot_t *root, bit8 pathId, bit8 targetId, bit8 LUN ) { tiDeviceHandle_t *dev = NULL; struct agtiapi_softc *pCard; bit32 offset; pCard = TIROOT_TO_CARD(root); offset = pathId * pCard->tgtCount + targetId; if (offset > (pCard->tgtCount - 1) ) { dev = NULL; } else { dev = pCard->pDevList[offset].pDevHandle; } return dev; } #ifdef PERF_COUNT #ifdef AGTIAPI_LOCAL_LOCK #define OSTI_SPIN_LOCK(lock) spin_lock(lock) #define OSTI_SPIN_UNLOCK(lock) spin_unlock(lock) #else #define OSTI_SPIN_LOCK(lock) #define OSTI_SPIN_UNLOCK(lock) #endif void ostiEnter(tiRoot_t *ptiRoot, U32 layer, int io) { ag_card_t *pCard = ((ag_card_info_t*)ptiRoot->osData)->pCard; int ini = ((pCard->flags & AGTIAPI_INIT_TIME) == AGTIAPI_INIT_TIME); BUG_ON((io != 0 && io != 1) || (layer != 0 && layer != 1 && layer != 2)); if (!ini) { unsigned long long cycles = get_cycles(); OSTI_SPIN_LOCK(&pCard->latLock); BUG_ON(pCard->callLevel[io] >= sizeof(pCard->layer[0]) / sizeof(pCard->layer[0][0])); if (pCard->callLevel[io] > 0) { unsigned int prev_layer = pCard->layer[io][pCard->callLevel[io] - 1]; pCard->totalCycles[io][prev_layer] += cycles - pCard->enterCycles[io][prev_layer]; } pCard->enterCycles[io][layer] = cycles; pCard->layer[io][pCard->callLevel[io]] = layer; pCard->callLevel[io]++; OSTI_SPIN_UNLOCK(&pCard->latLock); } } void ostiLeave(tiRoot_t *ptiRoot, U32 layer, int io) { ag_card_t *pCard = ((ag_card_info_t*)ptiRoot->osData)->pCard; int ini = ((pCard->flags & AGTIAPI_INIT_TIME) == AGTIAPI_INIT_TIME); BUG_ON((io != 0 && io != 1) || (layer != 0 && layer != 1 && layer != 2)); if (!ini) { unsigned long long cycles = get_cycles(); OSTI_SPIN_LOCK(&pCard->latLock); pCard->callLevel[io]--; BUG_ON(pCard->callLevel[io] < 0); BUG_ON(pCard->layer[io][pCard->callLevel[io]] != layer); pCard->totalCycles[io][layer] += cycles - pCard->enterCycles[io][layer]; if (pCard->callLevel[io] > 0) pCard->enterCycles[io][pCard->layer[io][pCard->callLevel[io] - 1]] = cycles; OSTI_SPIN_UNLOCK(&pCard->latLock); } } #endif osGLOBAL FORCEINLINE bit8 ostiBitScanForward( tiRoot_t *root, bit32 *Index, bit32 Mask ) { return 1; } #ifdef REMOVED osGLOBAL sbit32 ostiAtomicIncrement( tiRoot_t *root, sbit32 volatile *Addend ) { return 1; } osGLOBAL sbit32 ostiAtomicDecrement( tiRoot_t *root, sbit32 volatile *Addend ) { return 1; } osGLOBAL sbit32 ostiAtomicBitClear( tiRoot_t *root, sbit32 volatile *Destination, sbit32 Value ) { return 0; } osGLOBAL sbit32 ostiAtomicBitSet( tiRoot_t *root, sbit32 volatile *Destination, sbit32 Value ) { return 0; /* set_bit(Value, (volatile unsigned long *)Destination); return 0; */ } osGLOBAL sbit32 ostiAtomicExchange( tiRoot_t *root, sbit32 volatile *Target, sbit32 Value ) { return 0; } #endif osGLOBAL FORCEINLINE sbit32 ostiInterlockedExchange( tiRoot_t *root, sbit32 volatile *Target, sbit32 Value ) { return 0; } osGLOBAL FORCEINLINE sbit32 ostiInterlockedIncrement( tiRoot_t *root, sbit32 volatile *Addend ) { return 0; } osGLOBAL FORCEINLINE sbit32 ostiInterlockedDecrement( tiRoot_t *root, sbit32 volatile *Addend ) { return 0; } osGLOBAL FORCEINLINE sbit32 ostiInterlockedAnd( tiRoot_t *root, sbit32 volatile *Destination, sbit32 Value ) { return 0; } osGLOBAL FORCEINLINE sbit32 ostiInterlockedOr( tiRoot_t *root, sbit32 volatile *Destination, sbit32 Value ) { return 0; } // this is just stub code to allow compile and use of the module ... // now that a call to this function has been added with windows specific // intentions. osGLOBAL bit32 ostiSetDeviceQueueDepth( tiRoot_t *tiRoot, tiIORequest_t *tiIORequest, bit32 QueueDepth ) { bit32 retVal = 0; ccb_t *pccb = (ccb_t *) tiIORequest->osData; tiDeviceHandle_t *tiDeviceHandle = pccb->devHandle; ag_device_t *pDevice = (ag_device_t *)tiDeviceHandle->osData; AGTIAPI_PRINTK( "ostiSetDeviceQueueDepth stub only: root%p, req%p, qdeep%d\n", tiRoot, tiIORequest, QueueDepth ); pDevice->qdepth = QueueDepth; return retVal; } // this is just stub code to allow compile and use of the module ... // now that a call to this function has been added with windows specific // intentions. osGLOBAL void ostiGetSenseKeyCount(tiRoot_t *root, bit32 fIsClear, void *SenseKeyCount, bit32 length ) { AGTIAPI_PRINTK( "ostiGetSenseKeyCount stub only: rt%p, fcl%d, kyCt%p, ln%d\n", root, fIsClear, SenseKeyCount, length ); } osGLOBAL void ostiGetSCSIStatusCount(tiRoot_t *root, bit32 fIsClear, void *ScsiStatusCount, bit32 length ) { AGTIAPI_PRINTK( "ostiGetSCSIStatusCount: stub only rt%p, fcl%d, kyCt%p, ln%d\n", root, fIsClear, ScsiStatusCount, length ); } osGLOBAL void ostiPCI_TRIGGER( tiRoot_t *tiRoot ) { ostiChipReadBit32Ext(tiRoot, 0, 0x5C); } osGLOBAL bit32 ostiNumOfLUNIOCTLreq( tiRoot_t *root, void *param1, void *param2, void **tiRequestBody, tiIORequest_t **tiIORequest ) { bit32 status = IOCTL_CALL_SUCCESS; pccb_t pccb; AGTIAPI_PRINTK("ostiNumOfLUNIOCTLreq: start\n"); struct agtiapi_softc *pCard = TIROOT_TO_CARD(root); /* get a ccb */ if ((pccb = agtiapi_GetCCB(pCard)) == NULL) { printf("ostiNumOfLUNIOCTLreq - GetCCB ERROR\n"); status = IOCTL_CALL_FAIL; //BUG_ON(1); } *tiIORequest = (tiIORequest_t*)&pccb->tiIORequest; *tiRequestBody = &pccb->tdIOReqBody; AGTIAPI_PRINTK("ostiNumOfLUNIOCTLreq:end\n"); return status; }