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 /*******************************************************************************/ 23 /** \file 24 * 25 * 26 * This file contains Management IOCTL APIs 27 * 28 */ 29 #include <sys/cdefs.h> 30 __FBSDID("$FreeBSD$"); 31 #include <dev/pms/config.h> 32 33 #include <dev/pms/freebsd/driver/common/osenv.h> 34 #include <dev/pms/freebsd/driver/common/ostypes.h> 35 #include <dev/pms/freebsd/driver/common/osdebug.h> 36 37 #include <dev/pms/RefTisa/sallsdk/api/sa.h> 38 #include <dev/pms/RefTisa/sallsdk/api/saapi.h> 39 #include <dev/pms/RefTisa/sallsdk/api/saosapi.h> 40 41 #include <dev/pms/RefTisa/tisa/api/titypes.h> 42 #include <dev/pms/RefTisa/tisa/api/ostiapi.h> 43 #include <dev/pms/RefTisa/tisa/api/tiapi.h> 44 #include <dev/pms/RefTisa/tisa/api/tiglobal.h> 45 46 #ifdef FDS_SM 47 #include <dev/pms/RefTisa/sat/api/sm.h> 48 #include <dev/pms/RefTisa/sat/api/smapi.h> 49 #include <dev/pms/RefTisa/sat/api/tdsmapi.h> 50 #endif 51 52 #ifdef FDS_DM 53 #include <dev/pms/RefTisa/discovery/api/dm.h> 54 #include <dev/pms/RefTisa/discovery/api/dmapi.h> 55 #include <dev/pms/RefTisa/discovery/api/tddmapi.h> 56 #endif 57 58 #include <dev/pms/RefTisa/tisa/sassata/sas/common/tdtypes.h> 59 #include <dev/pms/freebsd/driver/common/osstring.h> 60 #include <dev/pms/RefTisa/tisa/sassata/common/tdutil.h> 61 #include <dev/pms/RefTisa/sallsdk/spc/mpidebug.h> 62 63 #ifdef INITIATOR_DRIVER 64 #include <dev/pms/RefTisa/tisa/sassata/sas/ini/itdtypes.h> 65 #include <dev/pms/RefTisa/tisa/sassata/sas/ini/itddefs.h> 66 #include <dev/pms/RefTisa/tisa/sassata/sas/ini/itdglobl.h> 67 #endif 68 69 #ifdef TARGET_DRIVER 70 #include <dev/pms/RefTisa/tisa/sassata/sas/tgt/ttdglobl.h> 71 #include <dev/pms/RefTisa/tisa/sassata/sas/tgt/ttdxchg.h> 72 #include <dev/pms/RefTisa/tisa/sassata/sas/tgt/ttdtypes.h> 73 #endif 74 75 #include <dev/pms/RefTisa/tisa/sassata/common/tdsatypes.h> 76 #include <dev/pms/RefTisa/tisa/sassata/common/tdproto.h> 77 #include <dev/pms/RefTisa/tisa/sassata/common/tdioctl.h> 78 79 #include <dev/pms/RefTisa/sallsdk/spc/sadefs.h> 80 #include <dev/pms/RefTisa/sallsdk/spc/spcdefs.h> 81 #include <dev/pms/RefTisa/sallsdk/spc/mpi.h> 82 #include <dev/pms/RefTisa/sallsdk/spc/sallist.h> 83 #include <dev/pms/RefTisa/sallsdk/spc/satypes.h> 84 85 86 #define agFieldOffset(baseType,fieldName) \ 87 /*lint -e545 */ \ 88 ((bit32)((bitptr)(&(((baseType *)0)->fieldName)))) \ 89 90 #ifdef SA_LL_API_TEST 91 osGLOBAL bit32 tdLlApiTestIoctl(tiRoot_t *tiRoot, 92 tiIOCTLPayload_t *agIOCTLPayload, 93 void *agParam1, 94 void *agParam2, 95 void *agParam3); 96 #endif /* SA_LL_API_TEST */ 97 98 99 extern bit32 volatile sgpioResponseSet; 100 101 #ifdef SPC_ENABLE_PROFILE 102 /***************************************************************************** 103 * 104 * tdipFWProfileIoctl 105 * 106 * Purpose: This routine is called to process the FW Profile IOCTL function. 107 * This function is used for both target and initiator. 108 * 109 * Parameters: 110 * tiRoot: Pointer to driver instance 111 * agIOCTLPayload: Pointer to the IOCTL payload. 112 * agParam1: Pointer to pass context handle for IOCTL DMA operation 113 * agParam2: Pointer to pass context handle for IOCTL DMA operation 114 * agParam3: Pointer to pass context handle for IOCTL DMA operation 115 * 116 * Return: 117 * 118 * IOCTL_CALL_SUCCESS The requested operation completed successfully. 119 * IOCTL_CALL_FAIL Fail to complete the IOCTL request. 120 * Detail error code is function specific and 121 * defined by the specific IOCTL function. 122 * IOCTL_CALL_INVALID_CODE This IOCTL function is not recognized. 123 * 124 * 125 *****************************************************************************/ 126 osGLOBAL bit32 tdipFWProfileIoctl( 127 tiRoot_t *tiRoot, 128 tiIOCTLPayload_t *agIOCTLPayload, 129 void *agParam1, 130 void *agParam2, 131 void *agParam3 132 ) 133 { 134 135 bit32 status = IOCTL_CALL_SUCCESS; 136 bit32 bufAddrUpper = 0; 137 bit32 bufAddrLower = 0; 138 tdFWProfile_t *fwProfile; 139 140 void *osMemHandle = agNULL; 141 void *buffer = agNULL; 142 agsaFwProfile_t fwProfileInfo = {0}; 143 144 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 145 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 146 agsaRoot_t *agRoot = &tdsaAllShared->agRootInt; 147 148 fwProfile = (tdFWProfile_t *)&agIOCTLPayload->FunctionSpecificArea[0]; 149 150 151 fwProfileInfo.processor = fwProfile->processor; 152 fwProfileInfo.cmd = fwProfile->cmd; 153 fwProfileInfo.len = fwProfile->len; 154 fwProfileInfo.tcid = fwProfile->tcid; 155 if(fwProfile->cmd == START_CODE_PROFILE) 156 { 157 fwProfileInfo.codeStartAdd = fwProfile->codeStartAdd; 158 fwProfileInfo.codeEndAdd = fwProfile->codeEndAdd; 159 } 160 if((fwProfile->cmd == STOP_TIMER_PROFILE) || (fwProfile->cmd == STOP_CODE_PROFILE)) 161 { 162 if(fwProfile->len != 0) 163 { 164 if(ostiAllocMemory( tiRoot, 165 &osMemHandle, 166 (void **)&buffer, 167 &bufAddrUpper, 168 &bufAddrLower, 169 8, 170 fwProfile->len, 171 agFALSE)) 172 { 173 return IOCTL_CALL_FAIL; 174 } 175 osti_memset((void *)buffer, 0, fwProfile->len); 176 } 177 fwProfileInfo.agSgl.sgLower = bufAddrLower; 178 fwProfileInfo.agSgl.sgUpper = bufAddrUpper; 179 fwProfileInfo.agSgl.len = fwProfile->len; 180 fwProfileInfo.agSgl.extReserved = 0; 181 tdsaAllShared->tdFWProfileEx.buffer = osMemHandle; 182 tdsaAllShared->tdFWProfileEx.virtAddr = buffer; 183 tdsaAllShared->tdFWProfileEx.len = fwProfile->len; 184 } 185 tdsaAllShared->tdFWProfileEx.tdFWProfile = fwProfile; 186 tdsaAllShared->tdFWProfileEx.param1 = agParam1; 187 tdsaAllShared->tdFWProfileEx.param2 = agParam2; 188 tdsaAllShared->tdFWProfileEx.payload = agIOCTLPayload; 189 tdsaAllShared->tdFWProfileEx.inProgress = 1; 190 status = saFwProfile(agRoot, 191 agNULL, 192 0, 193 &fwProfileInfo 194 ); 195 if(status) 196 { 197 if((fwProfile->cmd == STOP_TIMER_PROFILE) || (fwProfile->cmd == STOP_CODE_PROFILE)) 198 ostiFreeMemory(tiRoot, osMemHandle, fwProfile->len); 199 status = IOCTL_CALL_FAIL; 200 } 201 else 202 status = IOCTL_CALL_PENDING; 203 return status; 204 } 205 206 207 #endif 208 209 /***************************************************************************** 210 * 211 * tdipFWControlIoctl 212 * 213 * Purpose: This routine is called to process the FW control IOCTL function. 214 * This function is used for both target and initiator. 215 * 216 * Parameters: 217 * tiRoot: Pointer to driver instance 218 * agIOCTLPayload: Pointer to the IOCTL payload. 219 * agParam1: Pointer to pass context handle for IOCTL DMA operation 220 * agParam2: Pointer to pass context handle for IOCTL DMA operation 221 * agParam3: Pointer to pass context handle for IOCTL DMA operation 222 * 223 * Return: 224 * 225 * IOCTL_CALL_SUCCESS The requested operation completed successfully. 226 * IOCTL_CALL_FAIL Fail to complete the IOCTL request. 227 * Detail error code is function specific and 228 * defined by the specific IOCTL function. 229 * IOCTL_CALL_PENDING This request is asynchronous and completed 230 * in some other context. 231 * IOCTL_CALL_INVALID_CODE This IOCTL function is not recognized. 232 * 233 * 234 *****************************************************************************/ 235 osGLOBAL bit32 tdipFWControlIoctl( 236 tiRoot_t *tiRoot, 237 tiIOCTLPayload_t *agIOCTLPayload, 238 void *agParam1, 239 void *agParam2, 240 void *agParam3 241 ) { 242 243 bit32 status = IOCTL_CALL_PENDING; 244 bit32 bufAddrUpper = 0; 245 bit32 bufAddrLower = 0; 246 tdFWControl_t *fwControl; 247 void *osMemHandle = agNULL; 248 void *buffer = agNULL; 249 agsaUpdateFwFlash_t flashUpdateInfo; 250 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 251 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 252 agsaRoot_t *agRoot = &tdsaAllShared->agRootInt; 253 254 if( agIOCTLPayload->Length < 255 ( agFieldOffset(tiIOCTLPayload_t, FunctionSpecificArea) + 256 sizeof(tdFWControl_t) ) ) { 257 agIOCTLPayload->Status = IOCTL_ERR_STATUS_INTERNAL_ERROR; 258 status = IOCTL_CALL_FAIL; 259 return status; 260 } 261 fwControl = (tdFWControl_t *)&agIOCTLPayload->FunctionSpecificArea[0]; 262 263 if(fwControl->len != 0) 264 { 265 if(ostiAllocMemory( tiRoot, 266 &osMemHandle, 267 (void **)&buffer, 268 &bufAddrUpper, 269 &bufAddrLower, 270 8, 271 fwControl->len, 272 agFALSE) ) 273 return IOCTL_CALL_FAIL; 274 } 275 osti_memset( (void *)buffer, 0, fwControl->len ); 276 osti_memcpy( (void *)buffer, 277 fwControl->buffer, 278 fwControl->len ); 279 flashUpdateInfo.agSgl.sgLower = bufAddrLower; 280 flashUpdateInfo.agSgl.sgUpper = bufAddrUpper; 281 flashUpdateInfo.agSgl.len = fwControl->len; 282 flashUpdateInfo.agSgl.extReserved = 0; 283 flashUpdateInfo.currentImageOffset = fwControl->offset; 284 flashUpdateInfo.currentImageLen = fwControl->len; 285 flashUpdateInfo.totalImageLen = fwControl->size; 286 switch (agIOCTLPayload->MinorFunction) 287 { 288 case IOCTL_MN_FW_DOWNLOAD_DATA: 289 { 290 TI_DBG6(("tdipFWControlIoctl: calling saFwFlashUpdate\n")); 291 tdsaAllShared->tdFWControlEx.tdFWControl = fwControl; 292 tdsaAllShared->tdFWControlEx.buffer = osMemHandle; 293 tdsaAllShared->tdFWControlEx.param1 = agParam1; 294 tdsaAllShared->tdFWControlEx.param2 = agParam2; 295 tdsaAllShared->tdFWControlEx.payload = agIOCTLPayload; 296 tdsaAllShared->tdFWControlEx.inProgress = 1; 297 status = saFwFlashUpdate( agRoot, 298 agNULL, 299 0, 300 &flashUpdateInfo ); 301 if(status) { 302 status = IOCTL_CALL_FAIL; 303 fwControl->retcode = IOCTL_CALL_TIMEOUT; 304 } 305 else { 306 status = IOCTL_CALL_PENDING; 307 } 308 break; 309 } 310 default: 311 status = IOCTL_CALL_INVALID_CODE; 312 TI_DBG1( ("tdipFWControlIoctl: ERROR: Wrong IOCTL code %d\n", 313 agIOCTLPayload->MinorFunction) ); 314 ostiFreeMemory(tiRoot, osMemHandle, fwControl->len); 315 return status; 316 } /* end IOCTL switch */ 317 return status; 318 } /* tdipFWControlIoctl */ 319 320 321 /***************************************************************************** 322 * 323 * tiCOMMgntIOCTL 324 * 325 * Purpose: This routine is a TISA API for processing the PMC specific 326 * IOCTL function. 327 * 328 * Each IOCTL function is identified by the IOCTL header 329 * specified in the data payload as the following: 330 * Field Description 331 * ----- ----------- 332 * Signature PMC IOCTL signature. 333 * #define PMC_IOCTL_SIGNATURE 0x1234 334 * MajorFunction Major function number. 335 * MinorFunction Minor function number. 336 * Length Length of this structure in bytes. 337 * Status Return status for this IOCTL function. 338 * FunctionSpecificArea Variable length function specific area. 339 * 340 * Parameters: 341 * tiRoot: Pointer to driver instance 342 * agIOCTLPayload: Pointer to the IOCTL payload. 343 * agParam1: Pointer to pass context handle for IOCTL DMA operation 344 * agParam2: Pointer to pass context handle for IOCTL DMA operation 345 * agParam3: Pointer to pass context handle for IOCTL DMA operation 346 * 347 * Return: 348 * 349 * IOCTL_CALL_SUCCESS The requested operation completed successfully. 350 * IOCTL_CALL_FAIL Fail to complete the IOCTL request. 351 * Detail error code is function specific and 352 * defined by the specific IOCTL function. 353 * IOCTL_CALL_PENDING This request is asynchronous and completed 354 * in some other context. 355 * IOCTL_CALL_INVALID_CODE This IOCTL function is not recognized. 356 * IOCTL_CALL_INVALID_DEVICE Invalid target or destination device. 357 * 358 * Note: 359 * Used ostiAllocMemory() OS layer callback function to allocate memory 360 * for DMA operaion. Then use ostiFreeMemory() to deallocate the memory. 361 * 362 *****************************************************************************/ 363 osGLOBAL bit32 364 tiCOMMgntIOCTL( 365 tiRoot_t *tiRoot, 366 tiIOCTLPayload_t *agIOCTLPayload, 367 void *agParam1, 368 void *agParam2, 369 void *agParam3 370 ) 371 { 372 bit32 status = IOCTL_CALL_INVALID_CODE; 373 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 374 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 375 agsaRoot_t *agRoot = &(tdsaAllShared->agRootNonInt); 376 bit32 EventLogLength = 0; 377 bit32 EventLogOption; 378 bit32 ReadLength = 0; 379 bit32 Offset = 0; 380 bit32 RequestLength = 0; /* user request on how much data to pass to application */ 381 agsaContext_t *agContext = NULL; 382 bit8 *loc = 0; 383 384 TI_DBG3(("tiCOMMgntIOCTL: start\n")); 385 386 TI_DBG3(("tiCOMMgntIOCTL: tiRoot %p agIOCTLPayload %p agParam1 %p agParam2 %p agParam3 %p\n", 387 tiRoot,agIOCTLPayload,agParam1,agParam2,agParam3 )); 388 389 TI_DBG3(("tiCOMMgntIOCTL: Signature %X\ntiCOMMgntIOCTL: MajorFunction 0x%X\ntiCOMMgntIOCTL: MinorFunction 0x%X\ntiCOMMgntIOCTL: Length 0x%X\ntiCOMMgntIOCTL: Status 0x%X\ntiCOMMgntIOCTL: Reserved 0x%X\ntiCOMMgntIOCTL: FunctionSpecificArea 0x%X\n", 390 agIOCTLPayload->Signature, 391 agIOCTLPayload->MajorFunction, 392 agIOCTLPayload->MinorFunction, 393 agIOCTLPayload->Length, 394 agIOCTLPayload->Status, 395 agIOCTLPayload->Reserved, 396 agIOCTLPayload->FunctionSpecificArea[0] )); 397 398 /* PMC IOCTL signatures matched ? */ 399 if(agIOCTLPayload->Signature != PMC_IOCTL_SIGNATURE) 400 { 401 TI_DBG1(("tiCOMMgntIOCTL:agIOCTLPayload->Signature %x IOCTL_CALL_INVALID_CODE\n",agIOCTLPayload->Signature )); 402 status = IOCTL_CALL_INVALID_CODE; 403 return (status); 404 } 405 406 switch (agIOCTLPayload->MajorFunction) 407 { 408 //TODO: make the card identification more robust. For now - just to keep going with FW download 409 #ifdef IOCTL_INTERRUPT_TIME_CONFIG 410 case IOCTL_MJ_CARD_PARAMETER: 411 { 412 switch( agIOCTLPayload->MinorFunction ) 413 { 414 case IOCTL_MN_CARD_GET_INTERRUPT_CONFIG: 415 { 416 agsaInterruptConfigPage_t *pInterruptConfig = (agsaInterruptConfigPage_t *)&agIOCTLPayload->FunctionSpecificArea[0]; 417 status = saGetControllerConfig(agRoot, 418 0, 419 AGSA_INTERRUPT_CONFIGURATION_PAGE, 420 pInterruptConfig->vectorMask0, 421 pInterruptConfig->vectorMask1, 422 agParam2); 423 if(status == AGSA_RC_SUCCESS) { 424 status = IOCTL_CALL_PENDING; 425 agIOCTLPayload->Status = IOCTL_ERR_STATUS_OK; 426 } else { 427 agIOCTLPayload->Status = IOCTL_ERR_STATUS_INTERNAL_ERROR; 428 } 429 break; 430 } 431 case IOCTL_MN_CARD_GET_TIMER_CONFIG: 432 status = saGetControllerConfig(agRoot, 0, AGSA_SAS_PROTOCOL_TIMER_CONFIG_PAGE, 0, 0, agParam2); 433 if(status == AGSA_RC_SUCCESS) { 434 status = IOCTL_CALL_PENDING; 435 agIOCTLPayload->Status = IOCTL_ERR_STATUS_OK; 436 } else { 437 agIOCTLPayload->Status = IOCTL_ERR_STATUS_INTERNAL_ERROR; 438 } 439 break; 440 } 441 break; 442 } 443 #endif /* IOCTL_INTERRUPT_TIME_CONFIG */ 444 case IOCTL_MJ_INI_DRIVER_IDENTIFY: 445 { 446 status=IOCTL_CALL_SUCCESS; 447 break; 448 } 449 case IOCTL_MJ_GET_DEVICE_LUN: 450 status = tdsaGetNumOfLUNIOCTL(tiRoot,agIOCTLPayload, agParam1, agParam2, agParam3); 451 if(status == IOCTL_CALL_SUCCESS) 452 { 453 status = IOCTL_CALL_PENDING; 454 } 455 break; 456 case IOCTL_MJ_SMP_REQUEST: 457 status = tdsaSendSMPIoctl(tiRoot, agIOCTLPayload, 458 agParam1,agParam2,agParam3); 459 break; 460 461 case IOCTL_MJ_FW_CONTROL: 462 { 463 //ostiIOCTLClearSignal (tiRoot, &agParam1, &agParam2, &agParam3); 464 status = tdipFWControlIoctl( tiRoot, agIOCTLPayload, 465 agParam1, agParam2, agParam3); 466 467 break; 468 } 469 //#ifdef EVENT_LOG_INFO_TESTING 470 /* Reserved field in tiIOCTLPayload_t is used as offset */ 471 case IOCTL_MJ_GET_EVENT_LOG1: 472 { 473 switch (agIOCTLPayload->MinorFunction) 474 { 475 case IOCTL_MN_FW_GET_TRACE_BUFFER: 476 { 477 agsaControllerEventLog_t EventLog; 478 saGetControllerEventLogInfo(agRoot, &EventLog); 479 TI_DBG6(("tiCOMMgntIOCTL: IOCTL_MJ_GET_EVENT_LOG1 Length %d\n", agIOCTLPayload->Length)); 480 RequestLength = agIOCTLPayload->Length; 481 Offset = agIOCTLPayload->Reserved; 482 EventLogLength = EventLog.eventLog1.totalLength; 483 EventLogOption = EventLog.eventLog1Option; 484 if (EventLogLength <= Offset) 485 { 486 TI_DBG1(("tiCOMMgntIOCTL: 1 out of range Requestlength %d Offset %d event log length %d\n", RequestLength, Offset, EventLogLength)); 487 // out of range 488 agIOCTLPayload->Status = IOCTL_ERR_STATUS_NO_MORE_DATA; 489 agIOCTLPayload->Length = 0; 490 if(EventLogOption == 0) 491 { 492 agIOCTLPayload->Status = IOCTL_ERR_FW_EVENTLOG_DISABLED; 493 } 494 status=IOCTL_CALL_SUCCESS; 495 return status; 496 } 497 ReadLength = MIN(EventLogLength - Offset, RequestLength); 498 loc = (bit8 *)EventLog.eventLog1.virtPtr + Offset; 499 osti_memcpy(&(agIOCTLPayload->FunctionSpecificArea), loc, ReadLength); 500 // tdhexdump("IOCTL_MJ_GET_EVENT_LOG1 first 32bytes", (bit8 *)&(agIOCTLPayload->FunctionSpecificArea), 32); 501 agIOCTLPayload->Status = IOCTL_ERR_STATUS_OK; 502 agIOCTLPayload->Length = (bit16)ReadLength; 503 status=IOCTL_CALL_SUCCESS; 504 break; 505 } 506 case IOCTL_MN_FW_GET_EVENT_FLASH_LOG1: 507 { 508 TI_DBG6(("tiCOMMgntIOCTL: IOCTL_MN_FW_GET_EVENT_FLASH_LOG1\n")); 509 status = tdsaRegDumpGetIoctl(tiRoot, agIOCTLPayload, agParam1, agParam2, agParam3); 510 break; 511 } 512 } 513 break; 514 } 515 516 case IOCTL_MJ_GET_EVENT_LOG2: 517 { 518 switch (agIOCTLPayload->MinorFunction) 519 { 520 case IOCTL_MN_FW_GET_TRACE_BUFFER: 521 { 522 agsaControllerEventLog_t EventLog; 523 saGetControllerEventLogInfo(agRoot, &EventLog); 524 TI_DBG6(("tiCOMMgntIOCTL: IOCTL_MJ_GET_EVENT_LOG2 Length %d\n", agIOCTLPayload->Length)); 525 RequestLength = agIOCTLPayload->Length; 526 Offset = agIOCTLPayload->Reserved; 527 EventLogLength = EventLog.eventLog2.totalLength; 528 EventLogOption = EventLog.eventLog2Option; 529 if (EventLogLength <= Offset) 530 { 531 TI_DBG1(("tiCOMMgntIOCTL: 2 out of range Requestlength %d Offset %d event log length %d\n", RequestLength, Offset, EventLogLength)); 532 /* out of range */ 533 agIOCTLPayload->Status = IOCTL_ERR_STATUS_NO_MORE_DATA; 534 agIOCTLPayload->Length = 0; 535 if(EventLogOption == 0) 536 { 537 agIOCTLPayload->Status = IOCTL_ERR_FW_EVENTLOG_DISABLED; 538 } 539 status=IOCTL_CALL_SUCCESS; 540 return status; 541 } 542 ReadLength = MIN(EventLogLength - Offset, RequestLength); 543 loc = (bit8 *)EventLog.eventLog2.virtPtr + Offset; 544 osti_memcpy(&(agIOCTLPayload->FunctionSpecificArea), loc, ReadLength); 545 // tdhexdump("IOCTL_MJ_GET_EVENT_LOG2 first 32bytes", (bit8 *)&(agIOCTLPayload->FunctionSpecificArea), 32); 546 agIOCTLPayload->Status = IOCTL_ERR_STATUS_OK; 547 agIOCTLPayload->Length = (bit16)ReadLength; 548 status=IOCTL_CALL_SUCCESS; 549 break; 550 } 551 case IOCTL_MN_FW_GET_EVENT_FLASH_LOG2: 552 { 553 TI_DBG6(("tiCOMMgntIOCTL: IOCTL_MN_FW_GET_EVENT_FLASH_LOG2\n")); 554 status = tdsaRegDumpGetIoctl(tiRoot, agIOCTLPayload, agParam1, agParam2, agParam3); 555 break; 556 } 557 } 558 break; 559 } 560 561 562 case IOCTL_MJ_FW_INFO: 563 { 564 agsaControllerInfo_t ControllerInfo; 565 saGetControllerInfo(agRoot, &ControllerInfo); 566 TI_DBG1(("tiCOMMgntIOCTL: IOCTL_MJ_FW_INFO Length %d\n", agIOCTLPayload->Length)); 567 RequestLength = agIOCTLPayload->Length; 568 Offset = agIOCTLPayload->Reserved; 569 if (RequestLength == 0) 570 { 571 TI_DBG1(("tiCOMMgntIOCTL: IOCTL_MJ_FW_INFO: No more Data!\n")); 572 /* out of range */ 573 agIOCTLPayload->Status = IOCTL_ERR_STATUS_NO_MORE_DATA; 574 agIOCTLPayload->Length = 0; 575 status=IOCTL_CALL_SUCCESS; 576 return status; 577 } 578 579 osti_memcpy((bit8*)&(agIOCTLPayload->FunctionSpecificArea), (bit8*)&ControllerInfo, sizeof(agsaControllerInfo_t)); 580 581 TI_DBG1(("tiCOMMgntIOCTL:IOCTL_MJ_FW_INFO ControllerInfo signature 0x%X\n",ControllerInfo.signature)); 582 TI_DBG1(("tiCOMMgntIOCTL:IOCTL_MJ_FW_INFO ControllerInfo PCILinkRate 0x%X\n",ControllerInfo.PCILinkRate)); 583 TI_DBG1(("tiCOMMgntIOCTL:IOCTL_MJ_FW_INFO ControllerInfo PCIWidth 0x%X\n",ControllerInfo.PCIWidth)); 584 agIOCTLPayload->Status = IOCTL_ERR_STATUS_OK; 585 status=IOCTL_CALL_SUCCESS; 586 break; 587 588 } 589 590 case IOCTL_MJ_GET_FW_REV: 591 { 592 agsaControllerInfo_t ControllerInfo; 593 saGetControllerInfo(agRoot, &ControllerInfo); 594 TI_DBG3(("tiCOMMgntIOCTL: IOCTL_MJ_GET_FW_REV Length %d\n", agIOCTLPayload->Length)); 595 RequestLength = agIOCTLPayload->Length; 596 Offset = agIOCTLPayload->Reserved; 597 if (RequestLength == 0) 598 { 599 TI_DBG1(("tiCOMMgntIOCTL: IOCTL_MJ_GET_FW_REV: No more Data!\n")); 600 /* out of range */ 601 agIOCTLPayload->Status = IOCTL_ERR_STATUS_NO_MORE_DATA; 602 agIOCTLPayload->Length = 0; 603 status=IOCTL_CALL_SUCCESS; 604 return status; 605 } 606 607 osti_memcpy((bit8*)&(agIOCTLPayload->FunctionSpecificArea), (bit8*)&ControllerInfo.fwRevision, sizeof(bit32)); 608 loc = (bit8 *)&(agIOCTLPayload->FunctionSpecificArea)+ sizeof(bit32); 609 osti_memcpy(loc, (bit8*)&ControllerInfo.sdkRevision, sizeof(bit32)); 610 611 agIOCTLPayload->Status = IOCTL_ERR_STATUS_OK; 612 status=IOCTL_CALL_SUCCESS; 613 break; 614 615 } 616 617 #ifdef SPC_ENABLE_PROFILE 618 case IOCTL_MJ_FW_PROFILE: 619 { 620 TI_DBG6(("tiCOMMgntIOCTL: IOCTL_MJ_FW_PROFILE\n")); 621 status = tdipFWProfileIoctl( tiRoot, agIOCTLPayload, 622 agParam1, agParam2, agParam3); 623 break; 624 } 625 #endif /* SPC_ENABLE_PROFILE */ 626 627 case IOCTL_MJ_GET_CORE_DUMP: 628 { 629 TI_DBG6(("tiCOMMgntIOCTL: IOCTL_MJ_GET_CORE_DUMP\n")); 630 if (tiIS_SPC(agRoot)) 631 { 632 status = tdsaRegDumpGetIoctl(tiRoot, agIOCTLPayload, agParam1, agParam2, agParam3); 633 } 634 else 635 { 636 agIOCTLPayload->Status = IOCTL_ERR_STATUS_NOT_SUPPORTED; 637 status = IOCTL_CALL_SUCCESS; 638 } 639 break; 640 } 641 //#endif 642 case IOCTL_MJ_NVMD_SET: 643 { 644 bit8 nvmDev; 645 TI_DBG6(("tiCOMMgntIOCTL: IOCTL_MJ_NVMD_SET\n")); 646 nvmDev = (bit8) agIOCTLPayload->Status; 647 agIOCTLPayload->Status = 0; 648 status = tdsaNVMDSetIoctl(tiRoot, agIOCTLPayload, agParam1, agParam2, &nvmDev); 649 break; 650 } 651 #if 0 652 case IOCTL_MJ_GPIO: 653 { 654 bit32 sVid =0; 655 TI_DBG6(("tiCOMMgntIOCTL: IOCTL_MJ_GPIO\n")); 656 657 /* Get Subsystem vendor */ 658 sVid = ostiChipConfigReadBit32(tiRoot,0x2C); 659 sVid = sVid & 0xFFFF; 660 661 /* GPIO is only intended for chip down design 662 * therefore it's only applies to 8H/SPCv product family 663 */ 664 if(sVid == 0x9005) 665 return IOCTL_CALL_INVALID_DEVICE; 666 667 status = tdsaGpioSetup(tiRoot, agContext, agIOCTLPayload, agParam1, agParam2); 668 if(status == IOCTL_CALL_SUCCESS) 669 status = IOCTL_CALL_PENDING; /* Wait for response from the Controller */ 670 else 671 return status; 672 673 break; 674 } 675 #endif 676 677 case IOCTL_MJ_SGPIO: 678 { 679 TI_DBG6(("tiCOMMgntIOCTL: IOCTL_MJ_SGPIO\n")); 680 status = tdsaSGpioIoctlSetup(tiRoot, agContext, agIOCTLPayload, agParam1, agParam2); 681 break; 682 } 683 684 case IOCTL_MJ_NVMD_GET: 685 { 686 bit8 nvmDev; 687 TI_DBG3(("tiCOMMgntIOCTL: IOCTL_MJ_NVMD_GET\n")); 688 nvmDev = (bit8) agIOCTLPayload->Status; 689 agIOCTLPayload->Status = 0; 690 status = tdsaNVMDGetIoctl(tiRoot, agIOCTLPayload, agParam1, agParam2, &nvmDev); 691 break; 692 } 693 694 case IOCTL_MJ_GET_FORENSIC_DATA: 695 { 696 TI_DBG3(("tiCOMMgntIOCTL: IOCTL_MJ_GET_FORENSIC_DATA\n")); 697 status = tdsaForensicDataGetIoctl(tiRoot, agIOCTLPayload, agParam1, agParam2, agParam3); 698 break; 699 } 700 case IOCTL_MJ_GET_DEVICE_INFO: 701 { 702 TI_DBG3(("tiCOMMgntIOCTL: IOCTL_MJ_GET_DEVICE_INFO\n")); 703 status = tdsaDeviceInfoGetIoctl(tiRoot, agIOCTLPayload, agParam1, agParam2, agParam3); 704 break; 705 } 706 707 case IOCTL_MJ_GET_IO_ERROR_STATISTIC: 708 { 709 TI_DBG3(("tiCOMMgntIOCTL: IOCTL_MJ_GET_IO_ERROR_STATISTIC\n")); 710 status = tdsaIoErrorStatisticGetIoctl(tiRoot, agIOCTLPayload, agParam1, agParam2, agParam3); 711 break; 712 } 713 714 case IOCTL_MJ_GET_IO_EVENT_STATISTIC: 715 { 716 TI_DBG3(("tiCOMMgntIOCTL: IOCTL_MJ_GET_IO_EVENT_STATISTIC\n")); 717 status = tdsaIoEventStatisticGetIoctl(tiRoot, agIOCTLPayload, agParam1, agParam2, agParam3); 718 break; 719 } 720 721 case IOCTL_MJ_SEND_BIST: 722 { 723 TI_DBG1(("tiCOMMgntIOCTL: IOCTL_MJ_SEND_BIST\n")); 724 status = tdsaSendBISTIoctl(tiRoot, agIOCTLPayload, agParam1, agParam2, agParam3); 725 break; 726 } 727 728 #if 0 729 case IOCTL_MJ_SET_OR_GET_REGISTER: 730 { 731 TI_DBG3(("tiCOMMgntIOCTL: IOCTL_MJ_SET_OR_GET_REGISTER\n")); 732 status = tdsaRegisterIoctl(tiRoot, agIOCTLPayload, agParam1, agParam2, agParam3); 733 break; 734 } 735 736 #endif 737 case IOCTL_MJ_PHY_DETAILS: 738 { 739 PhyDetails_t *PhyDetails = (PhyDetails_t*)&agIOCTLPayload->FunctionSpecificArea; 740 agsaRoot_t *agRoot = &(tdsaAllShared->agRootNonInt); 741 agsaLLRoot_t *saRoot = (agsaLLRoot_t *)(agRoot->sdkData); 742 bit8 *sasAddressHi; 743 bit8 *sasAddressLo; 744 bit8 sas_dev_type; 745 int i = 0; 746 747 tiIniGetDirectSataSasAddr(tiRoot, i , &sasAddressHi, &sasAddressLo); 748 for( i = 0; i < saRoot->phyCount ; i++) 749 { 750 PhyDetails[i].attached_phy = saRoot->phys[i].sasIdentify.phyIdentifier; 751 /* deice types 752 * SAS 753 * 0x01 - Sas end device 754 * 0x02 - Expander device 755 * SATA 756 * 0x11 - Sata 757 * NO DEVICE 0x00 758 */ 759 sas_dev_type = (saRoot->phys[i].sasIdentify.deviceType_addressFrameType & 0x70 ) >> 4 ; 760 if ((saRoot->phys[i].status == 1) && (sas_dev_type == 0)){ //status 1 - Phy Up 761 //Sata phy 762 PhyDetails[i].attached_dev_type = SAS_PHY_SATA_DEVICE;//0x11 for sata end device 763 osti_memcpy(&PhyDetails[i].attached_sasAddressHi, tdsaAllShared->Ports[i].SASID.sasAddressHi, sizeof(bit32)); 764 osti_memcpy(&PhyDetails[i].attached_sasAddressLo, tdsaAllShared->Ports[i].SASID.sasAddressLo, sizeof(bit32)); 765 PhyDetails[i].attached_sasAddressLo[3] += i + 16; 766 } 767 else { 768 PhyDetails[i].attached_dev_type = sas_dev_type; 769 osti_memcpy(&PhyDetails[i].attached_sasAddressHi, saRoot->phys[i].sasIdentify.sasAddressHi, sizeof(bit32)); 770 osti_memcpy(&PhyDetails[i].attached_sasAddressLo, saRoot->phys[i].sasIdentify.sasAddressLo, sizeof(bit32)); 771 } 772 osti_memcpy(&PhyDetails[i].sasAddressLo,&(tdsaAllShared->Ports[i].SASID.sasAddressLo), sizeof(bit32)); 773 osti_memcpy(&PhyDetails[i].sasAddressHi,&(tdsaAllShared->Ports[i].SASID.sasAddressHi), sizeof(bit32)); 774 } 775 776 // osti_memcpy(&agIoctlPayload->FunctionSpecificArea,&PhyInfo, sizeof(agsaSGpioReqResponse_t)); 777 // printk("Ioctl success\n"); 778 return IOCTL_CALL_SUCCESS; 779 } 780 781 case IOCTL_MJ_PHY_GENERAL_STATUS: 782 { 783 agsaPhyGeneralState_t *PhyData=NULL; 784 bit32 ret = AGSA_RC_FAILURE; 785 PhyData = (agsaPhyGeneralState_t*) &agIOCTLPayload->FunctionSpecificArea[0]; 786 787 PhyData->Reserved2 = 0; 788 /* Validate the length */ 789 if (agIOCTLPayload->Length < sizeof(agsaPhyGeneralState_t)) 790 { 791 status = IOCTL_CALL_FAIL; 792 break; 793 } 794 795 tdsaAllShared->tdFWControlEx.param1 = agParam1; 796 tdsaAllShared->tdFWControlEx.param2 = agParam2; 797 tdsaAllShared->tdFWControlEx.payload = agIOCTLPayload; 798 tdsaAllShared->tdFWControlEx.inProgress = 1; 799 //tdsaAllShared->tdFWControlEx.usrAddr = PhyData; 800 801 ret = tdsaGetPhyGeneralStatusIoctl(tiRoot,PhyData); 802 if(ret == AGSA_RC_FAILURE) 803 { 804 status = IOCTL_CALL_FAIL; 805 tdsaAllShared->tdFWControlEx.payload = NULL; 806 tdsaAllShared->tdFWControlEx.inProgress = 0; 807 break; 808 } 809 else if(ret == IOCTL_ERR_STATUS_NOT_SUPPORTED) 810 { 811 812 agIOCTLPayload->Status = IOCTL_ERR_STATUS_NOT_SUPPORTED; 813 status = IOCTL_CALL_SUCCESS; 814 break; 815 } 816 817 //status = IOCTL_CALL_PENDING; 818 status = IOCTL_CALL_PENDING; 819 } 820 821 break; 822 #if 1 823 case IOCTL_MJ_GET_PHY_PROFILE: 824 { 825 TI_DBG1(("tiCOMMgntIOCTL: IOCTL_MJ_GET_PHY_PROFILE %p %p %p\n",agParam1,agParam2,agParam3)); 826 status = tdsaPhyProfileIoctl(tiRoot, agIOCTLPayload, agParam1, agParam2, agParam3); 827 break; 828 } 829 #endif 830 case IOCTL_MJ_LL_TRACING: 831 { 832 void * stu = &agIOCTLPayload->FunctionSpecificArea[0]; 833 switch(agIOCTLPayload->MinorFunction) 834 { 835 836 case IOCTL_MN_LL_RESET_TRACE_INDEX: 837 { 838 839 #ifdef SA_ENABLE_TRACE_FUNCTIONS 840 TSTMTID_TRACE_BUFFER_RESET *llist = (TSTMTID_TRACE_BUFFER_RESET *)stu; 841 hpTraceBufferParms_t BufferParms; 842 TI_DBG5(("tdReturnIOCTL_Info: hpIOCTL_ResetTraceIndex\n")); 843 844 BufferParms.TraceCompiled = 0; 845 BufferParms.TraceWrap = 0; 846 BufferParms.CurrentTraceIndexWrapCount = 0; 847 BufferParms.BufferSize = 0; 848 BufferParms.CurrentIndex = 0; 849 BufferParms.pTrace = NULL; 850 BufferParms.pTraceIndexWrapCount = NULL; 851 BufferParms.pTraceMask = NULL; 852 BufferParms.pCurrentTraceIndex = NULL; 853 854 smTraceGetInfo(agRoot,&BufferParms); 855 TI_DBG5(("tdReturnIOCTL_Info: pTrace %p\n",BufferParms.pTrace)); 856 TI_DBG5(("tdReturnIOCTL_Info: pCurrentTraceIndex %p %X\n",BufferParms.pCurrentTraceIndex,*BufferParms.pCurrentTraceIndex)); 857 TI_DBG5(("tdReturnIOCTL_Info: pTraceIndexWrapCount %p %X\n",BufferParms.pTraceIndexWrapCount,*BufferParms.pTraceIndexWrapCount)); 858 TI_DBG5(("tdReturnIOCTL_Info: pTraceMask %p %X\n",BufferParms.pTraceMask,*BufferParms.pTraceMask)); 859 860 if( llist->Flag != 0) 861 { 862 if( llist->TraceMask != *BufferParms.pTraceMask) 863 { 864 smTraceSetMask(agRoot, llist->TraceMask ); 865 } 866 } 867 if( llist->Reset) 868 { 869 870 *BufferParms.pCurrentTraceIndex = 0; 871 smResetTraceBuffer(agRoot); 872 873 *BufferParms.pCurrentTraceIndex = 0; 874 *BufferParms.pTraceIndexWrapCount =0; 875 llist->TraceMask = *BufferParms.pTraceMask; 876 } 877 #endif /* SA_ENABLE_TRACE_FUNCTIONS */ 878 agIOCTLPayload->Status = IOCTL_ERR_STATUS_OK; 879 status = IOCTL_CALL_SUCCESS; 880 881 } 882 break; 883 884 case IOCTL_MN_LL_GET_TRACE_BUFFER_INFO: 885 { 886 hpTraceBufferParms_t BufferParms; 887 TSTMTID_TRACE_BUFFER_INFO *llist = (TSTMTID_TRACE_BUFFER_INFO *)stu; 888 TI_DBG5(("tdReturnIOCTL_Info: hpIOCTL_GetTraceBufferInfo\n")); 889 890 891 BufferParms.TraceCompiled = 0; 892 BufferParms.TraceWrap = 0; 893 BufferParms.CurrentTraceIndexWrapCount = 0; 894 BufferParms.BufferSize = 0; 895 BufferParms.CurrentIndex = 0; 896 BufferParms.pTrace = NULL; 897 BufferParms.pTraceMask = NULL; 898 #ifdef SA_ENABLE_TRACE_FUNCTIONS 899 smTraceGetInfo(agRoot,&BufferParms); 900 #endif /* SA_ENABLE_TRACE_FUNCTIONS not enabled */ 901 llist->TraceCompiled = BufferParms.TraceCompiled; 902 llist->BufferSize = BufferParms.BufferSize; 903 llist->CurrentIndex = BufferParms.CurrentIndex ; 904 llist->CurrentTraceIndexWrapCount = BufferParms.CurrentTraceIndexWrapCount; 905 llist->TraceWrap = BufferParms.TraceWrap; 906 if(BufferParms.pTraceMask != NULL) 907 { 908 llist->TraceMask = *BufferParms.pTraceMask; 909 } 910 agIOCTLPayload->Status = IOCTL_ERR_STATUS_OK; 911 status = IOCTL_CALL_SUCCESS; 912 } 913 break; 914 915 case IOCTL_MN_LL_GET_TRACE_BUFFER: 916 { 917 #ifdef SA_ENABLE_TRACE_FUNCTIONS 918 TSTMTID_TRACE_BUFFER_FETCH *llist = (TSTMTID_TRACE_BUFFER_FETCH *)stu; 919 920 hpTraceBufferParms_t BufferParms; 921 bit32 c= 0; 922 923 BufferParms.TraceCompiled = 0; 924 BufferParms.TraceWrap = 0; 925 BufferParms.CurrentTraceIndexWrapCount = 0; 926 BufferParms.BufferSize = 0; 927 BufferParms.CurrentIndex = 0; 928 BufferParms.pTrace = NULL; 929 smTraceGetInfo(agRoot,&BufferParms); 930 931 TI_DBG6(("tdReturnIOCTL_Info: hpIOCTL_GetTraceBuffer\n")); 932 933 if(llist->LowFence != LowFence32Bits) 934 { 935 break; 936 } 937 if(llist->HighFence != HighFence32Bits) 938 { 939 break; 940 } 941 942 if(llist->BufferOffsetBegin + FetchBufferSIZE > BufferParms.BufferSize ) 943 { 944 } 945 946 for ( c=0; c < FetchBufferSIZE;c++) 947 { 948 llist->Data[c] = *(BufferParms.pTrace+( c + llist->BufferOffsetBegin)); 949 } 950 #endif /* SA_ENABLE_TRACE_FUNCTIONS not enabled */ 951 } 952 agIOCTLPayload->Status = IOCTL_ERR_STATUS_OK; 953 status = IOCTL_CALL_SUCCESS; 954 break; 955 } 956 break; 957 } 958 959 #ifdef SA_LL_API_TEST 960 case IOCTL_MJ_LL_API_TEST: 961 { 962 status = tdLlApiTestIoctl( tiRoot, agIOCTLPayload, 963 agParam1,agParam2,agParam3 ); 964 break; 965 } 966 967 #endif /* SA_LL_API_TEST */ 968 969 case IOCTL_MJ_MODE_CTL_PAGE: 970 { 971 /* The SPCv controller has some options accessed via mode pages */ 972 tiEncryptDekConfigPage_t *pModePage= (tiEncryptDekConfigPage_t *) &agIOCTLPayload->FunctionSpecificArea[0]; 973 bit32 pageLength = 0; 974 bit32 pageCode; 975 bit32 modeOperation; 976 977 pageCode = pModePage->pageCode & 0xFF; 978 modeOperation = *(bit32 *) agParam2; 979 980 switch(modeOperation) 981 { 982 983 case tiModePageSet: 984 switch (pageCode) 985 { 986 case TI_ENCRYPTION_DEK_CONFIG_PAGE: 987 pageLength = sizeof(tiEncryptDekConfigPage_t); 988 break; 989 990 case TI_ENCRYPTION_CONTROL_PARM_PAGE: 991 pageLength = sizeof(tiEncryptControlParamPage_t); 992 break; 993 994 case TI_ENCRYPTION_GENERAL_CONFIG_PAGE: 995 /* Pages are currently unsupported */ 996 pageLength = 0; 997 break; 998 } 999 1000 status = saSetControllerConfig(agRoot, 0, pageCode, pageLength, pModePage, (agsaContext_t *)agIOCTLPayload); 1001 break; 1002 1003 case tiModePageGet: 1004 status = saGetControllerConfig(agRoot, 0, pageCode, 0, 0, (agsaContext_t *)agIOCTLPayload); 1005 break; 1006 1007 default: 1008 agIOCTLPayload->Status = IOCTL_ERR_STATUS_NOT_SUPPORTED; 1009 } 1010 } 1011 break; 1012 #ifdef PHY_RESTART_TEST 1013 case IOCTL_MJ_PORT_START: 1014 { 1015 bit32 portID, tiStatus; 1016 bit32 *data = (bit32*) &agIOCTLPayload->FunctionSpecificArea[0]; 1017 portID = *data; 1018 1019 tiStatus = tiCOMPortStart(tiRoot, portID, tdsaAllShared->Ports[portID].tiPortalContext, 0); 1020 1021 if (tiStatus == tiSuccess) 1022 { 1023 agIOCTLPayload->Status = IOCTL_ERR_STATUS_OK; 1024 } 1025 else 1026 { 1027 agIOCTLPayload->Status = IOCTL_ERR_STATUS_INTERNAL_ERROR; 1028 } 1029 status = IOCTL_CALL_SUCCESS; 1030 break; 1031 } 1032 1033 case IOCTL_MJ_PORT_STOP: 1034 { 1035 bit32 portID, tiStatus; 1036 bit32 *data = (bit32*) &agIOCTLPayload->FunctionSpecificArea[0]; 1037 portID = *data; 1038 1039 tiStatus = tiCOMPortStop(tiRoot, tdsaAllShared->Ports[portID].tiPortalContext); 1040 if (tiStatus == tiSuccess) 1041 { 1042 agIOCTLPayload->Status = IOCTL_ERR_STATUS_OK; 1043 } 1044 else 1045 { 1046 agIOCTLPayload->Status = IOCTL_ERR_STATUS_INTERNAL_ERROR; 1047 } 1048 1049 status = IOCTL_CALL_SUCCESS; 1050 break; 1051 } 1052 #endif 1053 case IOCTL_MJ_SEND_TMF: 1054 switch(agIOCTLPayload->MinorFunction) 1055 { 1056 case IOCTL_MN_TMF_DEVICE_RESET: 1057 status = tdsaSendTMFIoctl(tiRoot, agIOCTLPayload, agParam1, agParam2, AG_TARGET_WARM_RESET); 1058 break; 1059 case IOCTL_MN_TMF_LUN_RESET: 1060 status = tdsaSendTMFIoctl(tiRoot, agIOCTLPayload, agParam1, agParam2, AG_LOGICAL_UNIT_RESET); 1061 break; 1062 } 1063 break; 1064 case IOCTL_MJ_GET_DRIVER_VERSION: 1065 osti_sprintf(agIOCTLPayload->FunctionSpecificArea, "%s", AGTIAPI_DRIVER_VERSION); 1066 agIOCTLPayload->Status = IOCTL_ERR_STATUS_OK; 1067 status=IOCTL_CALL_SUCCESS; 1068 break; 1069 default: 1070 agIOCTLPayload->Status = IOCTL_ERR_STATUS_NOT_SUPPORTED; 1071 break; 1072 } 1073 1074 return status; 1075 } 1076 1077 #if 0 1078 /***************************************************************************** 1079 * 1080 * tdsaGpioSetup 1081 * 1082 * Purpose: This routine is called to set Gpio parameters to the controller. 1083 * 1084 * Parameters: 1085 * tiRoot: Pointer to driver instance 1086 * agsaContext_t : 1087 * tiIOCTLPayload_t : ioctl header with payload gpio info 1088 * agParam1,agParam2 : Generic parameters 1089 * 1090 * Return: status 1091 * 1092 * 1093 *****************************************************************************/ 1094 osGLOBAL bit32 1095 tdsaGpioSetup( 1096 tiRoot_t *tiRoot, 1097 agsaContext_t *agContext, 1098 tiIOCTLPayload_t *agIOCTLPayload, 1099 void *agParam1, 1100 void *agParam2 1101 ) 1102 { 1103 1104 tdsaTimerRequest_t *osIoctlTimer; 1105 agsaGpioEventSetupInfo_t *gpioEventSetupInfo; 1106 agsaGpioWriteSetupInfo_t *gpioWriteSetupInfo; 1107 agsaGpioPinSetupInfo_t *gpioPinSetupInfo; 1108 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 1109 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 1110 agsaRoot_t *agRoot = &(tdsaAllShared->agRootInt); 1111 bit32 status = IOCTL_CALL_SUCCESS; 1112 1113 TI_DBG3(("tdsaGpioSetup: start\n")); 1114 1115 if(tiRoot == agNULL || agIOCTLPayload == agNULL ) 1116 return IOCTL_CALL_FAIL; 1117 1118 osIoctlTimer = &tdsaAllShared->osIoctlTimer; 1119 tdsaInitTimerRequest(tiRoot, osIoctlTimer); 1120 tdIoctlStartTimer(tiRoot, osIoctlTimer); /* Start the timout handler for both ioctl and controller response */ 1121 tdsaAllShared->tdFWControlEx.virtAddr = (bit8 *)osIoctlTimer; 1122 1123 tdsaAllShared->tdFWControlEx.usrAddr = (bit8 *)&agIOCTLPayload->FunctionSpecificArea[0]; 1124 tdsaAllShared->tdFWControlEx.param1 = agParam1; 1125 tdsaAllShared->tdFWControlEx.param2 = agParam2; 1126 tdsaAllShared->tdFWControlEx.payload = agIOCTLPayload; 1127 tdsaAllShared->tdFWControlEx.inProgress = 1; 1128 1129 switch (agIOCTLPayload->MinorFunction) 1130 { 1131 1132 case IOCTL_MN_GPIO_PINSETUP: 1133 { 1134 TI_DBG3(("tdsaGpioSetup: IOCTL_MN_GPIO_PINSETUP\n")); 1135 gpioPinSetupInfo =(agsaGpioPinSetupInfo_t *)&agIOCTLPayload->FunctionSpecificArea[0]; 1136 status = saGpioPinSetup(agRoot, agContext, 0, gpioPinSetupInfo); 1137 1138 break; 1139 } 1140 case IOCTL_MN_GPIO_EVENTSETUP: 1141 { 1142 TI_DBG3(("tdsaGpioSetup: IOCTL_MN_GPIO_EVENTSETUP\n")); 1143 gpioEventSetupInfo = (agsaGpioEventSetupInfo_t *)&agIOCTLPayload->FunctionSpecificArea[0]; 1144 status = saGpioEventSetup(agRoot, agContext, 0, gpioEventSetupInfo); 1145 1146 break; 1147 } 1148 1149 case IOCTL_MN_GPIO_READ: 1150 { 1151 TI_DBG3(("tdsaGpioSetup: IOCTL_MN_GPIO_READ\n")); 1152 status = saGpioRead(agRoot, agContext, 0); 1153 1154 break; 1155 } 1156 1157 case IOCTL_MN_GPIO_WRITE: 1158 { 1159 TI_DBG3(("tdsaGpioSetup: IOCTL_MN_GPIO_WRITE\n")); 1160 gpioWriteSetupInfo = (agsaGpioWriteSetupInfo_t *)&agIOCTLPayload->FunctionSpecificArea[0]; 1161 status = saGpioWrite(agRoot, agContext, 0, gpioWriteSetupInfo->gpioWritemask, gpioWriteSetupInfo->gpioWriteVal); 1162 1163 break; 1164 } 1165 1166 default : 1167 return status; 1168 } 1169 1170 if(status != AGSA_RC_SUCCESS) 1171 { 1172 status = IOCTL_CALL_FAIL; 1173 agIOCTLPayload->Status = IOCTL_ERR_STATUS_INTERNAL_ERROR; 1174 1175 tdsaSingleThreadedEnter(tiRoot, TD_TIMER_LOCK); 1176 if (osIoctlTimer->timerRunning == agTRUE) 1177 { 1178 tdsaSingleThreadedLeave(tiRoot, TD_TIMER_LOCK); 1179 tdsaKillTimer(tiRoot, osIoctlTimer); 1180 1181 }else{ 1182 tdsaSingleThreadedLeave(tiRoot, TD_TIMER_LOCK); 1183 } 1184 } 1185 1186 TI_DBG3(("tdsaGpioPinSetup: End\n")); 1187 return status; 1188 1189 } 1190 #endif 1191 1192 /***************************************************************************** 1193 * 1194 * ostiGetGpioIOCTLRsp 1195 * 1196 * Purpose: This routine is called for Get Gpio IOCTL reaponse has been received. 1197 * 1198 * Parameters: 1199 * tiRoot: Pointer to driver instance 1200 * payloadRsp: Pointer to the FW download IOMB's payload. 1201 * 1202 * Return: none 1203 * 1204 * 1205 *****************************************************************************/ 1206 1207 osGLOBAL void ostiGetGpioIOCTLRsp( 1208 tiRoot_t *tiRoot, 1209 bit32 status, 1210 bit32 gpioReadValue, 1211 agsaGpioPinSetupInfo_t *gpioPinSetupInfo, 1212 agsaGpioEventSetupInfo_t *gpioEventSetupInfo 1213 ) 1214 { 1215 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 1216 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 1217 tiIOCTLPayload_t *agIoctlPayload ; 1218 agsaGpioReadInfo_t *gpioReadInfo; 1219 1220 tdsaTimerRequest_t *osIoctlTimer; 1221 osIoctlTimer = (tdsaTimerRequest_t *)tdsaAllShared->tdFWControlEx.virtAddr; 1222 1223 TI_DBG2(("ostiGetGpioIOCTLRsp: start, status = %d \n", status)); 1224 1225 agIoctlPayload = (tiIOCTLPayload_t *)(tdsaAllShared->tdFWControlEx.payload); 1226 1227 if(agIoctlPayload == agNULL){ 1228 return; 1229 } 1230 1231 agIoctlPayload->Status =(bit16) status; 1232 1233 if( (status != IOCTL_CALL_TIMEOUT) && (osIoctlTimer != NULL)) 1234 { 1235 tdsaSingleThreadedEnter(tiRoot, TD_TIMER_LOCK); 1236 if (osIoctlTimer->timerRunning == agTRUE) 1237 { 1238 tdsaSingleThreadedLeave(tiRoot, TD_TIMER_LOCK); 1239 tdsaKillTimer(tiRoot, osIoctlTimer); 1240 1241 }else{ 1242 tdsaSingleThreadedLeave(tiRoot, TD_TIMER_LOCK); 1243 } 1244 }else { 1245 tdsaAllShared->tdFWControlEx.inProgress = 0; 1246 agIoctlPayload->Status = (bit16)status; 1247 ostiIOCTLSetSignal(tiRoot, tdsaAllShared->tdFWControlEx.param1, 1248 tdsaAllShared->tdFWControlEx.param2, NULL); 1249 return; 1250 } 1251 1252 if(status == SUCCESS) 1253 TI_DBG3((" ostiGetGpioIOCTLRsp:Got GPIO response from OUTBuf")); 1254 else { 1255 tdsaAllShared->tdFWControlEx.inProgress = 0; 1256 ostiIOCTLSetSignal(tiRoot, tdsaAllShared->tdFWControlEx.param1, 1257 tdsaAllShared->tdFWControlEx.param2, NULL); 1258 return; 1259 } 1260 1261 switch (agIoctlPayload->MinorFunction) 1262 { 1263 1264 case IOCTL_MN_GPIO_PINSETUP: 1265 { 1266 TI_DBG3((" ostiGetGpioIOCTLRsp:Got GPIO response for IOCTL_MN_GPIO_PINSETUP")); 1267 1268 break; 1269 } 1270 case IOCTL_MN_GPIO_EVENTSETUP: 1271 { 1272 TI_DBG3((" ostiGetGpioIOCTLRsp:Got GPIO response for IOCTL_MN_GPIO_EVENTSETUP")); 1273 1274 break; 1275 } 1276 1277 case IOCTL_MN_GPIO_WRITE: 1278 { 1279 TI_DBG3((" ostiGetGpioIOCTLRsp:Got GPIO response for IOCTL_MN_GPIO_WRITE")); 1280 1281 break; 1282 } 1283 1284 case IOCTL_MN_GPIO_READ: 1285 { 1286 gpioReadInfo = ( agsaGpioReadInfo_t *)tdsaAllShared->tdFWControlEx.usrAddr; 1287 1288 gpioReadInfo->gpioReadValue = gpioReadValue; 1289 gpioReadInfo->gpioInputEnabled = gpioPinSetupInfo->gpioInputEnabled ; /* GPIOIE */ 1290 gpioReadInfo->gpioEventLevelChangePart1 = gpioPinSetupInfo->gpioTypePart1; /* GPIEVCHANGE (pins 11-0) */ 1291 gpioReadInfo->gpioEventLevelChangePart2 = gpioPinSetupInfo->gpioTypePart2; /* GPIEVCHANGE (pins 23-20) */ 1292 gpioReadInfo->gpioEventRisingEdgePart1 = 0xFFF & gpioEventSetupInfo->gpioEventRisingEdge; /* GPIEVRISE (pins 11-0) */ 1293 gpioReadInfo->gpioEventRisingEdgePart2 = 0x00F00000 & (gpioEventSetupInfo->gpioEventRisingEdge); /* GPIEVRISE (pins 23-20) */ 1294 gpioReadInfo->gpioEventFallingEdgePart1 = 0xFFF & gpioEventSetupInfo->gpioEventFallingEdge; /* GPIEVALL (pins 11-0) */ 1295 gpioReadInfo->gpioEventFallingEdgePart2 = 0x00F00000 & gpioEventSetupInfo->gpioEventFallingEdge; /* GPIEVALL (pins 23-20 */ 1296 1297 break; 1298 } 1299 1300 default : 1301 break; 1302 } 1303 1304 if(tdsaAllShared->tdFWControlEx.inProgress) 1305 { 1306 tdsaAllShared->tdFWControlEx.inProgress = 0; 1307 ostiIOCTLSetSignal(tiRoot, tdsaAllShared->tdFWControlEx.param1, 1308 tdsaAllShared->tdFWControlEx.param2, NULL); 1309 } 1310 TI_DBG2(("ostiGetGpioIOCTLRsp: end \n")); 1311 1312 return ; 1313 } 1314 1315 /***************************************************************************** 1316 * 1317 * tdsaSGpioIoctlSetup 1318 * 1319 * Purpose: This routine is called to send SGPIO request to the controller. 1320 * 1321 * Parameters: 1322 * tiRoot: Pointer to driver instance 1323 * agsaContext_t: Context for this request 1324 * tiIOCTLPayload_t: ioctl header with payload sgpio info 1325 * agParam1,agParam2: Generic parameters 1326 * 1327 * Return: status 1328 * 1329 * 1330 *****************************************************************************/ 1331 osGLOBAL bit32 1332 tdsaSGpioIoctlSetup( 1333 tiRoot_t *tiRoot, 1334 agsaContext_t *agContext, 1335 tiIOCTLPayload_t *agIOCTLPayload, 1336 void *agParam1, 1337 void *agParam2 1338 ) 1339 { 1340 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 1341 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 1342 agsaRoot_t *agRoot = &(tdsaAllShared->agRootInt); 1343 bit32 status = IOCTL_CALL_FAIL; 1344 agsaSGpioReqResponse_t *pSGpioReq = (agsaSGpioReqResponse_t *)&agIOCTLPayload->FunctionSpecificArea[0]; 1345 1346 TI_DBG3(("tdsaSGpioIoctlSetup: start\n")); 1347 1348 agIOCTLPayload->Status = IOCTL_ERR_STATUS_INTERNAL_ERROR; 1349 1350 do 1351 { 1352 if (tiRoot == agNULL || agIOCTLPayload == agNULL) 1353 { 1354 break; 1355 } 1356 1357 /* Validate the length */ 1358 if (agIOCTLPayload->Length < sizeof(agsaSGpioReqResponse_t)) 1359 { 1360 TI_DBG3(("Invalid length\n")); 1361 break; 1362 } 1363 1364 /* Validate the SMP Frame Type, Function and Register Type fields */ 1365 if ((pSGpioReq->smpFrameType != SMP_REQUEST) || \ 1366 ((pSGpioReq->function != SMP_READ_GPIO_REGISTER) && (pSGpioReq->function != SMP_WRITE_GPIO_REGISTER)) || \ 1367 (pSGpioReq->registerType > AGSA_SGPIO_GENERAL_PURPOSE_TRANSMIT_REG)) 1368 { 1369 TI_DBG4(("Invalid Parameter\n")); 1370 break; 1371 } 1372 1373 /* Specific validation for configuration register type */ 1374 if (AGSA_SGPIO_CONFIG_REG == pSGpioReq->registerType) 1375 { 1376 if ((pSGpioReq->registerIndex > 0x01) || \ 1377 ((0x00 == pSGpioReq->registerIndex) && (pSGpioReq->registerCount > 0x02)) || \ 1378 ((0x01 == pSGpioReq->registerIndex) && (pSGpioReq->registerCount > 0x01))) 1379 { 1380 break; 1381 } 1382 } 1383 1384 /* Use FW control place in shared structure to keep the necessary information */ 1385 tdsaAllShared->tdFWControlEx.param1 = agParam1; 1386 tdsaAllShared->tdFWControlEx.param2 = agParam2; 1387 tdsaAllShared->tdFWControlEx.payload = agIOCTLPayload; 1388 tdsaAllShared->tdFWControlEx.inProgress = 1; 1389 1390 status = saSgpio(agRoot, agContext, 0, pSGpioReq); 1391 if (status != AGSA_RC_SUCCESS) 1392 { 1393 break; 1394 } 1395 1396 status = IOCTL_CALL_PENDING; 1397 1398 } while (0); 1399 1400 TI_DBG3(("tdsaGpioPinSetup: End\n")); 1401 return status; 1402 } 1403 1404 /***************************************************************************** 1405 * 1406 * ostiSgpioIoctlRsp 1407 * 1408 * Purpose: This routine is called when a SGPIO IOCTL response is received. 1409 * 1410 * Parameters: 1411 * tiRoot: Pointer to driver instance 1412 * pSgpioResponse: Pointer to the SGPIO response 1413 * 1414 * Return: none 1415 * 1416 * 1417 *****************************************************************************/ 1418 osGLOBAL void ostiSgpioIoctlRsp( 1419 tiRoot_t *tiRoot, 1420 agsaSGpioReqResponse_t *pSgpioResponse 1421 ) 1422 { 1423 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 1424 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 1425 tiIOCTLPayload_t *agIoctlPayload = agNULL; 1426 1427 TI_DBG3(("ostiSgpioIoctlRsp: start\n")); 1428 1429 if (tdsaAllShared->tdFWControlEx.inProgress) 1430 { 1431 agIoctlPayload = (tiIOCTLPayload_t *)(tdsaAllShared->tdFWControlEx.payload); 1432 if (agIoctlPayload) 1433 { 1434 tdsaAllShared->tdFWControlEx.payload = NULL; 1435 osti_memcpy(&agIoctlPayload->FunctionSpecificArea[0], pSgpioResponse, sizeof(agsaSGpioReqResponse_t)); 1436 agIoctlPayload->Status = IOCTL_ERR_STATUS_OK; 1437 sgpioResponseSet = 1; 1438 } 1439 tdsaAllShared->sgpioResponseSet = 1; //Sunitha:Check if needed? 1440 1441 ostiIOCTLSetSignal(tiRoot, tdsaAllShared->tdFWControlEx.param1, 1442 tdsaAllShared->tdFWControlEx.param2, agNULL); 1443 1444 tdsaAllShared->tdFWControlEx.inProgress = 0; 1445 } 1446 1447 TI_DBG3(("ostiSgpioIoctlRsp: end\n")); 1448 } 1449 /***************************************************************************** 1450 * 1451 * ostiCOMMgntIOCTLRsp 1452 * 1453 * Purpose: This routine is called when FW control IOCTL reaponse has been received. 1454 * This function is used for both target and initiator. 1455 * 1456 * Parameters: 1457 * tiRoot: Pointer to driver instance 1458 * payloadRsp: Pointer to the FW download IOMB's payload. 1459 * 1460 * Return: none 1461 * 1462 * 1463 * 1464 *****************************************************************************/ 1465 1466 osGLOBAL void ostiCOMMgntIOCTLRsp( 1467 tiRoot_t *tiRoot, 1468 bit32 status 1469 ) 1470 { 1471 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 1472 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 1473 1474 TI_DBG1(("ostiCOMMgntIOCTLRsp: status 0x%x\n",status)); 1475 (tdsaAllShared->tdFWControlEx.tdFWControl)->retcode = status; 1476 1477 ostiFreeMemory(tiRoot, 1478 tdsaAllShared->tdFWControlEx.buffer, 1479 tdsaAllShared->tdFWControlEx.tdFWControl->len); 1480 1481 ostiIOCTLSetSignal(tiRoot, 1482 tdsaAllShared->tdFWControlEx.param1, 1483 tdsaAllShared->tdFWControlEx.param2, 1484 NULL); 1485 } 1486 1487 1488 /***************************************************************************** 1489 * 1490 * ostiRegDumpIOCTLRsp 1491 * 1492 * Purpose: This routine is called when Register Dump from flash IOCTL reaponse has been received. 1493 * This function is used for both target and initiator. 1494 * 1495 * Parameters: 1496 * tiRoot: Pointer to driver instance 1497 * payloadRsp: Pointer to the FW download IOMB's payload. 1498 * 1499 * Return: none 1500 * 1501 * 1502 * 1503 *****************************************************************************/ 1504 1505 osGLOBAL void ostiRegDumpIOCTLRsp( 1506 tiRoot_t *tiRoot, 1507 bit32 status 1508 ) 1509 { 1510 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 1511 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 1512 1513 TI_DBG1(("ostiRegDumpIOCTLRsp: start\n")); 1514 // (tdsaAllShared->tdFWControlEx.tdFWControl)->retcode = status; 1515 osti_memcpy((void *)(tdsaAllShared->tdFWControlEx.usrAddr), 1516 (void *)(tdsaAllShared->tdFWControlEx.virtAddr), 1517 tdsaAllShared->tdFWControlEx.len); 1518 1519 ostiFreeMemory(tiRoot, 1520 tdsaAllShared->tdFWControlEx.buffer, 1521 tdsaAllShared->tdFWControlEx.len); 1522 1523 ostiIOCTLSetSignal(tiRoot, 1524 tdsaAllShared->tdFWControlEx.param1, 1525 tdsaAllShared->tdFWControlEx.param2, 1526 NULL); 1527 } 1528 1529 /***************************************************************************** 1530 * 1531 * ostiSetNVMDIOCTLRsp 1532 * 1533 * Purpose: This routine is called for Set NVMD IOCTL reaponse has been received. 1534 * This function is used for both target and initiator. 1535 * 1536 * Parameters: 1537 * tiRoot: Pointer to driver instance 1538 * payloadRsp: Pointer to the FW download IOMB's payload. 1539 * 1540 * Return: none 1541 * 1542 * 1543 * 1544 *****************************************************************************/ 1545 1546 osGLOBAL void ostiSetNVMDIOCTLRsp( 1547 tiRoot_t *tiRoot, 1548 bit32 status 1549 ) 1550 { 1551 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 1552 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 1553 tiIOCTLPayload_t *agIOCTLPayload; 1554 1555 if(status) 1556 { 1557 agIOCTLPayload = (tiIOCTLPayload_t *)(tdsaAllShared->tdFWControlEx.payload); 1558 agIOCTLPayload->Status = (bit16)status; 1559 } 1560 1561 TI_DBG1(("ostiSetNVMDIOCTLRsp: start, status = %d\n", status)); 1562 // (tdsaAllShared->tdFWControlEx.tdFWControl)->retcode = status; 1563 ostiFreeMemory(tiRoot, 1564 tdsaAllShared->tdFWControlEx.buffer, 1565 tdsaAllShared->tdFWControlEx.len); 1566 1567 ostiIOCTLSetSignal(tiRoot, 1568 tdsaAllShared->tdFWControlEx.param1, 1569 tdsaAllShared->tdFWControlEx.param2, 1570 NULL); 1571 } 1572 #ifdef SPC_ENABLE_PROFILE 1573 /***************************************************************************** 1574 * 1575 * ostiFWProfileIOCTLRsp 1576 * 1577 * Purpose: This routine is called for Fw Profile IOCTL reaponse has been received. 1578 * This function is used for both target and initiator. 1579 * 1580 * Parameters: 1581 * tiRoot: Pointer to driver instance 1582 * status: 1583 * 1584 * Return: none 1585 * 1586 * 1587 * 1588 *****************************************************************************/ 1589 1590 osGLOBAL void ostiFWProfileIOCTLRsp( 1591 tiRoot_t *tiRoot, 1592 bit32 status, 1593 bit32 len) 1594 { 1595 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 1596 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 1597 tdFWProfile_t *fwProfile; 1598 1599 TI_DBG1(("ostiFWProfileIOCTLRsp: start\n")); 1600 fwProfile = (tdFWProfile_t *)tdsaAllShared->tdFWProfileEx.tdFWProfile; 1601 // (tdsaAllShared->tdFWControlEx.tdFWControl)->retcode = status; 1602 if (status == AGSA_RC_SUCCESS) 1603 { 1604 if((fwProfile->cmd == STOP_TIMER_PROFILE) || (fwProfile->cmd == STOP_CODE_PROFILE)) 1605 { 1606 osti_memcpy((void *)(fwProfile->buffer), 1607 (void *)(tdsaAllShared->tdFWProfileEx.virtAddr), 1608 len); 1609 1610 ostiFreeMemory(tiRoot, 1611 tdsaAllShared->tdFWProfileEx.buffer, 1612 tdsaAllShared->tdFWProfileEx.len); 1613 } 1614 } 1615 fwProfile->status = status; 1616 fwProfile->len = len; 1617 ostiIOCTLSetSignal(tiRoot, 1618 tdsaAllShared->tdFWProfileEx.param1, 1619 tdsaAllShared->tdFWProfileEx.param2, 1620 NULL); 1621 } 1622 #endif 1623 /***************************************************************************** 1624 * 1625 * ostiGetNVMDIOCTLRsp 1626 * 1627 * Purpose: This routine is called for Get NVMD IOCTL reaponse has been received. 1628 * This function is used for both target and initiator. 1629 * 1630 * Parameters: 1631 * tiRoot: Pointer to driver instance 1632 * payloadRsp: Pointer to the FW download IOMB's payload. 1633 * 1634 * Return: none 1635 * 1636 * 1637 * 1638 *****************************************************************************/ 1639 1640 osGLOBAL void ostiGetNVMDIOCTLRsp( 1641 tiRoot_t *tiRoot, 1642 bit32 status 1643 ) 1644 { 1645 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 1646 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 1647 tiIOCTLPayload_t *agIOCTLPayload; 1648 1649 if(status) 1650 { 1651 agIOCTLPayload = (tiIOCTLPayload_t *)(tdsaAllShared->tdFWControlEx.payload); 1652 agIOCTLPayload->Status = (bit16)status; 1653 } 1654 1655 TI_DBG1(("ostiGetNVMDIOCTLRsp: start, status = %d\n", status)); 1656 tdsaAllShared->NvmdResponseSet = 1; 1657 1658 if(tdsaAllShared->tdFWControlEx.param1 != agNULL) 1659 { 1660 osti_memcpy((void *)(tdsaAllShared->tdFWControlEx.usrAddr), 1661 (void *)(tdsaAllShared->tdFWControlEx.virtAddr), 1662 tdsaAllShared->tdFWControlEx.len); 1663 1664 ostiFreeMemory(tiRoot, 1665 tdsaAllShared->tdFWControlEx.buffer, 1666 tdsaAllShared->tdFWControlEx.len); 1667 1668 ostiIOCTLSetSignal(tiRoot, 1669 tdsaAllShared->tdFWControlEx.param1, 1670 tdsaAllShared->tdFWControlEx.param2, 1671 NULL); 1672 } 1673 } 1674 1675 1676 /***************************************************************************** 1677 * 1678 * ostiGetPhyProfileIOCTLRsp 1679 * 1680 * Purpose: This routine is called for phy response has been received. 1681 * This function is used for both target and initiator. 1682 * 1683 * Parameters: 1684 * tiRoot: Pointer to driver instance 1685 * payloadRsp: Pointer to the IOMB's payload. 1686 * 1687 * Return: none 1688 * 1689 * 1690 * 1691 *****************************************************************************/ 1692 1693 osGLOBAL void ostiGetPhyProfileIOCTLRsp( 1694 tiRoot_t *tiRoot, 1695 bit32 status 1696 ) 1697 { 1698 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 1699 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 1700 tiIOCTLPayload_t *agIOCTLPayload; 1701 tdPhyCount_t *PhyBlob = agNULL; 1702 if(status) 1703 { 1704 agIOCTLPayload = (tiIOCTLPayload_t *)(tdsaAllShared->tdFWControlEx.payload); 1705 agIOCTLPayload->Status = (bit16)status; 1706 1707 PhyBlob = (tdPhyCount_t*)&agIOCTLPayload->FunctionSpecificArea[0]; 1708 if(PhyBlob) 1709 { 1710 // PhyBlob->Phy |= 0x800; 1711 if(PhyBlob->phyResetProblem == 0 ) 1712 { 1713 PhyBlob->phyResetProblem = -1; 1714 } 1715 TI_DBG1(("ostiGetPhyProfileIOCTLRsp: PhyBlob->Phy 0x%x\n",PhyBlob->Phy)); 1716 TI_DBG1(("ostiGetPhyProfileIOCTLRsp: PhyBlob->BW_rx 0x%x\n",PhyBlob->BW_rx)); 1717 TI_DBG1(("ostiGetPhyProfileIOCTLRsp: PhyBlob->BW_tx 0x%x\n",PhyBlob->BW_tx)); 1718 TI_DBG1(("ostiGetPhyProfileIOCTLRsp: PhyBlob->InvalidDword 0x%x\n",PhyBlob->InvalidDword)); 1719 TI_DBG1(("ostiGetPhyProfileIOCTLRsp: PhyBlob->runningDisparityError 0x%x\n",PhyBlob->runningDisparityError)); 1720 TI_DBG1(("ostiGetPhyProfileIOCTLRsp: PhyBlob->codeViolation 0x%x\n",PhyBlob->codeViolation)); 1721 TI_DBG1(("ostiGetPhyProfileIOCTLRsp: PhyBlob->phyResetProblem 0x%x\n",PhyBlob->phyResetProblem)); 1722 TI_DBG1(("ostiGetPhyProfileIOCTLRsp: PhyBlob->inboundCRCError 0x%x\n",PhyBlob->inboundCRCError)); 1723 1724 } 1725 1726 1727 } 1728 1729 TI_DBG1(("ostiGetPhyProfileIOCTLRsp: start, status = %d\n", status)); 1730 TI_DBG1(("ostiGetPhyProfileIOCTLRsp: start, len = %d %p %p\n", tdsaAllShared->tdFWControlEx.len,tdsaAllShared->tdFWControlEx.usrAddr,tdsaAllShared->tdFWControlEx.virtAddr)); 1731 1732 // osti_memcpy((void *)(tdsaAllShared->tdFWControlEx.usrAddr), 1733 // (void *)(tdsaAllShared->tdFWControlEx.virtAddr), 1734 // tdsaAllShared->tdFWControlEx.len); 1735 1736 ostiFreeMemory(tiRoot, 1737 tdsaAllShared->tdFWControlEx.buffer, 1738 tdsaAllShared->tdFWControlEx.len); 1739 1740 ostiIOCTLSetSignal(tiRoot, 1741 tdsaAllShared->tdFWControlEx.param1, 1742 tdsaAllShared->tdFWControlEx.param2, 1743 NULL); 1744 } 1745 1746 1747 /***************************************************************************** 1748 * 1749 * ostiGenEventIOCTLRsp 1750 * 1751 * Purpose: This routine is called when General Event happened while waiting for IOCTL response. 1752 * This function is used for both target and initiator. 1753 * 1754 * Parameters: 1755 * tiRoot: Pointer to driver instance 1756 * payloadRsp: Pointer to the FW download IOMB's payload. 1757 * 1758 * Return: none 1759 * 1760 * 1761 * 1762 *****************************************************************************/ 1763 1764 osGLOBAL void ostiGenEventIOCTLRsp( 1765 tiRoot_t *tiRoot, 1766 bit32 status 1767 ) 1768 { 1769 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 1770 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 1771 tiIOCTLPayload_t *agIOCTLPayload; 1772 1773 TI_DBG1(("ostiGenEventIOCTLRsp: start\n")); 1774 1775 if(tdsaAllShared->tdFWControlEx.inProgress) /*Free only if our IOCTL is in progress*/ 1776 { 1777 agIOCTLPayload = (tiIOCTLPayload_t *)(tdsaAllShared->tdFWControlEx.payload); 1778 agIOCTLPayload->Status = IOCTL_ERR_STATUS_INTERNAL_ERROR; 1779 (tdsaAllShared->tdFWControlEx.tdFWControl)->retcode = IOCTL_ERR_STATUS_INTERNAL_ERROR; 1780 1781 ostiFreeMemory(tiRoot, 1782 tdsaAllShared->tdFWControlEx.buffer, 1783 tdsaAllShared->tdFWControlEx.len); 1784 1785 ostiIOCTLSetSignal(tiRoot, 1786 tdsaAllShared->tdFWControlEx.param1, 1787 tdsaAllShared->tdFWControlEx.param2, 1788 NULL); 1789 tdsaAllShared->tdFWControlEx.inProgress = 0; 1790 } 1791 #ifdef SPC_ENABLE_PROFILE 1792 if(tdsaAllShared->tdFWProfileEx.inProgress) 1793 { 1794 agIOCTLPayload = (tiIOCTLPayload_t *)(tdsaAllShared->tdFWProfileEx.payload); 1795 agIOCTLPayload->Status = IOCTL_ERR_STATUS_INTERNAL_ERROR; 1796 if(tdsaAllShared->tdFWProfileEx.virtAddr != NULL) /*Free only if our IOCTL is in progress*/ 1797 { 1798 ostiFreeMemory(tiRoot, 1799 tdsaAllShared->tdFWProfileEx.buffer, 1800 tdsaAllShared->tdFWProfileEx.len); 1801 tdsaAllShared->tdFWProfileEx.virtAddr = NULL; 1802 } 1803 ostiIOCTLSetSignal(tiRoot, 1804 tdsaAllShared->tdFWProfileEx.param1, 1805 tdsaAllShared->tdFWProfileEx.param2, 1806 NULL); 1807 tdsaAllShared->tdFWProfileEx.inProgress = 0; 1808 1809 } 1810 #endif /*SPC_ENABLE_PROFILE*/ 1811 1812 } 1813 1814 osGLOBAL void 1815 ostiGetDeviceInfoIOCTLRsp( 1816 tiRoot_t *tiRoot, 1817 bit32 status, 1818 void *param 1819 ) 1820 { 1821 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 1822 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 1823 tiIOCTLPayload_t *agIOCTLPayload = agNULL; 1824 tdDeviceInfoPayload_t *pTDDeviceInfo = agNULL; 1825 agsaDeviceInfo_t *pSADeviceInfo = agNULL; 1826 1827 TI_DBG1(("ostiGetDeviceInfoIOCTLRsp: start\n")); 1828 1829 agIOCTLPayload = (tiIOCTLPayload_t *)(tdsaAllShared->tdFWControlEx.payload); 1830 pSADeviceInfo = (agsaDeviceInfo_t*)param; 1831 pTDDeviceInfo = (tdDeviceInfoPayload_t*)agIOCTLPayload->FunctionSpecificArea; 1832 1833 if (pSADeviceInfo != agNULL) 1834 { 1835 /* fill the device information in IOCTL payload */ 1836 osti_memcpy(&pTDDeviceInfo->devInfo.sasAddressHi, pSADeviceInfo->sasAddressHi, sizeof(bit32)); 1837 osti_memcpy(&pTDDeviceInfo->devInfo.sasAddressLo, pSADeviceInfo->sasAddressLo, sizeof(bit32)); 1838 1839 pTDDeviceInfo->devInfo.sasAddressHi = DMA_BEBIT32_TO_BIT32(pTDDeviceInfo->devInfo.sasAddressHi); 1840 pTDDeviceInfo->devInfo.sasAddressLo = DMA_BEBIT32_TO_BIT32(pTDDeviceInfo->devInfo.sasAddressLo); 1841 1842 pTDDeviceInfo->devInfo.deviceType = (pSADeviceInfo->devType_S_Rate & 0x30) >> 4; 1843 pTDDeviceInfo->devInfo.linkRate = pSADeviceInfo->devType_S_Rate & 0x0F; 1844 1845 agIOCTLPayload->Status = IOCTL_ERR_STATUS_OK; 1846 } 1847 else 1848 { 1849 agIOCTLPayload->Status = IOCTL_ERR_STATUS_INVALID_DEVICE; 1850 } 1851 1852 if(tdsaAllShared->tdFWControlEx.inProgress) /*Free only if our IOCTL is in progress*/ 1853 { 1854 ostiIOCTLSetSignal(tiRoot, 1855 tdsaAllShared->tdFWControlEx.param1, 1856 tdsaAllShared->tdFWControlEx.param2, 1857 NULL); 1858 tdsaAllShared->tdFWControlEx.inProgress = 0; 1859 } 1860 } 1861 1862 1863 #ifdef INITIATOR_DRIVER 1864 osGLOBAL void 1865 ostiGetIoErrorStatsIOCTLRsp( 1866 tiRoot_t *tiRoot, 1867 bit32 status, 1868 void *param 1869 ) 1870 { 1871 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 1872 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 1873 itdsaIni_t *Initiator = (itdsaIni_t *)tdsaAllShared->itdsaIni; 1874 tiIOCTLPayload_t *agIOCTLPayload = agNULL; 1875 tdIoErrorStatisticPayload_t *pIoErrorPayload = agNULL; 1876 agsaIOErrorEventStats_t *pIoErrorCount = agNULL; 1877 1878 OS_ASSERT(sizeof(agsaIOErrorEventStats_t) == sizeof(tdIoErrorEventStatisticIOCTL_t), "agsaIOErrorEventStats_t tdIoErrorEventStatisticIOCTL_t\n"); 1879 TI_DBG1(("ostiGetIoErrorStatsIOCTLRsp: start\n")); 1880 1881 agIOCTLPayload = (tiIOCTLPayload_t *)(tdsaAllShared->tdFWControlEx.payload); 1882 pIoErrorPayload = (tdIoErrorStatisticPayload_t*)agIOCTLPayload->FunctionSpecificArea; 1883 pIoErrorCount = (agsaIOErrorEventStats_t*)param; 1884 1885 osti_memcpy(&pIoErrorPayload->IoError, pIoErrorCount, sizeof(agsaIOErrorEventStats_t)); 1886 /*copy SCSI status and sense key count from OS layer to TD layer*/ 1887 osti_memcpy(&pIoErrorPayload->ScsiStatusCounter, &Initiator->ScsiStatusCounts, sizeof(tdSCSIStatusCount_t)); 1888 osti_memcpy(&pIoErrorPayload->SenseKeyCounter, &Initiator->SenseKeyCounter, sizeof(tdSenseKeyCount_t)); 1889 if (pIoErrorPayload->flag) 1890 { 1891 osti_memset(&Initiator->ScsiStatusCounts, 0,sizeof(tdSCSIStatusCount_t) ); 1892 osti_memset(&Initiator->SenseKeyCounter, 0,sizeof(tdSenseKeyCount_t) ); 1893 } 1894 1895 agIOCTLPayload->Status = IOCTL_ERR_STATUS_OK; 1896 } 1897 #endif /* INITIATOR_DRIVER */ 1898 1899 osGLOBAL void 1900 ostiGetIoEventStatsIOCTLRsp( 1901 tiRoot_t *tiRoot, 1902 bit32 status, 1903 void *param 1904 ) 1905 { 1906 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 1907 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 1908 tiIOCTLPayload_t *agIOCTLPayload = agNULL; 1909 tdIoEventStatisticPayload_t *pIoEventPayload = agNULL; 1910 agsaIOErrorEventStats_t *pIoEventCount = agNULL; 1911 1912 TI_DBG1(("ostiGetIoEventStatsIOCTLRsp: start\n")); 1913 1914 agIOCTLPayload = (tiIOCTLPayload_t *)(tdsaAllShared->tdFWControlEx.payload); 1915 pIoEventPayload = (tdIoEventStatisticPayload_t*)agIOCTLPayload->FunctionSpecificArea; 1916 pIoEventCount = (agsaIOErrorEventStats_t*)param; 1917 1918 osti_memcpy(&pIoEventPayload->IoEvent, pIoEventCount, sizeof(agsaIOErrorEventStats_t)); 1919 1920 agIOCTLPayload->Status = IOCTL_ERR_STATUS_OK; 1921 } 1922 1923 osGLOBAL void 1924 ostiGetForensicDataIOCTLRsp( 1925 tiRoot_t *tiRoot, 1926 bit32 status, 1927 void *param 1928 ) 1929 { 1930 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 1931 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 1932 tiIOCTLPayload_t *agIOCTLPayload = agNULL; 1933 tdForensicDataPayload_t *pForensicDataPayload = agNULL; 1934 agsaForensicData_t *pForensicData = agNULL; 1935 1936 TI_DBG3(("ostiGetForensicDataIOCTLRsp: start, status = %d\n", status)); 1937 1938 agIOCTLPayload = (tiIOCTLPayload_t *)(tdsaAllShared->tdFWControlEx.payload); 1939 pForensicDataPayload = (tdForensicDataPayload_t*)agIOCTLPayload->FunctionSpecificArea; 1940 pForensicData = (agsaForensicData_t*)param; 1941 1942 if (agNULL == agIOCTLPayload) 1943 { 1944 return; 1945 } 1946 1947 if (FORENSIC_DATA_TYPE_CHECK_FATAL == pForensicData->DataType) 1948 { 1949 agIOCTLPayload->Status = (bit16)status; 1950 return; 1951 } 1952 1953 if (status == AGSA_RC_SUCCESS) 1954 { 1955 switch (pForensicData->DataType) 1956 { 1957 case FORENSIC_DATA_TYPE_NON_FATAL: 1958 case FORENSIC_DATA_TYPE_FATAL: 1959 pForensicDataPayload->dataBuffer.directOffset = pForensicData->BufferType.dataBuf.directOffset; 1960 pForensicDataPayload->dataBuffer.readLen = pForensicData->BufferType.dataBuf.readLen; 1961 break; 1962 case FORENSIC_DATA_TYPE_GSM_SPACE: 1963 pForensicDataPayload->gsmBuffer.directOffset = pForensicData->BufferType.gsmBuf.directOffset; 1964 pForensicDataPayload->gsmBuffer.readLen = pForensicData->BufferType.gsmBuf.readLen; 1965 break; 1966 1967 case FORENSIC_DATA_TYPE_QUEUE: 1968 break; 1969 1970 default: 1971 TI_DBG1(("ostiGetForensicDataIOCTLRsp: forensic data type error %d\n", pForensicData->DataType)); 1972 break; 1973 } 1974 agIOCTLPayload->Status = IOCTL_ERR_STATUS_OK; 1975 } 1976 else if(status == IOCTL_ERROR_NO_FATAL_ERROR) 1977 { 1978 agIOCTLPayload->Status = (bit16)status; 1979 } 1980 else 1981 { 1982 agIOCTLPayload->Status = IOCTL_ERR_STATUS_INTERNAL_ERROR; 1983 } 1984 1985 /*Free only if our IOCTL is in progress*/ 1986 if(tdsaAllShared->tdFWControlEx.inProgress) 1987 { 1988 TI_DBG3(("ostiGetForensicDataIOCTLRsp: Waiting for the signal \n")); 1989 ostiIOCTLSetSignal(tiRoot, 1990 tdsaAllShared->tdFWControlEx.param1, 1991 tdsaAllShared->tdFWControlEx.param2, 1992 NULL); 1993 TI_DBG3(("ostiGetForensicDataIOCTLRsp: Signal wait completed \n")); 1994 tdsaAllShared->tdFWControlEx.inProgress = 0; 1995 } 1996 } 1997 1998 /***************************************************************************** 1999 * 2000 * tdsaRegDumpGetIoctl 2001 * 2002 * Purpose: This routine is called to get Register Dump information. 2003 * This function is used for both target and initiator. 2004 * 2005 * Parameters: 2006 * tiRoot: Pointer to driver instance 2007 * agIOCTLPayload: Pointer to the IOCTL payload. 2008 * agParam1: Pointer to pass context handle for IOCTL DMA operation 2009 * agParam2: Pointer to pass context handle for IOCTL DMA operation 2010 * agParam3: Pointer to pass context handle for IOCTL DMA operation 2011 * 2012 * Return: 2013 * 2014 * IOCTL_CALL_SUCCESS The requested operation completed successfully. 2015 * IOCTL_CALL_FAIL Fail to complete the IOCTL request. 2016 * Detail error code is function specific and 2017 * defined by the specific IOCTL function. 2018 * IOCTL_CALL_PENDING This request is asynchronous and completed 2019 * in some other context. 2020 * IOCTL_CALL_INVALID_CODE This IOCTL function is not recognized. 2021 * 2022 * 2023 *****************************************************************************/ 2024 osGLOBAL bit32 2025 tdsaRegDumpGetIoctl( 2026 tiRoot_t *tiRoot, 2027 tiIOCTLPayload_t *agIOCTLPayload, 2028 void *agParam1, 2029 void *agParam2, 2030 void *agParam3 2031 ) 2032 { 2033 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 2034 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 2035 agsaRoot_t *agRoot = &(tdsaAllShared->agRootInt); 2036 // agsaControllerStatus_t RegDump; 2037 bit32 Offset = 0; 2038 bit32 RequestLength = 0; /* user request on how much data to pass to application */ 2039 agsaRegDumpInfo_t regDumpInfo; 2040 void *buffer = agNULL; 2041 void *osMemHandle = agNULL; 2042 bit32 status = IOCTL_CALL_SUCCESS; 2043 bit32 CoreDumpLength = 16384; /* change it once data is available */ 2044 bit32 EventLogOffset = 65536; 2045 2046 ///saGetControllerStatus(agRoot, &RegDump); 2047 /* length of FSA as provided by application */ 2048 RequestLength = agIOCTLPayload->Length; 2049 /// FunctionSpecificOffset = 0; /* Offset into the FunctionSpecificArea of payload */ 2050 /* offset into core dump that was passed from application */ 2051 Offset = agIOCTLPayload->Reserved; 2052 2053 if((CoreDumpLength <= Offset)&& 2054 (agIOCTLPayload->MinorFunction != IOCTL_MN_FW_GET_EVENT_FLASH_LOG1)&& 2055 (agIOCTLPayload->MinorFunction != IOCTL_MN_FW_GET_EVENT_FLASH_LOG2)) 2056 { 2057 agIOCTLPayload->Status = IOCTL_ERR_STATUS_NO_MORE_DATA; 2058 agIOCTLPayload->Length = 0; 2059 status=IOCTL_CALL_SUCCESS; 2060 return status; 2061 } 2062 regDumpInfo.regDumpOffset = Offset; 2063 agIOCTLPayload->Status = IOCTL_ERR_STATUS_OK; 2064 /* dump either aap1 or iop registers */ 2065 switch(agIOCTLPayload->MinorFunction){ 2066 2067 /*Coredump*/ 2068 case IOCTL_MN_FW_GET_CORE_DUMP_AAP1: 2069 //CoreDumpBAROffset = RegDump.fatalErrorInfo.regDumpOffset0; /* get this from mpi config table */ 2070 //CoreDumpLength = RegDump.fatalErrorInfo.regDumpLen0; 2071 /*changes for added Call back*/ 2072 tdsaAllShared->tdFWControlEx.param1 = agParam1; 2073 tdsaAllShared->tdFWControlEx.param2 = agParam2; 2074 regDumpInfo.regDumpSrc = 0; 2075 regDumpInfo.regDumpNum = 0; 2076 regDumpInfo.directLen = RequestLength; 2077 regDumpInfo.directData = &agIOCTLPayload->FunctionSpecificArea[0]; 2078 /*changes for added Call back*/ 2079 //status = IOCTL_CALL_SUCCESS; 2080 tdsaAllShared->tdFWControlEx.inProgress = 1; 2081 status = IOCTL_CALL_PENDING; 2082 break; 2083 case IOCTL_MN_FW_GET_CORE_DUMP_IOP: 2084 //CoreDumpBAROffset = RegDump.fatalErrorInfo.regDumpOffset1; /* get this from mpi config table */ 2085 //CoreDumpLength = RegDump.fatalErrorInfo.regDumpLen1; 2086 /*changes for added Call back*/ 2087 tdsaAllShared->tdFWControlEx.param1 = agParam1; 2088 tdsaAllShared->tdFWControlEx.param2 = agParam2; 2089 regDumpInfo.regDumpSrc = 0; 2090 regDumpInfo.regDumpNum = 1; 2091 regDumpInfo.directLen = RequestLength; 2092 regDumpInfo.directData = &agIOCTLPayload->FunctionSpecificArea[0]; 2093 /*changes for added Call back*/ 2094 //status = IOCTL_CALL_SUCCESS; 2095 tdsaAllShared->tdFWControlEx.inProgress = 1; 2096 status = IOCTL_CALL_PENDING; 2097 break; 2098 case IOCTL_MN_FW_GET_CORE_DUMP_FLASH_AAP1: 2099 regDumpInfo.regDumpSrc = 1; 2100 regDumpInfo.regDumpNum = 0; 2101 if(RequestLength != 0) 2102 { 2103 if(ostiAllocMemory( tiRoot, 2104 &osMemHandle, 2105 (void **)&buffer, 2106 &(regDumpInfo.indirectAddrUpper32), 2107 &(regDumpInfo.indirectAddrLower32), 2108 8, 2109 RequestLength, 2110 agFALSE)) 2111 return IOCTL_CALL_FAIL; 2112 } 2113 osti_memset((void *)buffer, 0, RequestLength); 2114 regDumpInfo.indirectLen = RequestLength; 2115 2116 // use FW control place in shared structure to keep the neccesary information 2117 tdsaAllShared->tdFWControlEx.buffer = osMemHandle; 2118 tdsaAllShared->tdFWControlEx.virtAddr = buffer; 2119 tdsaAllShared->tdFWControlEx.usrAddr = (bit8*)&agIOCTLPayload->FunctionSpecificArea[0]; 2120 tdsaAllShared->tdFWControlEx.len = RequestLength; 2121 tdsaAllShared->tdFWControlEx.param1 = agParam1; 2122 tdsaAllShared->tdFWControlEx.param2 = agParam2; 2123 tdsaAllShared->tdFWControlEx.payload = agIOCTLPayload; 2124 tdsaAllShared->tdFWControlEx.inProgress = 1; 2125 status = IOCTL_CALL_PENDING; 2126 break; 2127 case IOCTL_MN_FW_GET_CORE_DUMP_FLASH_IOP: 2128 regDumpInfo.regDumpSrc = 1; 2129 regDumpInfo.regDumpNum = 1; 2130 if(RequestLength != 0) 2131 { 2132 if(ostiAllocMemory( tiRoot, 2133 &osMemHandle, 2134 (void **)&buffer, 2135 &(regDumpInfo.indirectAddrUpper32), 2136 &(regDumpInfo.indirectAddrLower32), 2137 8, 2138 RequestLength, 2139 agFALSE)) 2140 return IOCTL_CALL_FAIL; 2141 } 2142 osti_memset((void *)buffer, 0, RequestLength); 2143 regDumpInfo.indirectLen = RequestLength; 2144 2145 // use FW control place in shared structure to keep the neccesary information 2146 tdsaAllShared->tdFWControlEx.buffer = osMemHandle; 2147 tdsaAllShared->tdFWControlEx.virtAddr = buffer; 2148 tdsaAllShared->tdFWControlEx.usrAddr = (bit8*)&agIOCTLPayload->FunctionSpecificArea[0]; 2149 tdsaAllShared->tdFWControlEx.len = RequestLength; 2150 tdsaAllShared->tdFWControlEx.param1 = agParam1; 2151 tdsaAllShared->tdFWControlEx.param2 = agParam2; 2152 tdsaAllShared->tdFWControlEx.payload = agIOCTLPayload; 2153 tdsaAllShared->tdFWControlEx.inProgress = 1; 2154 status = IOCTL_CALL_PENDING; 2155 break; 2156 /*EventLog from Flash*/ 2157 case IOCTL_MN_FW_GET_EVENT_FLASH_LOG1: //aap1 Eventlog 2158 if(CoreDumpLength + EventLogOffset <= Offset) 2159 { 2160 agIOCTLPayload->Status = IOCTL_ERR_STATUS_NO_MORE_DATA; 2161 agIOCTLPayload->Length = 0; 2162 status=IOCTL_CALL_SUCCESS; 2163 return status; 2164 } 2165 regDumpInfo.regDumpSrc = 1; 2166 regDumpInfo.regDumpNum = 0; 2167 if(RequestLength != 0) 2168 { 2169 if(ostiAllocMemory( tiRoot, 2170 &osMemHandle, 2171 (void **)&buffer, 2172 &(regDumpInfo.indirectAddrUpper32), 2173 &(regDumpInfo.indirectAddrLower32), 2174 8, 2175 RequestLength, 2176 agFALSE)) 2177 return IOCTL_CALL_FAIL; 2178 } 2179 osti_memset((void *)buffer, 0, RequestLength); 2180 regDumpInfo.indirectLen = RequestLength; 2181 2182 // use FW control place in shared structure to keep the neccesary information 2183 tdsaAllShared->tdFWControlEx.buffer = osMemHandle; 2184 tdsaAllShared->tdFWControlEx.virtAddr = buffer; 2185 tdsaAllShared->tdFWControlEx.usrAddr = (bit8*)&agIOCTLPayload->FunctionSpecificArea[0]; 2186 tdsaAllShared->tdFWControlEx.len = RequestLength; 2187 tdsaAllShared->tdFWControlEx.param1 = agParam1; 2188 tdsaAllShared->tdFWControlEx.param2 = agParam2; 2189 tdsaAllShared->tdFWControlEx.payload = agIOCTLPayload; 2190 tdsaAllShared->tdFWControlEx.inProgress = 1; 2191 status = IOCTL_CALL_PENDING; 2192 break; 2193 case IOCTL_MN_FW_GET_EVENT_FLASH_LOG2: //iop Eventlog 2194 if(CoreDumpLength + EventLogOffset <= Offset) 2195 { 2196 agIOCTLPayload->Status = IOCTL_ERR_STATUS_NO_MORE_DATA; 2197 agIOCTLPayload->Length = 0; 2198 status=IOCTL_CALL_SUCCESS; 2199 return status; 2200 } 2201 regDumpInfo.regDumpSrc = 1; 2202 regDumpInfo.regDumpNum = 1; 2203 if(RequestLength != 0) 2204 { 2205 if(ostiAllocMemory( tiRoot, 2206 &osMemHandle, 2207 (void **)&buffer, 2208 &(regDumpInfo.indirectAddrUpper32), 2209 &(regDumpInfo.indirectAddrLower32), 2210 8, 2211 RequestLength, 2212 agFALSE)) 2213 return IOCTL_CALL_FAIL; 2214 } 2215 osti_memset((void *)buffer, 0, RequestLength); 2216 regDumpInfo.indirectLen = RequestLength; 2217 2218 // use FW control place in shared structure to keep the neccesary information 2219 tdsaAllShared->tdFWControlEx.buffer = osMemHandle; 2220 tdsaAllShared->tdFWControlEx.virtAddr = buffer; 2221 tdsaAllShared->tdFWControlEx.usrAddr = (bit8*)&agIOCTLPayload->FunctionSpecificArea[0]; 2222 tdsaAllShared->tdFWControlEx.len = RequestLength; 2223 tdsaAllShared->tdFWControlEx.param1 = agParam1; 2224 tdsaAllShared->tdFWControlEx.param2 = agParam2; 2225 tdsaAllShared->tdFWControlEx.payload = agIOCTLPayload; 2226 tdsaAllShared->tdFWControlEx.inProgress = 1; 2227 status = IOCTL_CALL_PENDING; 2228 break; 2229 default: 2230 status = IOCTL_CALL_INVALID_CODE; 2231 TI_DBG1(("tiCOMMgntIOCTL: ERROR: Wrong IOCTL code %d\n", agIOCTLPayload->MinorFunction)); 2232 break; 2233 } 2234 if(saGetRegisterDump(agRoot, agNULL, 0, ®DumpInfo) != AGSA_RC_SUCCESS) 2235 { 2236 status = IOCTL_CALL_FAIL; 2237 agIOCTLPayload->Status = IOCTL_ERR_STATUS_INTERNAL_ERROR; 2238 } 2239 2240 return status; 2241 } 2242 2243 osGLOBAL void 2244 ostiCOMMgntVPDSetIOCTLRsp( 2245 tiRoot_t *tiRoot, 2246 bit32 status 2247 ) 2248 { 2249 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 2250 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 2251 // agsaRoot_t *agRoot = &(tdsaAllShared->agRootInt); 2252 2253 TI_DBG1(("ostiCOMMgntVPDSetIOCTLRsp: start\n")); 2254 (tdsaAllShared->tdFWControlEx.tdFWControl)->retcode = status; 2255 2256 ostiFreeMemory(tiRoot, 2257 tdsaAllShared->tdFWControlEx.buffer, 2258 tdsaAllShared->tdFWControlEx.len); 2259 2260 ostiIOCTLSetSignal(tiRoot, tdsaAllShared->tdFWControlEx.param1, 2261 tdsaAllShared->tdFWControlEx.param2, 2262 NULL); 2263 } 2264 2265 /***************************************************************************** 2266 * 2267 * tdsaNVMDSetIoctl 2268 * 2269 * Purpose: This routine is called to set Config. SEEPROM information. 2270 * This function is used for both target and initiator. 2271 * 2272 * Parameters: 2273 * tiRoot: Pointer to driver instance 2274 * agIOCTLPayload: Pointer to the IOCTL payload. 2275 * agParam1: Pointer to pass context handle for IOCTL DMA operation 2276 * agParam2: Pointer to pass context handle for IOCTL DMA operation 2277 * agParam3: Pointer to pass context handle for IOCTL DMA operation 2278 * 2279 * Return: 2280 * 2281 * IOCTL_CALL_SUCCESS The requested operation completed successfully. 2282 * IOCTL_CALL_FAIL Fail to complete the IOCTL request. 2283 * Detail error code is function specific and 2284 * defined by the specific IOCTL function. 2285 * IOCTL_CALL_PENDING This request is asynchronous and completed 2286 * in some other context. 2287 * IOCTL_CALL_INVALID_CODE This IOCTL function is not recognized. 2288 * 2289 * 2290 *****************************************************************************/ 2291 osGLOBAL bit32 2292 tdsaNVMDSetIoctl( 2293 tiRoot_t *tiRoot, 2294 tiIOCTLPayload_t *agIOCTLPayload, 2295 void *agParam1, 2296 void *agParam2, 2297 void *agParam3 2298 ) 2299 { 2300 bit32 RequestLength = 0; 2301 bit32 bufAddrUpper = 0; 2302 bit32 bufAddrLower = 0; 2303 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 2304 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 2305 agsaRoot_t *agRoot = &(tdsaAllShared->agRootInt); 2306 void *buffer = agNULL; 2307 void *osMemHandle = agNULL; 2308 bit32 status = IOCTL_CALL_SUCCESS; 2309 agsaNVMDData_t nvmdInfo; 2310 2311 2312 TI_DBG2(("tdsaNVMDSetIoctl: start\n")); 2313 2314 RequestLength = agIOCTLPayload->Length; 2315 2316 osti_memset(&nvmdInfo, 0, sizeof(agsaNVMDData_t)); 2317 2318 switch(agIOCTLPayload->MinorFunction) 2319 { 2320 case IOCTL_MN_NVMD_SET_CONFIG: 2321 2322 //nvmdInfo.NVMDevice = 1; 2323 nvmdInfo.NVMDevice = *((bit8*)agParam3); 2324 nvmdInfo.signature = 0xFEDCBA98; 2325 nvmdInfo.dataOffsetAddress = agIOCTLPayload->Reserved; 2326 nvmdInfo.indirectPayload = 1; 2327 nvmdInfo.indirectLen = RequestLength; 2328 2329 if (nvmdInfo.NVMDevice == 0) { 2330 nvmdInfo.TWIDeviceAddress = 0xa0; 2331 nvmdInfo.TWIBusNumber = 0; 2332 nvmdInfo.TWIDevicePageSize = 0; 2333 nvmdInfo.TWIDeviceAddressSize = 1; 2334 } 2335 2336 if(RequestLength != 0) 2337 { 2338 if(ostiAllocMemory( tiRoot, 2339 &osMemHandle, 2340 (void **)&buffer, 2341 &bufAddrUpper, 2342 &bufAddrLower, 2343 8, 2344 RequestLength, 2345 agFALSE)) 2346 return IOCTL_CALL_FAIL; 2347 } 2348 else 2349 { 2350 return IOCTL_CALL_FAIL; 2351 } 2352 2353 osti_memset((void *)buffer, 0, RequestLength); 2354 2355 osti_memcpy((void *)buffer, 2356 agIOCTLPayload->FunctionSpecificArea, 2357 RequestLength); 2358 2359 nvmdInfo.indirectAddrLower32 = bufAddrLower; 2360 nvmdInfo.indirectAddrUpper32 = bufAddrUpper; 2361 // use FW control place in shared structure to keep the neccesary information 2362 tdsaAllShared->tdFWControlEx.buffer = osMemHandle; 2363 tdsaAllShared->tdFWControlEx.virtAddr = buffer; 2364 tdsaAllShared->tdFWControlEx.usrAddr = (bit8*)&agIOCTLPayload->FunctionSpecificArea[0]; 2365 tdsaAllShared->tdFWControlEx.len = RequestLength; 2366 tdsaAllShared->tdFWControlEx.param1 = agParam1; 2367 tdsaAllShared->tdFWControlEx.param2 = agParam2; 2368 tdsaAllShared->tdFWControlEx.payload = agIOCTLPayload; 2369 tdsaAllShared->tdFWControlEx.inProgress = 1; 2370 status = IOCTL_CALL_PENDING; 2371 break; 2372 default: 2373 status = IOCTL_CALL_INVALID_CODE; 2374 TI_DBG1(("tdsaNVMDSetIoctl: ERROR: Wrong IOCTL code %d\n", agIOCTLPayload->MinorFunction)); 2375 break; 2376 } 2377 2378 if(saSetNVMDCommand(agRoot, agNULL, 0, &nvmdInfo) != AGSA_RC_SUCCESS) 2379 { 2380 status = IOCTL_CALL_FAIL; 2381 agIOCTLPayload->Status = IOCTL_ERR_STATUS_INTERNAL_ERROR; 2382 } 2383 2384 return status; 2385 2386 } 2387 2388 /***************************************************************************** 2389 * 2390 * tdsaNVMDGetIoctl 2391 * 2392 * Purpose: This routine is called to get Config. SEEPROM information. 2393 * This function is used for both target and initiator. 2394 * 2395 * Parameters: 2396 * tiRoot: Pointer to driver instance 2397 * agIOCTLPayload: Pointer to the IOCTL payload. 2398 * agParam1: Pointer to pass context handle for IOCTL DMA operation 2399 * agParam2: Pointer to pass context handle for IOCTL DMA operation 2400 * agParam3: Pointer to pass context handle for IOCTL DMA operation 2401 * 2402 * Return: 2403 * 2404 * IOCTL_CALL_SUCCESS The requested operation completed successfully. 2405 * IOCTL_CALL_FAIL Fail to complete the IOCTL request. 2406 * Detail error code is function specific and 2407 * defined by the specific IOCTL function. 2408 * IOCTL_CALL_PENDING This request is asynchronous and completed 2409 * in some other context. 2410 * IOCTL_CALL_INVALID_CODE This IOCTL function is not recognized. 2411 * 2412 * 2413 *****************************************************************************/ 2414 osGLOBAL bit32 2415 tdsaNVMDGetIoctl( 2416 tiRoot_t *tiRoot, 2417 tiIOCTLPayload_t *agIOCTLPayload, 2418 void *agParam1, 2419 void *agParam2, 2420 void *agParam3 2421 ) 2422 { 2423 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 2424 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 2425 agsaRoot_t *agRoot = &(tdsaAllShared->agRootInt); 2426 void *buffer = agNULL; 2427 void *osMemHandle = agNULL; 2428 bit32 status = IOCTL_CALL_SUCCESS; 2429 agsaNVMDData_t nvmdInfo; 2430 bit32 Offset = 0; 2431 bit32 RequestLength = 0; 2432 bit32 ostiMemoryStatus = 0; 2433 bit32 i,j; 2434 bit8* seepromBuffer; 2435 bit8* phySettingsBuffer; 2436 2437 2438 TI_DBG2(("tdsaNVMDGetIoctl: start\n")); 2439 2440 RequestLength = agIOCTLPayload->Length; 2441 Offset = agIOCTLPayload->Reserved; 2442 2443 osti_memset(&nvmdInfo, 0, sizeof(agsaNVMDData_t)); 2444 /* This condition is not valid for direct read so commenting */ 2445 /*if(!tiIS_SPC(agRoot)) { 2446 if( RequestLength <= Offset ) //4096-max seeprom size 2447 { 2448 agIOCTLPayload->Status = IOCTL_ERR_STATUS_NO_MORE_DATA; 2449 agIOCTLPayload->Length = 0; 2450 status=IOCTL_CALL_SUCCESS; 2451 return status; 2452 } 2453 }*/ 2454 2455 agIOCTLPayload->Status = IOCTL_ERR_STATUS_OK; 2456 2457 switch(agIOCTLPayload->MinorFunction) 2458 { 2459 case IOCTL_MN_NVMD_GET_CONFIG: 2460 2461 // nvmdInfo.NVMDevice = 1; 2462 nvmdInfo.NVMDevice = *((bit8*)agParam3); 2463 nvmdInfo.signature = 0xFEDCBA98; 2464 nvmdInfo.dataOffsetAddress = Offset; 2465 nvmdInfo.indirectPayload = 1; 2466 nvmdInfo.indirectLen = RequestLength; 2467 2468 if (nvmdInfo.NVMDevice == 0) { 2469 nvmdInfo.TWIDeviceAddress = 0xa0; 2470 nvmdInfo.TWIBusNumber = 0; 2471 nvmdInfo.TWIDevicePageSize = 0; 2472 nvmdInfo.TWIDeviceAddressSize = 1; 2473 } 2474 2475 if(RequestLength != 0) 2476 { 2477 ostiMemoryStatus = ostiAllocMemory( tiRoot, 2478 &osMemHandle, 2479 (void **)&buffer, 2480 &(nvmdInfo.indirectAddrUpper32), 2481 &(nvmdInfo.indirectAddrLower32), 2482 8, 2483 RequestLength, 2484 agFALSE); 2485 if((ostiMemoryStatus != tiSuccess) && (buffer == agNULL)) 2486 return IOCTL_CALL_FAIL; 2487 } 2488 else 2489 { 2490 return IOCTL_CALL_FAIL; 2491 } 2492 osti_memset((void *)buffer, 0, RequestLength); 2493 2494 // use FW control place in shared structure to keep the neccesary information 2495 tdsaAllShared->tdFWControlEx.buffer = osMemHandle; 2496 tdsaAllShared->tdFWControlEx.virtAddr = buffer; 2497 tdsaAllShared->tdFWControlEx.usrAddr = (bit8*)&agIOCTLPayload->FunctionSpecificArea[0]; 2498 tdsaAllShared->tdFWControlEx.len = RequestLength; 2499 tdsaAllShared->tdFWControlEx.param1 = agParam1; 2500 tdsaAllShared->tdFWControlEx.param2 = agParam2; 2501 tdsaAllShared->tdFWControlEx.payload = agIOCTLPayload; 2502 tdsaAllShared->tdFWControlEx.inProgress = 1; 2503 status = IOCTL_CALL_PENDING; 2504 break; 2505 default: 2506 status = IOCTL_CALL_INVALID_CODE; 2507 TI_DBG1(("tiCOMMgntIOCTL: ERROR: Wrong IOCTL code %d\n", agIOCTLPayload->MinorFunction)); 2508 break; 2509 } 2510 tdsaAllShared->NvmdResponseSet = 0; 2511 2512 if(saGetNVMDCommand(agRoot, agNULL, 0, &nvmdInfo) != AGSA_RC_SUCCESS) 2513 { 2514 status = IOCTL_CALL_FAIL; 2515 agIOCTLPayload->Status = IOCTL_ERR_STATUS_INTERNAL_ERROR; 2516 return status; 2517 } 2518 /* Copy the SAS address */ 2519 if(agParam1 == agNULL) 2520 2521 { 2522 while(!tdsaAllShared->NvmdResponseSet) 2523 { 2524 // tiCOMDelayedInterruptHandler(tiRoot, 0, 1, tiNonInterruptContext); 2525 } 2526 if(nvmdInfo.NVMDevice == 4 || nvmdInfo.NVMDevice == 1) 2527 { 2528 seepromBuffer = buffer; 2529 /*Get Initiator SAS address*/ 2530 2531 if(tiIS_SPC(agRoot)) 2532 { 2533 for(j=0,i=ADAPTER_WWN_SPC_START_OFFSET; i<= ADAPTER_WWN_SPC_END_OFFSET; i++,j++) 2534 agIOCTLPayload->FunctionSpecificArea[j] = seepromBuffer[i]; 2535 } 2536 else 2537 { 2538 for(j=0,i=ADAPTER_WWN_START_OFFSET; i<= ADAPTER_WWN_END_OFFSET; i++,j++) 2539 agIOCTLPayload->FunctionSpecificArea[j] = seepromBuffer[i]; 2540 } 2541 } 2542 /* Copy the Phy settings */ 2543 else if(nvmdInfo.NVMDevice == 6) 2544 { 2545 phySettingsBuffer = buffer; 2546 for(i=0; i<PHY_SETTINGS_LEN; i++) 2547 agIOCTLPayload->FunctionSpecificArea[i] = phySettingsBuffer[i]; 2548 } 2549 tdsaAllShared->NvmdResponseSet = 0; 2550 ostiFreeMemory(tiRoot, tdsaAllShared->tdFWControlEx.buffer, tdsaAllShared->tdFWControlEx.len); 2551 2552 } 2553 return status; 2554 2555 } 2556 2557 /***************************************************************************** 2558 * 2559 * tdsaDeviceInfoGetIoctl 2560 * 2561 * Purpose: This routine is called to get the specified device information. 2562 * 2563 * Parameters: 2564 * tiRoot: Pointer to driver instance 2565 * agIOCTLPayload: Pointer to the IOCTL payload. 2566 * agParam1: Pointer to pass context handle for IOCTL DMA operation 2567 * agParam2: Pointer to pass context handle for IOCTL DMA operation 2568 * agParam3: Pointer to pass context handle for IOCTL DMA operation 2569 * 2570 * Return: 2571 * 2572 * IOCTL_CALL_SUCCESS The requested operation completed successfully. 2573 * IOCTL_CALL_FAIL Fail to complete the IOCTL request. 2574 * Detail error code is function specific and 2575 * defined by the specific IOCTL function. 2576 * IOCTL_CALL_PENDING This request is asynchronous and completed 2577 * in some other context. 2578 * IOCTL_CALL_INVALID_CODE This IOCTL function is not recognized. 2579 * 2580 * 2581 *****************************************************************************/ 2582 osGLOBAL bit32 2583 tdsaDeviceInfoGetIoctl( 2584 tiRoot_t *tiRoot, 2585 tiIOCTLPayload_t *agIOCTLPayload, 2586 void *agParam1, 2587 void *agParam2, 2588 void *agParam3 2589 ) 2590 { 2591 tdsaDeviceData_t *oneDeviceData = agNULL; 2592 tiDeviceHandle_t *tiDeviceHandle = agNULL; 2593 tdDeviceInfoPayload_t *pDeviceInfo = agNULL; 2594 /*agsaDevHandle_t *agDevHandle = agNULL;*/ 2595 bit32 status = IOCTL_CALL_SUCCESS; 2596 2597 pDeviceInfo = (tdDeviceInfoPayload_t*)agIOCTLPayload->FunctionSpecificArea; 2598 2599 TI_DBG3(("tdsaDeviceInfoGetIoctl: %d:%3d:%d %p %p %p\n", 2600 (bit8)pDeviceInfo->PathId, 2601 (bit8)pDeviceInfo->TargetId, 2602 (bit8)pDeviceInfo->Lun, 2603 agParam1, 2604 agParam2, 2605 agParam3)); 2606 2607 tiDeviceHandle = ostiMapToDevHandle(tiRoot, 2608 (bit8)pDeviceInfo->PathId, 2609 (bit8)pDeviceInfo->TargetId, 2610 (bit8)pDeviceInfo->Lun 2611 ); 2612 2613 if (tiDeviceHandle == agNULL) 2614 { 2615 TI_DBG1(("tdsaDeviceInfoGetIoctl: tiDeviceHandle is NULL !!!! SCSI address = %d:%3d:%d\n", 2616 pDeviceInfo->PathId, pDeviceInfo->TargetId, pDeviceInfo->Lun)); 2617 agIOCTLPayload->Status = IOCTL_ERR_STATUS_INVALID_DEVICE; 2618 status = IOCTL_CALL_FAIL; 2619 return status; 2620 } 2621 2622 oneDeviceData = (tdsaDeviceData_t *)tiDeviceHandle->tdData; 2623 if(oneDeviceData == agNULL) 2624 { 2625 TI_DBG1(("tdsaDeviceInfoGetIoctl: tiDeviceHandle=%p DeviceData is NULL!!! SCSI address = %d:%3d:%d\n", 2626 tiDeviceHandle, pDeviceInfo->PathId, pDeviceInfo->TargetId, pDeviceInfo->Lun)); 2627 agIOCTLPayload->Status = IOCTL_ERR_STATUS_INVALID_DEVICE; 2628 status = IOCTL_CALL_FAIL; 2629 return status; 2630 } 2631 2632 /* for hotplug */ 2633 if (oneDeviceData->valid != agTRUE || oneDeviceData->registered != agTRUE || 2634 oneDeviceData->tdPortContext == agNULL ) 2635 { 2636 TI_DBG1(("tdsaDeviceInfoGetIoctl: tiDeviceHandle=%p did %d DeviceData was removed!!! SCSI address = %d:%3d:%d\n", 2637 tiDeviceHandle, oneDeviceData->id, pDeviceInfo->PathId, pDeviceInfo->TargetId, pDeviceInfo->Lun)); 2638 agIOCTLPayload->Status = IOCTL_ERR_STATUS_INVALID_DEVICE; 2639 status = IOCTL_CALL_FAIL; 2640 return status; 2641 } 2642 2643 /* fill the device information in IOCTL payload */ 2644 pDeviceInfo->devInfo.phyId = oneDeviceData->phyID; 2645 osti_memcpy(&pDeviceInfo->devInfo.sasAddressHi, oneDeviceData->agDeviceInfo.sasAddressHi, sizeof(bit32)); 2646 osti_memcpy(&pDeviceInfo->devInfo.sasAddressLo, oneDeviceData->agDeviceInfo.sasAddressLo, sizeof(bit32)); 2647 2648 pDeviceInfo->devInfo.sasAddressHi = DMA_BEBIT32_TO_BIT32(pDeviceInfo->devInfo.sasAddressHi); 2649 pDeviceInfo->devInfo.sasAddressLo = DMA_BEBIT32_TO_BIT32(pDeviceInfo->devInfo.sasAddressLo); 2650 2651 pDeviceInfo->devInfo.deviceType = (oneDeviceData->agDeviceInfo.devType_S_Rate & 0x30) >> 4; 2652 pDeviceInfo->devInfo.linkRate = oneDeviceData->agDeviceInfo.devType_S_Rate & 0x0F; 2653 2654 agIOCTLPayload->Status = IOCTL_ERR_STATUS_OK; 2655 2656 TI_DBG3(("tdsaDeviceInfoGetIoctl:IOCTL_CALL_SUCCESS\n")); 2657 2658 /*saGetDeviceInfo(agRoot, agNULL, 0, 0, agDevHandle);*/ 2659 2660 status = IOCTL_CALL_SUCCESS; 2661 2662 return status; 2663 } 2664 /***************************************************************************** 2665 * 2666 * tdsaIoErrorStatisticGetIoctl 2667 * 2668 * Purpose: This routine is called to get the IO error statistic. 2669 * 2670 * Parameters: 2671 * tiRoot: Pointer to driver instance 2672 * agIOCTLPayload: Pointer to the IOCTL payload. 2673 * agParam1: Pointer to pass context handle for IOCTL DMA operation 2674 * agParam2: Pointer to pass context handle for IOCTL DMA operation 2675 * agParam3: Pointer to pass context handle for IOCTL DMA operation 2676 * 2677 * Return: 2678 * 2679 * IOCTL_CALL_SUCCESS The requested operation completed successfully. 2680 * IOCTL_CALL_FAIL Fail to complete the IOCTL request. 2681 * Detail error code is function specific and 2682 * defined by the specific IOCTL function. 2683 * IOCTL_CALL_PENDING This request is asynchronous and completed 2684 * in some other context. 2685 * IOCTL_CALL_INVALID_CODE This IOCTL function is not recognized. 2686 * 2687 * 2688 *****************************************************************************/ 2689 osGLOBAL bit32 2690 tdsaIoErrorStatisticGetIoctl( 2691 tiRoot_t *tiRoot, 2692 tiIOCTLPayload_t *agIOCTLPayload, 2693 void *agParam1, 2694 void *agParam2, 2695 void *agParam3 2696 ) 2697 { 2698 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 2699 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 2700 agsaRoot_t *agRoot = &(tdsaAllShared->agRootInt); 2701 tdIoErrorStatisticPayload_t *pIoErrorPayload = agNULL; 2702 bit32 status = IOCTL_CALL_SUCCESS; 2703 2704 pIoErrorPayload = (tdIoErrorStatisticPayload_t*)agIOCTLPayload->FunctionSpecificArea; 2705 2706 tdsaAllShared->tdFWControlEx.buffer = agNULL; 2707 tdsaAllShared->tdFWControlEx.virtAddr = agNULL; 2708 tdsaAllShared->tdFWControlEx.usrAddr = (bit8*)&agIOCTLPayload->FunctionSpecificArea[0]; 2709 tdsaAllShared->tdFWControlEx.len = 0; 2710 tdsaAllShared->tdFWControlEx.param1 = agParam1; 2711 tdsaAllShared->tdFWControlEx.param2 = agParam2; 2712 tdsaAllShared->tdFWControlEx.payload = agIOCTLPayload; 2713 tdsaAllShared->tdFWControlEx.inProgress = 0; 2714 2715 saGetIOErrorStats(agRoot, agNULL, pIoErrorPayload->flag); 2716 2717 return status; 2718 } 2719 2720 /***************************************************************************** 2721 * 2722 * tdsaIoEventStatisticGetIoctl 2723 * 2724 * Purpose: This routine is called to get the IO event statistic. 2725 * 2726 * Parameters: 2727 * tiRoot: Pointer to driver instance 2728 * agIOCTLPayload: Pointer to the IOCTL payload. 2729 * agParam1: Pointer to pass context handle for IOCTL DMA operation 2730 * agParam2: Pointer to pass context handle for IOCTL DMA operation 2731 * agParam3: Pointer to pass context handle for IOCTL DMA operation 2732 * 2733 * Return: 2734 * 2735 * IOCTL_CALL_SUCCESS The requested operation completed successfully. 2736 * IOCTL_CALL_FAIL Fail to complete the IOCTL request. 2737 * Detail error code is function specific and 2738 * defined by the specific IOCTL function. 2739 * IOCTL_CALL_PENDING This request is asynchronous and completed 2740 * in some other context. 2741 * IOCTL_CALL_INVALID_CODE This IOCTL function is not recognized. 2742 * 2743 * 2744 *****************************************************************************/ 2745 osGLOBAL bit32 2746 tdsaIoEventStatisticGetIoctl( 2747 tiRoot_t *tiRoot, 2748 tiIOCTLPayload_t *agIOCTLPayload, 2749 void *agParam1, 2750 void *agParam2, 2751 void *agParam3 2752 ) 2753 { 2754 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 2755 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 2756 agsaRoot_t *agRoot = &(tdsaAllShared->agRootInt); 2757 tdIoEventStatisticPayload_t *pIoEventPayload = agNULL; 2758 bit32 status = IOCTL_CALL_SUCCESS; 2759 2760 pIoEventPayload = (tdIoEventStatisticPayload_t*)agIOCTLPayload->FunctionSpecificArea; 2761 2762 tdsaAllShared->tdFWControlEx.buffer = agNULL; 2763 tdsaAllShared->tdFWControlEx.virtAddr = agNULL; 2764 tdsaAllShared->tdFWControlEx.usrAddr = (bit8*)&agIOCTLPayload->FunctionSpecificArea[0]; 2765 tdsaAllShared->tdFWControlEx.len = 0; 2766 tdsaAllShared->tdFWControlEx.param1 = agParam1; 2767 tdsaAllShared->tdFWControlEx.param2 = agParam2; 2768 tdsaAllShared->tdFWControlEx.payload = agIOCTLPayload; 2769 tdsaAllShared->tdFWControlEx.inProgress = 0; 2770 2771 saGetIOEventStats(agRoot, agNULL, pIoEventPayload->flag); 2772 2773 return status; 2774 } 2775 2776 /***************************************************************************** 2777 * 2778 * tdsaRegisterIoctl 2779 * 2780 * Purpose: This routine is called to get Forensic Data. 2781 * 2782 * Parameters: 2783 * tiRoot: Pointer to driver instance 2784 * agIOCTLPayload: Pointer to the IOCTL payload. 2785 * agParam1: Pointer to pass context handle for IOCTL DMA operation 2786 * agParam2: Pointer to pass context handle for IOCTL DMA operation 2787 * agParam3: Pointer to pass context handle for IOCTL DMA operation 2788 * 2789 * Return: 2790 * 2791 * IOCTL_CALL_SUCCESS The requested operation completed successfully. 2792 * IOCTL_CALL_FAIL Fail to complete the IOCTL request. 2793 * Detail error code is function specific and 2794 * defined by the specific IOCTL function. 2795 * IOCTL_CALL_PENDING This request is asynchronous and completed 2796 * in some other context. 2797 * IOCTL_CALL_INVALID_CODE This IOCTL function is not recognized. 2798 * 2799 * 2800 *****************************************************************************/ 2801 osGLOBAL bit32 2802 tdsaRegisterIoctl( 2803 tiRoot_t *tiRoot, 2804 tiIOCTLPayload_t *agIOCTLPayload, 2805 void *agParam1, 2806 void *agParam2, 2807 void *agParam3 2808 ) 2809 { 2810 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 2811 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 2812 // agsaRoot_t *agRoot = &(tdsaAllShared->agRootInt); 2813 tdRegisterPayload_t *pRegisterPayload = agNULL; 2814 bit32 status = IOCTL_CALL_SUCCESS; 2815 2816 pRegisterPayload = (tdRegisterPayload_t*)agIOCTLPayload->FunctionSpecificArea; 2817 2818 tdsaAllShared->tdFWControlEx.buffer = agNULL; 2819 tdsaAllShared->tdFWControlEx.virtAddr = agNULL; 2820 tdsaAllShared->tdFWControlEx.usrAddr = (bit8*)&agIOCTLPayload->FunctionSpecificArea[0]; 2821 tdsaAllShared->tdFWControlEx.len = 0; 2822 tdsaAllShared->tdFWControlEx.param1 = agParam1; 2823 tdsaAllShared->tdFWControlEx.param2 = agParam2; 2824 tdsaAllShared->tdFWControlEx.payload = agIOCTLPayload; 2825 tdsaAllShared->tdFWControlEx.inProgress = 0; 2826 2827 TI_DBG1(("tdsaRegisterIoctl: Flag %d RegAddr 0x%x RegValue 0x%x\n", 2828 pRegisterPayload->flag, pRegisterPayload->RegAddr, pRegisterPayload->RegValue)); 2829 2830 if (pRegisterPayload->flag) 2831 { 2832 /* set register */ 2833 ostiChipWriteBit32Ext(tiRoot, 0, pRegisterPayload->RegAddr, pRegisterPayload->RegValue); 2834 } 2835 else 2836 { 2837 /* get register */ 2838 pRegisterPayload->RegValue = ostiChipReadBit32Ext(tiRoot, 0, pRegisterPayload->RegAddr); 2839 } 2840 agIOCTLPayload->Status = IOCTL_ERR_STATUS_OK; 2841 return status; 2842 } 2843 2844 osGLOBAL bit32 2845 tdsaGetPhyGeneralStatusIoctl( 2846 tiRoot_t *tiRoot, 2847 agsaPhyGeneralState_t *PhyData 2848 ) 2849 { 2850 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 2851 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 2852 agsaRoot_t *agRoot = &(tdsaAllShared->agRootNonInt); 2853 // agsaLLRoot_t *saRoot = (agsaLLRoot_t *)(agRoot->sdkData); 2854 // bit8 totalValidPhys; 2855 bit32 status = AGSA_RC_SUCCESS; 2856 bit32 i = 0; 2857 agsaControllerInfo_t ControllerInfo; 2858 saGetControllerInfo(agRoot,&ControllerInfo); 2859 2860 TI_DBG3(("tdsaGetPhyGeneralStatusIoctl: start\n")); 2861 do 2862 { 2863 if(tIsSPC(agRoot)||tIsSPCHIL(agRoot)) 2864 { 2865 status = IOCTL_ERR_STATUS_NOT_SUPPORTED; 2866 break; 2867 } 2868 2869 PhyData->Reserved1 = ControllerInfo.phyCount; 2870 for(i=0;i<PhyData->Reserved1;i++) 2871 { 2872 status = saGetPhyProfile( agRoot,agNULL,tdsaRotateQnumber(tiRoot, agNULL), AGSA_SAS_PHY_GENERAL_STATUS_PAGE,i); 2873 if(status == AGSA_RC_FAILURE) 2874 { 2875 break; 2876 } 2877 } 2878 }while(0); 2879 TI_DBG3(("tdsaGetPhyGeneralStatusIoctl: End\n")); 2880 return status; 2881 } 2882 /***************************************************************************** 2883 * 2884 * ostiGetPhyGeneralStatusRsp 2885 * 2886 * Purpose: This routine is called when a PhyStatus IOCTL response is received. 2887 * 2888 * Parameters: 2889 * tiRoot: Pointer to driver instance 2890 * agsaSASPhyGeneralStatusPage_t: Status of the phy. 2891 * bit32: phyID 2892 * 2893 * Return: none 2894 * 2895 * 2896 *****************************************************************************/ 2897 osGLOBAL void ostiGetPhyGeneralStatusRsp( 2898 tiRoot_t *tiRoot, 2899 agsaSASPhyGeneralStatusPage_t *GenStatus, 2900 bit32 phyID 2901 ) 2902 { 2903 2904 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 2905 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 2906 tiIOCTLPayload_t *agIoctlPayload = agNULL; 2907 agsaPhyGeneralState_t *pSetPhyStatusRes = agNULL; 2908 2909 2910 TI_DBG1(("ostiGetPhyGeneralStatusRsp: start\n")); 2911 2912 if (tdsaAllShared->tdFWControlEx.inProgress) 2913 { 2914 agIoctlPayload = (tiIOCTLPayload_t *)(tdsaAllShared->tdFWControlEx.payload); 2915 if ((agIoctlPayload) && (PMC_IOCTL_SIGNATURE == agIoctlPayload->Signature)&& 2916 (IOCTL_MJ_PHY_GENERAL_STATUS == agIoctlPayload->MajorFunction)) 2917 { 2918 pSetPhyStatusRes = (agsaPhyGeneralState_t*) &agIoctlPayload->FunctionSpecificArea[0]; 2919 osti_memcpy(&pSetPhyStatusRes->PhyGenData[phyID], GenStatus, sizeof(agsaSASPhyGeneralStatusPage_t)); 2920 pSetPhyStatusRes->Reserved2++; 2921 if(pSetPhyStatusRes->Reserved1 == pSetPhyStatusRes->Reserved2) 2922 { 2923 tdsaAllShared->tdFWControlEx.payload = NULL; 2924 ostiIOCTLSetSignal(tiRoot, tdsaAllShared->tdFWControlEx.param1, 2925 tdsaAllShared->tdFWControlEx.param2, agNULL); 2926 tdsaAllShared->tdFWControlEx.inProgress = 0; 2927 agIoctlPayload->Status = IOCTL_ERR_STATUS_OK; 2928 2929 } 2930 } 2931 } 2932 2933 TI_DBG1(("ostiGetPhyGeneralStatusRsp: end\n")); 2934 } 2935 2936 2937 osGLOBAL bit32 2938 tdsaPhyProfileIoctl( 2939 tiRoot_t *tiRoot, 2940 tiIOCTLPayload_t *agIOCTLPayload, 2941 void *agParam1, 2942 void *agParam2, 2943 void *agParam3 2944 ) 2945 { 2946 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 2947 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 2948 agsaRoot_t *agRoot = &(tdsaAllShared->agRootInt); 2949 void *buffer = agNULL; 2950 void *osMemHandle = agNULL; 2951 bit32 status = IOCTL_CALL_SUCCESS; 2952 bit32 retcode = AGSA_RC_FAILURE; 2953 bit32 RequestLength= agIOCTLPayload->Length; 2954 bit32 bufAddrUpper = 0; 2955 bit32 bufAddrLower = 0; 2956 2957 tdPhyCount_t *PhyBlob = (tdPhyCount_t*)&agIOCTLPayload->FunctionSpecificArea[0]; 2958 2959 2960 if(ostiAllocMemory( tiRoot, 2961 &osMemHandle, 2962 (void **)&buffer, 2963 &bufAddrUpper, 2964 &bufAddrLower, 2965 RequestLength, 2966 RequestLength, 2967 agTRUE)) 2968 return IOCTL_CALL_FAIL; 2969 2970 2971 tdsaAllShared->tdFWControlEx.buffer = osMemHandle; 2972 tdsaAllShared->tdFWControlEx.virtAddr = buffer; 2973 tdsaAllShared->tdFWControlEx.usrAddr = (bit8*)&agIOCTLPayload->FunctionSpecificArea[0]; 2974 tdsaAllShared->tdFWControlEx.len = 32; 2975 tdsaAllShared->tdFWControlEx.param1 = agParam1; 2976 tdsaAllShared->tdFWControlEx.param2 = agParam2; 2977 tdsaAllShared->tdFWControlEx.payload = agIOCTLPayload; 2978 tdsaAllShared->tdFWControlEx.inProgress = 1; 2979 2980 TI_DBG1(("tdsaPhyProfileIoctl: MinorFunction %d\n",agIOCTLPayload->MinorFunction)); 2981 // PhyBlob->Phy |= 0x100; 2982 2983 if( tiIS_SPC(agRoot) ) 2984 { 2985 TI_DBG1(("tdsaPhyProfileIoctl: SPC operation 0x%x PHY %d\n",agIOCTLPayload->MinorFunction,PhyBlob->Phy)); 2986 retcode = saLocalPhyControl(agRoot,agNULL,0 ,PhyBlob->Phy ,agIOCTLPayload->MinorFunction , agNULL); 2987 if(retcode == AGSA_RC_SUCCESS) 2988 { 2989 status = IOCTL_CALL_PENDING; 2990 } 2991 } 2992 else 2993 { 2994 TI_DBG1(("tdsaPhyProfileIoctl: SPCv operation 0x%x PHY %d\n",agIOCTLPayload->MinorFunction,PhyBlob->Phy)); 2995 retcode = saGetPhyProfile( agRoot,agNULL,0,agIOCTLPayload->MinorFunction , PhyBlob->Phy); 2996 2997 if(retcode == AGSA_RC_SUCCESS) 2998 { 2999 status = IOCTL_CALL_PENDING; 3000 } 3001 3002 } 3003 3004 TI_DBG2(("tdsaPhyProfileIoctl: after\n")); 3005 3006 3007 return status; 3008 } 3009 3010 /***************************************************************************** 3011 * 3012 * tdsaForensicDataGetIoctl 3013 * 3014 * Purpose: This routine is called to get Forensic Data. 3015 * 3016 * Parameters: 3017 * tiRoot: Pointer to driver instance 3018 * agIOCTLPayload: Pointer to the IOCTL payload. 3019 * agParam1: Pointer to pass context handle for IOCTL DMA operation 3020 * agParam2: Pointer to pass context handle for IOCTL DMA operation 3021 * agParam3: Pointer to pass context handle for IOCTL DMA operation 3022 * 3023 * Return: 3024 * 3025 * IOCTL_CALL_SUCCESS The requested operation completed successfully. 3026 * IOCTL_CALL_FAIL Fail to complete the IOCTL request. 3027 * Detail error code is function specific and 3028 * defined by the specific IOCTL function. 3029 * IOCTL_CALL_PENDING This request is asynchronous and completed 3030 * in some other context. 3031 * IOCTL_CALL_INVALID_CODE This IOCTL function is not recognized. 3032 * 3033 * 3034 *****************************************************************************/ 3035 osGLOBAL bit32 3036 tdsaForensicDataGetIoctl( 3037 tiRoot_t *tiRoot, 3038 tiIOCTLPayload_t *agIOCTLPayload, 3039 void *agParam1, 3040 void *agParam2, 3041 void *agParam3 3042 ) 3043 { 3044 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 3045 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 3046 agsaRoot_t *agRoot = &(tdsaAllShared->agRootInt); 3047 tdForensicDataPayload_t *pForensicDataPayload = agNULL; 3048 agsaForensicData_t ForensicData; 3049 bit32 status = IOCTL_CALL_SUCCESS; 3050 3051 pForensicDataPayload = (tdForensicDataPayload_t*)agIOCTLPayload->FunctionSpecificArea; 3052 3053 tdsaAllShared->tdFWControlEx.buffer = agNULL; 3054 tdsaAllShared->tdFWControlEx.virtAddr = agNULL; 3055 tdsaAllShared->tdFWControlEx.usrAddr = (bit8*)&agIOCTLPayload->FunctionSpecificArea[0]; 3056 tdsaAllShared->tdFWControlEx.len = 0; 3057 tdsaAllShared->tdFWControlEx.param1 = agParam1; 3058 tdsaAllShared->tdFWControlEx.param2 = agParam2; 3059 tdsaAllShared->tdFWControlEx.payload = agIOCTLPayload; 3060 tdsaAllShared->tdFWControlEx.inProgress = 0; 3061 3062 osti_memset(&ForensicData, 0, sizeof(agsaForensicData_t)); 3063 3064 ForensicData.DataType = pForensicDataPayload->DataType; 3065 3066 switch (ForensicData.DataType) 3067 { 3068 case FORENSIC_DATA_TYPE_NON_FATAL: 3069 case FORENSIC_DATA_TYPE_FATAL: 3070 ForensicData.BufferType.dataBuf.directLen = pForensicDataPayload->dataBuffer.directLen; 3071 ForensicData.BufferType.dataBuf.directOffset = pForensicDataPayload->dataBuffer.directOffset; 3072 ForensicData.BufferType.dataBuf.readLen = pForensicDataPayload->dataBuffer.readLen; 3073 ForensicData.BufferType.dataBuf.directData = (void*)pForensicDataPayload->dataBuffer.directData; 3074 break; 3075 case FORENSIC_DATA_TYPE_GSM_SPACE: 3076 ForensicData.BufferType.gsmBuf.directLen = pForensicDataPayload->gsmBuffer.directLen; 3077 ForensicData.BufferType.gsmBuf.directOffset = pForensicDataPayload->gsmBuffer.directOffset; 3078 ForensicData.BufferType.dataBuf.readLen = pForensicDataPayload->gsmBuffer.readLen; 3079 ForensicData.BufferType.gsmBuf.directData = (void*)pForensicDataPayload->gsmBuffer.directData; 3080 break; 3081 3082 case FORENSIC_DATA_TYPE_IB_QUEUE: 3083 ForensicData.BufferType.queueBuf.directLen = pForensicDataPayload->queueBuffer.directLen; 3084 //ForensicData.BufferType.queueBuf.queueType = pForensicDataPayload->queueBuffer.queueType; 3085 ForensicData.BufferType.queueBuf.queueType = FORENSIC_DATA_TYPE_IB_QUEUE; 3086 ForensicData.BufferType.queueBuf.queueIndex = pForensicDataPayload->queueBuffer.queueIndex; 3087 ForensicData.BufferType.queueBuf.directData = (void*)pForensicDataPayload->queueBuffer.directData; 3088 break; 3089 case FORENSIC_DATA_TYPE_OB_QUEUE: 3090 ForensicData.BufferType.queueBuf.directLen = pForensicDataPayload->queueBuffer.directLen; 3091 ForensicData.BufferType.queueBuf.queueType = FORENSIC_DATA_TYPE_OB_QUEUE; 3092 ForensicData.BufferType.queueBuf.queueIndex = pForensicDataPayload->queueBuffer.queueIndex; 3093 ForensicData.BufferType.queueBuf.directData = (void*)pForensicDataPayload->queueBuffer.directData; 3094 break; 3095 3096 default: 3097 TI_DBG1(("tdsaGetForensicDataIoctl: forensic data type error %d\n", pForensicDataPayload->DataType)); 3098 status = IOCTL_CALL_INVALID_CODE; 3099 return status; 3100 } 3101 3102 if ( saGetForensicData(agRoot, agNULL, &ForensicData) != AGSA_RC_SUCCESS ) 3103 { 3104 status = IOCTL_CALL_FAIL; 3105 } 3106 3107 return status; 3108 } 3109 3110 osGLOBAL bit32 3111 tdsaSendSMPIoctl( 3112 tiRoot_t *tiRoot, 3113 tiIOCTLPayload_t *agIOCTLPayload, 3114 void *agParam1, 3115 void *agParam2, 3116 void *agParam3 3117 ) 3118 { 3119 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 3120 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 3121 agsaRoot_t *agRoot = &(tdsaAllShared->agRootInt); 3122 void *reqBuffer = agNULL; 3123 void *respBuffer = agNULL; 3124 void *osMemHandle = agNULL; 3125 bit32 status = IOCTL_CALL_SUCCESS; 3126 // bit32 Offset = 0; 3127 // bit32 RequestLength = 0; 3128 bit32 ostiMemoryStatus = 0; 3129 smp_pass_through_req_t *smp_pass_through_req; 3130 3131 tiDeviceHandle_t *devHandle; 3132 agsaSMPFrame_t agSMPFrame; 3133 tdsaDeviceData_t *oneDeviceData = agNULL; 3134 bit32 i; 3135 3136 TI_DBG2(("tdsaSendSMPIoctl: start\n")); 3137 3138 smp_pass_through_req = (smp_pass_through_req_t*)agIOCTLPayload->FunctionSpecificArea; 3139 3140 for(i=0;i<8;i++) 3141 TI_DBG2(("SAS Address[%d]:%x",i,smp_pass_through_req->exp_sas_addr[i])); 3142 TI_DBG2(("SAS Request Length:%d",smp_pass_through_req->smp_req_len)); 3143 TI_DBG2(("SAS Response Length:%d",smp_pass_through_req->smp_resp_len)); 3144 for(i=0;i<smp_pass_through_req->smp_req_len;i++) 3145 TI_DBG2(("SAS request + %d:%x",i,smp_pass_through_req->smp_req_resp[i])); 3146 3147 devHandle = ostiGetDevHandleFromSasAddr(tiRoot, smp_pass_through_req->exp_sas_addr); 3148 if(devHandle == NULL) 3149 { 3150 status = IOCTL_CALL_FAIL; 3151 agIOCTLPayload->Status = IOCTL_ERR_STATUS_INTERNAL_ERROR; 3152 return status; 3153 } 3154 3155 3156 3157 //agIOCTLPayload->Status = IOCTL_ERR_STATUS_OK; 3158 agIOCTLPayload->Status = IOCTL_ERR_STATUS_NOT_RESPONDING; 3159 3160 3161 3162 if((ostiMemoryStatus != tiSuccess) && (reqBuffer == agNULL )) 3163 return IOCTL_CALL_FAIL; 3164 3165 3166 tdsaAllShared->tdFWControlEx.param3 = osMemHandle; 3167 3168 3169 agSMPFrame.outFrameBuf = smp_pass_through_req->smp_req_resp; 3170 agSMPFrame.expectedRespLen = smp_pass_through_req->smp_resp_len; 3171 agSMPFrame.inFrameLen = smp_pass_through_req->smp_resp_len - 4; 3172 3173 if(!(smp_pass_through_req->smp_req_len - 8) && !tiIS_SPC(agRoot)) 3174 { 3175 agSMPFrame.flag = 1; // Direct request Indirect response 3176 agSMPFrame.outFrameLen = smp_pass_through_req->smp_req_len - 4; //Exclude header 3177 } 3178 else 3179 { 3180 3181 agSMPFrame.flag = 3; //Indirect request and Indirect response 3182 ostiMemoryStatus = ostiAllocMemory( tiRoot, 3183 &osMemHandle, 3184 (void **)&reqBuffer, 3185 &(agSMPFrame.outFrameAddrUpper32), 3186 &(agSMPFrame.outFrameAddrLower32), 3187 8, 3188 smp_pass_through_req->smp_req_len, 3189 agFALSE); 3190 tdsaAllShared->tdFWControlEx.param3 = osMemHandle; 3191 if(tiIS_SPC(agRoot)) 3192 { 3193 agSMPFrame.outFrameLen = smp_pass_through_req->smp_req_len - 4; //Exclude crc 3194 osti_memcpy((void *)reqBuffer, (void *)(smp_pass_through_req->smp_req_resp), smp_pass_through_req->smp_req_len); 3195 } 3196 else 3197 { 3198 agSMPFrame.outFrameLen = smp_pass_through_req->smp_req_len - 8; //Exclude header and crc 3199 osti_memcpy((void *)reqBuffer, (void *)(smp_pass_through_req->smp_req_resp + 4), smp_pass_through_req->smp_req_len - 4); 3200 } 3201 } 3202 3203 ostiMemoryStatus = ostiAllocMemory( tiRoot, 3204 &osMemHandle, 3205 (void **)&respBuffer, 3206 &(agSMPFrame.inFrameAddrUpper32), 3207 &(agSMPFrame.inFrameAddrLower32), 3208 8, 3209 smp_pass_through_req->smp_resp_len + 4, 3210 agFALSE); 3211 if((ostiMemoryStatus != tiSuccess) && (respBuffer == agNULL )) 3212 return IOCTL_CALL_FAIL; 3213 3214 3215 osti_memset((void *)respBuffer, 0, smp_pass_through_req->smp_resp_len); 3216 3217 // use FW control place in shared structure to keep the neccesary information 3218 tdsaAllShared->tdFWControlEx.buffer = osMemHandle; 3219 tdsaAllShared->tdFWControlEx.virtAddr = respBuffer; 3220 tdsaAllShared->tdFWControlEx.usrAddr = (bit8*)smp_pass_through_req->smp_req_resp + smp_pass_through_req->smp_req_len; 3221 tdsaAllShared->tdFWControlEx.len = smp_pass_through_req->smp_resp_len; 3222 tdsaAllShared->tdFWControlEx.param1 = agParam1; 3223 tdsaAllShared->tdFWControlEx.param2 = agParam2; 3224 tdsaAllShared->tdFWControlEx.payload = agIOCTLPayload; 3225 tdsaAllShared->tdFWControlEx.inProgress = 1; 3226 status = IOCTL_CALL_PENDING; 3227 3228 oneDeviceData = (tdsaDeviceData_t *)devHandle->tdData; 3229 if(saSendSMPIoctl(agRoot, oneDeviceData->agDevHandle, 0, &agSMPFrame, &ossaSMPIoctlCompleted) != AGSA_RC_SUCCESS) 3230 { 3231 status = IOCTL_CALL_FAIL; 3232 agIOCTLPayload->Status = IOCTL_ERR_STATUS_INTERNAL_ERROR; 3233 } 3234 return status; 3235 } 3236 3237 osGLOBAL void ostiSendSMPIOCTLRsp( 3238 tiRoot_t *tiRoot, 3239 bit32 status 3240 ) 3241 { 3242 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 3243 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 3244 tiIOCTLPayload_t *agIOCTLPayload; 3245 3246 agIOCTLPayload = (tiIOCTLPayload_t *)(tdsaAllShared->tdFWControlEx.payload); 3247 agIOCTLPayload->Status = (bit16)status; 3248 3249 TI_DBG1(("ostiSendSMPIOCTLRsp: start, status = %d\n", status)); 3250 3251 // if(tdsaAllShared->tdFWControlEx.param1 != agNULL) 3252 // { 3253 osti_memcpy((void *)(tdsaAllShared->tdFWControlEx.usrAddr), 3254 (void *)(tdsaAllShared->tdFWControlEx.virtAddr), 3255 tdsaAllShared->tdFWControlEx.len); 3256 // } 3257 ostiFreeMemory(tiRoot, 3258 tdsaAllShared->tdFWControlEx.buffer, 3259 tdsaAllShared->tdFWControlEx.len); 3260 ostiFreeMemory(tiRoot, 3261 tdsaAllShared->tdFWControlEx.param3, 3262 tdsaAllShared->tdFWControlEx.len); 3263 //if(tdsaAllShared->tdFWControlEx.param1 != agNULL) 3264 // { 3265 ostiIOCTLComplete(tiRoot, 3266 tdsaAllShared->tdFWControlEx.param1, 3267 tdsaAllShared->tdFWControlEx.param2, 3268 NULL); 3269 // } 3270 } 3271 3272 3273 3274 3275 /***************************************************************************** 3276 * 3277 * tdsaSendBISTIoctl 3278 * 3279 * Purpose: This routine is called to get Forensic Data. 3280 * 3281 * Parameters: 3282 * tiRoot: Pointer to driver instance 3283 * agIOCTLPayload: Pointer to the IOCTL payload. 3284 * agParam1: Pointer to pass context handle for IOCTL DMA operation 3285 * agParam2: Pointer to pass context handle for IOCTL DMA operation 3286 * agParam3: Pointer to pass context handle for IOCTL DMA operation 3287 * 3288 * Return: 3289 * 3290 * IOCTL_CALL_SUCCESS The requested operation completed successfully. 3291 * IOCTL_CALL_FAIL Fail to complete the IOCTL request. 3292 * Detail error code is function specific and 3293 * defined by the specific IOCTL function. 3294 * IOCTL_CALL_PENDING This request is asynchronous and completed 3295 * in some other context. 3296 * IOCTL_CALL_INVALID_CODE This IOCTL function is not recognized. 3297 * 3298 * 3299 *****************************************************************************/ 3300 osGLOBAL bit32 3301 tdsaSendBISTIoctl( 3302 tiRoot_t *tiRoot, 3303 tiIOCTLPayload_t *agIOCTLPayload, 3304 void *agParam1, 3305 void *agParam2, 3306 void *agParam3 3307 ) 3308 { 3309 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 3310 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 3311 agsaRoot_t *agRoot = &(tdsaAllShared->agRootInt); 3312 tdBistPayload_t *pBistPayload; 3313 // bit32 length = 0; 3314 // bit32 status = IOCTL_CALL_SUCCESS; 3315 bit32 status = IOCTL_CALL_FAIL; 3316 3317 pBistPayload = (tdBistPayload_t*)agIOCTLPayload->FunctionSpecificArea; 3318 3319 tdsaAllShared->tdFWControlEx.buffer = agNULL; 3320 tdsaAllShared->tdFWControlEx.virtAddr = agNULL; 3321 tdsaAllShared->tdFWControlEx.usrAddr = (bit8*)&agIOCTLPayload->FunctionSpecificArea[0]; 3322 tdsaAllShared->tdFWControlEx.len = 0; 3323 tdsaAllShared->tdFWControlEx.param1 = agParam1; 3324 tdsaAllShared->tdFWControlEx.param2 = agParam2; 3325 tdsaAllShared->tdFWControlEx.payload = agIOCTLPayload; 3326 tdsaAllShared->tdFWControlEx.inProgress = 0; 3327 3328 TI_DBG1(("tdsaSendBISTIoctl: Type %d Length %d Data %p\n", 3329 pBistPayload->testType, 3330 pBistPayload->testLength, 3331 pBistPayload->testData )); 3332 3333 3334 // pBistPayload->testtype = AGSA_BIST_TEST; 3335 3336 if( pBistPayload->testType == AGSA_BIST_TEST) 3337 { 3338 if( pBistPayload->testLength != sizeof(agsaEncryptSelfTestBitMap_t)) 3339 { 3340 return status; 3341 } 3342 } 3343 else if( pBistPayload->testType == AGSA_SHA_TEST) 3344 { 3345 if( pBistPayload->testLength != sizeof(agsaEncryptSHATestDescriptor_t) ) 3346 { 3347 return status; 3348 } 3349 } 3350 else if( pBistPayload->testType == AGSA_HMAC_TEST ) 3351 { 3352 if( pBistPayload->testLength != sizeof(agsaEncryptHMACTestDescriptor_t)) 3353 { 3354 return status; 3355 } 3356 } 3357 3358 /* 3359 GLOBAL bit32 saEncryptSelftestExecute( 3360 agsaRoot_t *agRoot, 3361 agsaContext_t *agContext, 3362 bit32 queueNum, 3363 bit32 type, 3364 bit32 length, 3365 void *TestDescriptor); 3366 3367 */ 3368 if ( saEncryptSelftestExecute(agRoot, 3369 agNULL, 3370 0, 3371 pBistPayload->testType, 3372 pBistPayload->testLength, 3373 pBistPayload->testData ) != AGSA_RC_SUCCESS ) 3374 { 3375 status = IOCTL_CALL_FAIL; 3376 } 3377 3378 return status; 3379 } 3380 3381 3382 osGLOBAL bit32 3383 tdsaSendTMFIoctl( tiRoot_t *tiRoot, 3384 tiIOCTLPayload_t *agIOCTLPayload, 3385 void *agParam1, 3386 void *agParam2, 3387 unsigned long resetType 3388 ) 3389 { 3390 bit32 status; 3391 tmf_pass_through_req_t *tmf_req = (tmf_pass_through_req_t*)agIOCTLPayload->FunctionSpecificArea; 3392 #if !(defined(__FreeBSD__)) 3393 status = ostiSendResetDeviceIoctl(tiRoot, agParam2, tmf_req->pathId, tmf_req->targetId, tmf_req->lun, resetType); 3394 #endif 3395 TI_DBG3(("Status returned from ostiSendResetDeviceIoctl is %d\n",status)); 3396 if(status != IOCTL_CALL_SUCCESS) 3397 { 3398 agIOCTLPayload->Status = status; 3399 return status; 3400 } 3401 status = IOCTL_CALL_SUCCESS; 3402 return status; 3403 } 3404 3405 3406 #ifdef VPD_TESTING 3407 /* temporary to test saSetVPDCommand() and saGetVPDCommand */ 3408 osGLOBAL bit32 3409 tdsaVPDSet( 3410 tiRoot_t *tiRoot 3411 ) 3412 { 3413 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 3414 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 3415 agsaRoot_t *agRoot = &(tdsaAllShared->agRootInt); 3416 bit32 status = IOCTL_CALL_SUCCESS; 3417 agsaVPD_t VPDInfo; 3418 bit32 ret = AGSA_RC_SUCCESS; 3419 3420 bit32 bufAddrUpper = 0; 3421 bit32 bufAddrLower = 0; 3422 tdVPDControl_t *VPDControl; 3423 3424 void *osMemHandle = agNULL; 3425 void *buffer; 3426 bit32 timeCount=0; 3427 bit8 ioctlErr=0; 3428 bit8 VPDPayload[32]; 3429 bit8 i; 3430 TI_DBG2(("tdsaVPDSet: start\n")); 3431 3432 for(i=0;i<sizeof(VPDPayload);i++) 3433 { 3434 VPDPayload[i] = i; 3435 } 3436 if(ostiAllocMemory( tiRoot, 3437 &osMemHandle, 3438 (void **)&buffer, 3439 &bufAddrUpper, 3440 &bufAddrLower, 3441 8, 3442 sizeof(VPDPayload), 3443 agFALSE)) 3444 { 3445 return tiError; 3446 } 3447 osti_memcpy((void *)buffer, 3448 VPDPayload, 3449 sizeof(VPDPayload)); 3450 3451 3452 osti_memset(&VPDInfo, 0, sizeof(agsaVPD_t)); 3453 #ifdef NOT_YET /* direct mode worked */ 3454 /* For now, only direct mode */ 3455 VPDInfo.indirectMode = 0; /* direct mode */ 3456 VPDInfo.VPDDevice = 1; /* SEEPROM-1 */ 3457 VPDInfo.directLen = (bit8)sizeof(VPDPayload); 3458 VPDInfo.VPDOffset = 0; 3459 VPDInfo.directData = buffer; 3460 VPDInfo.indirectAddrUpper32 = bufAddrUpper; 3461 VPDInfo.indirectAddrLower32 = bufAddrLower; 3462 VPDInfo.indirectLen = sizeof(VPDPayload); 3463 #endif 3464 3465 /* indirect mode */ 3466 VPDInfo.indirectMode = 1; /* indirect mode */ 3467 VPDInfo.VPDDevice = 1; /* SEEPROM-1 */ 3468 VPDInfo.directLen = 0; 3469 VPDInfo.VPDOffset = 0; 3470 VPDInfo.directData = agNULL; 3471 VPDInfo.indirectAddrUpper32 = bufAddrUpper; 3472 VPDInfo.indirectAddrLower32 = bufAddrLower; 3473 VPDInfo.indirectLen = sizeof(VPDPayload); 3474 3475 tdsaAllShared->tdFWControlEx.buffer = osMemHandle; 3476 tdsaAllShared->tdFWControlEx.param1 = agParam1; 3477 tdsaAllShared->tdFWControlEx.param2 = agParam2; 3478 3479 /* for testing only */ 3480 tdsaAllShared->addrUpper = bufAddrUpper; 3481 tdsaAllShared->addrLower = bufAddrLower; 3482 3483 ret = saSetVPDCommand(agRoot, agNULL, 0, &VPDInfo); 3484 3485 if (ret == AGSA_RC_SUCCESS) 3486 { 3487 status = tiSuccess; 3488 } 3489 else 3490 { 3491 status = tiError; 3492 } 3493 3494 ostiFreeMemory(tiRoot, osMemHandle, sizeof(VPDPayload)); 3495 return status; 3496 } 3497 3498 /* temporary to test saSetVPDCommand() and saGetVPDCommand */ 3499 osGLOBAL bit32 3500 tdsaVPDGet(tiRoot_t *tiRoot) 3501 { 3502 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 3503 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 3504 agsaRoot_t *agRoot = &(tdsaAllShared->agRootInt); 3505 bit32 status = IOCTL_CALL_SUCCESS; 3506 agsaVPD_t VPDInfo; 3507 bit32 ret = AGSA_RC_SUCCESS; 3508 3509 3510 TI_DBG2(("tdsaVPDGet: start\n")); 3511 3512 osti_memset(&VPDInfo, 0, sizeof(agsaVPD_t)); 3513 3514 /* direct mode worked */ 3515 VPDInfo.indirectMode = 0; /* direct mode */ 3516 VPDInfo.VPDDevice = 1; /* SEEPROM-1*/ 3517 VPDInfo.directLen = 32; 3518 VPDInfo.VPDOffset = 0; 3519 VPDInfo.directData = agNULL; 3520 VPDInfo.indirectAddrUpper32 = 0; 3521 VPDInfo.indirectAddrLower32 = 0; 3522 VPDInfo.indirectLen = 0; 3523 3524 3525 #ifdef NOT_YET /* worked; can't read VPD in ossaGetVPDResponseCB() because of indirect */ 3526 VPDInfo.indirectMode = 1; /* direct mode */ 3527 VPDInfo.VPDDevice = 1; /* SEEPROM-1*/ 3528 VPDInfo.directLen = 0; 3529 VPDInfo.VPDOffset = 0; 3530 VPDInfo.directData = agNULL; 3531 VPDInfo.indirectAddrUpper32 = tdsaAllShared->addrUpper; 3532 VPDInfo.indirectAddrLower32 = tdsaAllShared->addrLower; 3533 VPDInfo.indirectLen = 32; 3534 #endif 3535 ret = saGetVPDCommand(agRoot, agNULL, 0, &VPDInfo); 3536 3537 if (ret == AGSA_RC_SUCCESS) 3538 { 3539 status = tiSuccess; 3540 } 3541 else 3542 { 3543 status = tiError; 3544 } 3545 return status; 3546 } 3547 #endif 3548 /***************************************************************************** 3549 * 3550 * tdsaGetNumOfLUNIOCTL 3551 * 3552 * Purpose: This routine is called to send Report LUN SSP command request. 3553 * 3554 * Parameters: 3555 * tiRoot: Pointer to driver instance 3556 * tiIOCTLPayload_t: Status of the Controller Reset. 3557 * agParam1: Void pointer to device extension 3558 * agParam2: Void pointer to SRB 3559 * agParam3: NULL 3560 * 3561 * Return: status 3562 * 3563 * 3564 *****************************************************************************/ 3565 osGLOBAL bit32 3566 tdsaGetNumOfLUNIOCTL( 3567 tiRoot_t *tiRoot, 3568 tiIOCTLPayload_t *agIOCTLPayload, 3569 void *agParam1, 3570 void *agParam2, 3571 void *agParam3 3572 ) 3573 { 3574 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 3575 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 3576 agsaRoot_t *agRoot = &(tdsaAllShared->agRootInt); 3577 tdDeviceLUNInfoIOCTL_t *pDeviceLUNInfo = agNULL; 3578 tiDeviceHandle_t *devHandle = agNULL; 3579 void *tiRequestBody = agNULL; 3580 tiIORequest_t *tiIORequest = agNULL; 3581 bit32 status = IOCTL_CALL_SUCCESS; 3582 3583 TI_DBG2(("tdsaGetNumOfLUNIOCTL: Start\n")); 3584 do 3585 { 3586 pDeviceLUNInfo = (tdDeviceLUNInfoIOCTL_t*)agIOCTLPayload->FunctionSpecificArea; 3587 3588 if (agIOCTLPayload->Length < sizeof(tdDeviceLUNInfoIOCTL_t)) 3589 { 3590 status = IOCTL_CALL_FAIL; 3591 break; 3592 } 3593 if(!pDeviceLUNInfo->tiDeviceHandle) 3594 { 3595 status = IOCTL_CALL_FAIL; 3596 agIOCTLPayload->Status = IOCTL_ERR_STATUS_INTERNAL_ERROR; 3597 break; 3598 } 3599 devHandle = (tiDeviceHandle_t*)pDeviceLUNInfo->tiDeviceHandle; 3600 agIOCTLPayload->Status = IOCTL_ERR_STATUS_OK; 3601 3602 status = ostiNumOfLUNIOCTLreq(tiRoot,agParam1,agParam2,&tiRequestBody,&tiIORequest); 3603 3604 3605 if(status != AGSA_RC_SUCCESS) 3606 { 3607 agIOCTLPayload->Status = IOCTL_ERR_STATUS_INTERNAL_ERROR; 3608 break; 3609 } 3610 status = tiNumOfLunIOCTLreq(tiRoot,tiIORequest,devHandle,tiRequestBody,agIOCTLPayload,agParam1,agParam2); 3611 3612 if(status != AGSA_RC_SUCCESS) 3613 { 3614 agIOCTLPayload->Status = IOCTL_ERR_STATUS_INTERNAL_ERROR; 3615 break; 3616 } 3617 // ostiIOCTLWaitForSignal (tiRoot, agParam1, agParam2, agParam3); 3618 3619 }while(0); 3620 TI_DBG2(("tdsaGetNumOfLUNIOCTL: End\n")); 3621 return status; 3622 } 3623 3624 3625 /***************************************************************************** 3626 * 3627 * ostiNumOfLUNIOCTLRsp 3628 * 3629 * Purpose: This routine is called when a Report LUN SSP command response id recieved. 3630 * 3631 * Parameters: 3632 * tiRoot: Pointer to driver instance 3633 * bit32 status 3634 * 3635 * Return: none 3636 * 3637 * 3638 *****************************************************************************/ 3639 osGLOBAL void ostiNumOfLUNIOCTLRsp( 3640 tiRoot_t *tiRoot, 3641 bit32 status 3642 ) 3643 { 3644 tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData; 3645 tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared; 3646 tiIOCTLPayload_t *agIOCTLPayload; 3647 tdDeviceLUNInfoIOCTL_t *pDeviceLUNInfo = NULL; 3648 bit32 count = 0; 3649 bit32 numOfLUN =0; 3650 3651 TI_DBG1(("ostiNumOfLUNIOCTLRsp: start, status = %d\n", status)); 3652 3653 if(tdsaAllShared->tdFWControlEx.inProgress == 1) 3654 { 3655 agIOCTLPayload = (tiIOCTLPayload_t *)(tdsaAllShared->tdFWControlEx.payload); 3656 if ((agIOCTLPayload) && (PMC_IOCTL_SIGNATURE == agIOCTLPayload->Signature)&& 3657 (IOCTL_MJ_GET_DEVICE_LUN == agIOCTLPayload->MajorFunction)) 3658 { 3659 agIOCTLPayload->Status = (bit16)status; 3660 pDeviceLUNInfo = (tdDeviceLUNInfoIOCTL_t*)agIOCTLPayload->FunctionSpecificArea; 3661 numOfLUN = ((tdsaAllShared->tdFWControlEx.virtAddr[0] << 24)|(tdsaAllShared->tdFWControlEx.virtAddr[1] << 16)|\ 3662 (tdsaAllShared->tdFWControlEx.virtAddr[2] << 8)|(tdsaAllShared->tdFWControlEx.virtAddr[3])); 3663 numOfLUN = numOfLUN/8; 3664 pDeviceLUNInfo->numOfLun = numOfLUN; 3665 // ostiFreeMemory(tiRoot, 3666 // tdsaAllShared->tdFWControlEx.virtAddr, 3667 // tdsaAllShared->tdFWControlEx.len); 3668 // if(tdsaAllShared->tdFWControlEx.param1 != agNULL) 3669 // { 3670 ostiIOCTLSetSignal(tiRoot, 3671 tdsaAllShared->tdFWControlEx.param1, 3672 tdsaAllShared->tdFWControlEx.param2, 3673 NULL); 3674 tdsaAllShared->tdFWControlEx.payload = NULL; 3675 // } 3676 3677 tdsaAllShared->tdFWControlEx.inProgress = 0; 3678 } 3679 } 3680 TI_DBG1(("ostiNumOfLUNIOCTLRsp: End\n")); 3681 } 3682 3683